From 7677c370115faa49759b72f5d7c9debfe1081e35 Mon Sep 17 00:00:00 2001
From: weixuanhu <44716380+weixuanhu@users.noreply.github.com>
Date: Mon, 6 May 2019 17:54:31 +0800
Subject: [PATCH 001/348] update 'sorted' to 'ascending sorted' in comments
 (#789)

To avoid confusion all 'sorted' to 'ascending sorted' in comments
---
 searches/binary_search.py | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/searches/binary_search.py b/searches/binary_search.py
index 7df45883c09a..1d5da96586cd 100644
--- a/searches/binary_search.py
+++ b/searches/binary_search.py
@@ -21,10 +21,10 @@
 def binary_search(sorted_collection, item):
     """Pure implementation of binary search algorithm in Python
 
-    Be careful collection must be sorted, otherwise result will be
+    Be careful collection must be ascending sorted, otherwise result will be
     unpredictable
 
-    :param sorted_collection: some sorted collection with comparable items
+    :param sorted_collection: some ascending sorted collection with comparable items
     :param item: item value to search
     :return: index of found item or None if item is not found
 
@@ -60,10 +60,10 @@ def binary_search(sorted_collection, item):
 def binary_search_std_lib(sorted_collection, item):
     """Pure implementation of binary search algorithm in Python using stdlib
 
-    Be careful collection must be sorted, otherwise result will be
+    Be careful collection must be ascending sorted, otherwise result will be
     unpredictable
 
-    :param sorted_collection: some sorted collection with comparable items
+    :param sorted_collection: some ascending sorted collection with comparable items
     :param item: item value to search
     :return: index of found item or None if item is not found
 
@@ -89,11 +89,11 @@ def binary_search_by_recursion(sorted_collection, item, left, right):
 
     """Pure implementation of binary search algorithm in Python by recursion
 
-    Be careful collection must be sorted, otherwise result will be
+    Be careful collection must be ascending sorted, otherwise result will be
     unpredictable
     First recursion should be started with left=0 and right=(len(sorted_collection)-1)
 
-    :param sorted_collection: some sorted collection with comparable items
+    :param sorted_collection: some ascending sorted collection with comparable items
     :param item: item value to search
     :return: index of found item or None if item is not found
 
@@ -123,11 +123,11 @@ def binary_search_by_recursion(sorted_collection, item, left, right):
         return binary_search_by_recursion(sorted_collection, item, midpoint+1, right)
       
 def __assert_sorted(collection):
-    """Check if collection is sorted, if not - raises :py:class:`ValueError`
+    """Check if collection is ascending sorted, if not - raises :py:class:`ValueError`
 
     :param collection: collection
-    :return: True if collection is sorted
-    :raise: :py:class:`ValueError` if collection is not sorted
+    :return: True if collection is ascending sorted
+    :raise: :py:class:`ValueError` if collection is not ascending sorted
 
     Examples:
     >>> __assert_sorted([0, 1, 2, 4])
@@ -136,10 +136,10 @@ def __assert_sorted(collection):
     >>> __assert_sorted([10, -1, 5])
     Traceback (most recent call last):
     ...
-    ValueError: Collection must be sorted
+    ValueError: Collection must be ascending sorted
     """
     if collection != sorted(collection):
-        raise ValueError('Collection must be sorted')
+        raise ValueError('Collection must be ascending sorted')
     return True
 
 
@@ -150,7 +150,7 @@ def __assert_sorted(collection):
     try:
         __assert_sorted(collection)
     except ValueError:
-        sys.exit('Sequence must be sorted to apply binary search')
+        sys.exit('Sequence must be ascending sorted to apply binary search')
 
     target_input = raw_input('Enter a single number to be found in the list:\n')
     target = int(target_input)

From 30a358298385e0e29b70a841d0b4019dc235f3a3 Mon Sep 17 00:00:00 2001
From: Lorenz Nickel <lorenz.nickel@gmx.net>
Date: Wed, 8 May 2019 21:48:30 +0200
Subject: [PATCH 002/348] fix: replaced outdated url (#791)

http://www.lpb-riannetrujillo.com/blog/python-fractal/ moved to http://www.riannetrujillo.com/blog/python-fractal/
---
 other/sierpinski_triangle.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/other/sierpinski_triangle.py b/other/sierpinski_triangle.py
index 6a06058fe03e..329a8ce5c43f 100644
--- a/other/sierpinski_triangle.py
+++ b/other/sierpinski_triangle.py
@@ -21,7 +21,7 @@
 Usage:
   - $python sierpinski_triangle.py <int:depth_for_fractal>
 
-Credits: This code was written by editing the code from http://www.lpb-riannetrujillo.com/blog/python-fractal/
+Credits: This code was written by editing the code from http://www.riannetrujillo.com/blog/python-fractal/
 
 '''
 import turtle
@@ -64,4 +64,4 @@ def triangle(points,depth):
                    depth-1)
 
 
-triangle(points,int(sys.argv[1]))
\ No newline at end of file
+triangle(points,int(sys.argv[1]))

From 56513cb21f759ac26b31ac1edcb45d886a97f715 Mon Sep 17 00:00:00 2001
From: Junth Basnet <25685098+Junth19@users.noreply.github.com>
Date: Fri, 10 May 2019 16:48:05 +0545
Subject: [PATCH 003/348] add-binary-exponentiation (#790)

---
 maths/BinaryExponentiation.py | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 maths/BinaryExponentiation.py

diff --git a/maths/BinaryExponentiation.py b/maths/BinaryExponentiation.py
new file mode 100644
index 000000000000..2411cd58a76b
--- /dev/null
+++ b/maths/BinaryExponentiation.py
@@ -0,0 +1,25 @@
+#Author : Junth Basnet
+#Time Complexity : O(logn)
+
+def binary_exponentiation(a, n):
+    
+    if (n == 0):
+        return 1
+    
+    elif (n % 2 == 1):
+        return binary_exponentiation(a, n - 1) * a
+    
+    else:
+        b = binary_exponentiation(a, n / 2)
+        return b * b
+
+    
+try:
+    base = int(input('Enter Base : '))
+    power = int(input("Enter Power : "))
+except ValueError:
+    print ("Invalid literal for integer")
+
+result = binary_exponentiation(base, power)
+print("{}^({}) : {}".format(base, power, result))
+    

From 36828b106f7905ecc0c0776e40c99929728a91a9 Mon Sep 17 00:00:00 2001
From: Julien Castiaux <Julien.castiaux@gmail.com>
Date: Sat, 11 May 2019 13:20:25 +0200
Subject: [PATCH 004/348] [FIX] maths/PrimeCheck (#796)

Current implementation is buggy and hard to read.

* Negative values were raising a TypeError due to `math.sqrt`
* 1 was considered prime, it is not.
* 2 was considered not prime, it is.

The implementation has been corrected to fix the bugs and to enhance
readability.

A docstring has been added with the definition of a prime number.

A complete test suite has been written, it tests the 10 first primes, a
negative value, 0, 1 and some not prime numbers.

closes #795
---
 maths/PrimeCheck.py | 55 +++++++++++++++++++++++++++++++++++++++------
 1 file changed, 48 insertions(+), 7 deletions(-)

diff --git a/maths/PrimeCheck.py b/maths/PrimeCheck.py
index e0c51d77a038..8c5c181689dd 100644
--- a/maths/PrimeCheck.py
+++ b/maths/PrimeCheck.py
@@ -1,13 +1,54 @@
 import math
+import unittest
+
+
 def primeCheck(number):
-    if number % 2 == 0 and number > 2: 
+    """
+    A number is prime if it has exactly two dividers: 1 and itself.
+    """
+    if number < 2:
+        # Negatives, 0 and 1 are not primes
         return False
-    return all(number % i for i in range(3, int(math.sqrt(number)) + 1, 2))
+    if number < 4:
+        # 2 and 3 are primes
+        return True
+    if number % 2 == 0:
+        # Even values are not primes
+        return False
+
+    # Except 2, all primes are odd. If any odd value divide
+    # the number, then that number is not prime.
+    odd_numbers = range(3, int(math.sqrt(number)) + 1, 2)
+    return not any(number % i == 0 for i in odd_numbers)
+
+
+class Test(unittest.TestCase):
+    def test_primes(self):
+        self.assertTrue(primeCheck(2))
+        self.assertTrue(primeCheck(3))
+        self.assertTrue(primeCheck(5))
+        self.assertTrue(primeCheck(7))
+        self.assertTrue(primeCheck(11))
+        self.assertTrue(primeCheck(13))
+        self.assertTrue(primeCheck(17))
+        self.assertTrue(primeCheck(19))
+        self.assertTrue(primeCheck(23))
+        self.assertTrue(primeCheck(29))
+
+    def test_not_primes(self):
+        self.assertFalse(primeCheck(-19),
+                "Negative numbers are not prime.")
+        self.assertFalse(primeCheck(0),
+                "Zero doesn't have any divider, primes must have two")
+        self.assertFalse(primeCheck(1),
+                "One just have 1 divider, primes must have two.")
+        self.assertFalse(primeCheck(2 * 2))
+        self.assertFalse(primeCheck(2 * 3))
+        self.assertFalse(primeCheck(3 * 3))
+        self.assertFalse(primeCheck(3 * 5))
+        self.assertFalse(primeCheck(3 * 5 * 7))
 
-def main():
-    print(primeCheck(37))
-    print(primeCheck(100))
-    print(primeCheck(77))
 
 if __name__ == '__main__':
-	main()
+    unittest.main()
+

From d8badcc6d5568e3ed8b060305f6d02e74019f1a4 Mon Sep 17 00:00:00 2001
From: Anup Kumar Panwar <1anuppanwar@gmail.com>
Date: Sun, 12 May 2019 09:10:56 +0530
Subject: [PATCH 005/348] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 1e43deb6bdef..9b61f1b63287 100644
--- a/README.md
+++ b/README.md
@@ -1,5 +1,5 @@
 # The Algorithms - Python <!-- [![Build Status](https://travis-ci.org/TheAlgorithms/Python.svg)](https://travis-ci.org/TheAlgorithms/Python) -->
-[![Donate](https://img.shields.io/badge/Donate-PayPal-green.svg)](https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=JP3BLXA6KMDGW)
+[![Donate](https://img.shields.io/badge/Donate-PayPal-green.svg)](https://www.paypal.me/TheAlgorithms/100)
 
 
 ### All algorithms implemented in Python (for education)

From 3f7bec6c00c089490c8b5d38686373ca6e1ea97b Mon Sep 17 00:00:00 2001
From: Bhushan Borole <37565807+bhushan-borole@users.noreply.github.com>
Date: Sun, 12 May 2019 17:16:47 +0530
Subject: [PATCH 006/348] Added page-rank algorithm implementation (#780)

* Added page-rank algorithm implementation

* changed init variables
---
 Graphs/pagerank.py | 72 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 72 insertions(+)
 create mode 100644 Graphs/pagerank.py

diff --git a/Graphs/pagerank.py b/Graphs/pagerank.py
new file mode 100644
index 000000000000..59f15a99e6b2
--- /dev/null
+++ b/Graphs/pagerank.py
@@ -0,0 +1,72 @@
+'''
+Author: https://github.com/bhushan-borole
+'''
+'''
+The input graph for the algorithm is:
+
+  A B C
+A 0 1 1
+B 0 0 1
+C 1 0 0
+
+'''
+
+graph = [[0, 1, 1],
+    	[0, 0, 1],
+    	[1, 0, 0]]
+
+
+class Node:
+    def __init__(self, name):
+        self.name = name
+        self.inbound = []
+        self.outbound = []
+    
+    def add_inbound(self, node):
+        self.inbound.append(node)
+    
+    def add_outbound(self, node):
+        self.outbound.append(node)
+    
+    def __repr__(self):
+        return 'Node {}: Inbound: {} ; Outbound: {}'.format(self.name,
+                                                      	self.inbound,
+                                                      	self.outbound)
+
+
+def page_rank(nodes, limit=3, d=0.85):
+    ranks = {}
+    for node in nodes:
+        ranks[node.name] = 1
+
+    outbounds = {}
+    for node in nodes:
+        outbounds[node.name] = len(node.outbound)
+
+    for i in range(limit):
+        print("======= Iteration {} =======".format(i+1))
+        for j, node in enumerate(nodes):
+            ranks[node.name] = (1 - d) + d * sum([ ranks[ib]/outbounds[ib] for ib in node.inbound ])
+        print(ranks)
+
+
+def main():
+    names = list(input('Enter Names of the Nodes: ').split())
+
+    nodes = [Node(name) for name in names]
+    
+    for ri, row in enumerate(graph):
+        for ci, col in enumerate(row):
+            if col == 1:
+                nodes[ci].add_inbound(names[ri])
+                nodes[ri].add_outbound(names[ci])
+
+    print("======= Nodes =======")
+    for node in nodes:
+        print(node)
+
+    page_rank(nodes)
+
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file

From 70bb6b2f18bec6cadca052d96e526d014d18ff32 Mon Sep 17 00:00:00 2001
From: Ravi Patel <ravi.patel1245@gmail.com>
Date: Mon, 13 May 2019 01:15:27 -0400
Subject: [PATCH 007/348] Added Huffman Coding Algorithm (#798)

---
 compression/huffman.py | 87 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 87 insertions(+)
 create mode 100644 compression/huffman.py

diff --git a/compression/huffman.py b/compression/huffman.py
new file mode 100644
index 000000000000..b6238b66e9fd
--- /dev/null
+++ b/compression/huffman.py
@@ -0,0 +1,87 @@
+import sys
+
+class Letter:
+    def __init__(self, letter, freq):
+        self.letter = letter
+        self.freq = freq
+        self.bitstring = ""
+
+    def __repr__(self):
+        return f'{self.letter}:{self.freq}'
+
+
+class TreeNode:
+    def __init__(self, freq, left, right):
+        self.freq = freq
+        self.left = left
+        self.right = right
+
+
+def parse_file(file_path):
+    """ 
+    Read the file and build a dict of all letters and their
+    frequences, then convert the dict into a list of Letters.
+    """
+    chars = {}
+    with open(file_path) as f:
+        while True:
+            c = f.read(1)
+            if not c:
+                break
+            chars[c] = chars[c] + 1 if c in chars.keys() else 1
+    letters = []
+    for char, freq in chars.items():
+        letter = Letter(char, freq)
+        letters.append(letter)
+    letters.sort(key=lambda l: l.freq)
+    return letters
+
+def build_tree(letters):
+    """ 
+    Run through the list of Letters and build the min heap
+    for the Huffman Tree.
+    """
+    while len(letters) > 1:
+        left = letters.pop(0)
+        right = letters.pop(0)
+        total_freq = left.freq + right.freq
+        node = TreeNode(total_freq, left, right)
+        letters.append(node)
+        letters.sort(key=lambda l: l.freq)
+    return letters[0]
+
+def traverse_tree(root, bitstring):
+    """ 
+    Recursively traverse the Huffman Tree to set each
+    Letter's bitstring, and return the list of Letters
+    """
+    if type(root) is Letter:
+        root.bitstring = bitstring
+        return [root]
+    letters = []
+    letters += traverse_tree(root.left, bitstring + "0")
+    letters += traverse_tree(root.right, bitstring + "1")
+    return letters
+
+def huffman(file_path):
+    """ 
+    Parse the file, build the tree, then run through the file
+    again, using the list of Letters to find and print out the 
+    bitstring for each letter.
+    """
+    letters_list = parse_file(file_path)
+    root = build_tree(letters_list)
+    letters = traverse_tree(root, "")
+    print(f'Huffman Coding of {file_path}: ')
+    with open(file_path) as f:
+        while True:
+            c = f.read(1)
+            if not c:
+                break
+            le = list(filter(lambda l: l.letter == c, letters))[0]
+            print(le.bitstring, end=" ")
+    print()
+
+if __name__ == "__main__":
+    # pass the file path to the huffman function
+    huffman(sys.argv[1])

From 3c40fda6a3ed8f59f1afc11b653be505557a41ef Mon Sep 17 00:00:00 2001
From: "Tommy.Liu" <447569003@qq.com>
Date: Tue, 14 May 2019 18:17:25 +0800
Subject: [PATCH 008/348] More elegant coding for merge_sort_fastest (#804)

* More elegant coding for merge_sort_fastest

* More elegant coding for merge_sort
---
 sorts/merge_sort.py         | 46 +++++++++++---------------------
 sorts/merge_sort_fastest.py | 53 ++++++++++++++++++++++++++++---------
 2 files changed, 55 insertions(+), 44 deletions(-)

diff --git a/sorts/merge_sort.py b/sorts/merge_sort.py
index ca4d319fa7f1..4a6201a40cb4 100644
--- a/sorts/merge_sort.py
+++ b/sorts/merge_sort.py
@@ -29,36 +29,20 @@ def merge_sort(collection):
     >>> merge_sort([-2, -5, -45])
     [-45, -5, -2]
     """
-    length = len(collection)
-    if length > 1:
-        midpoint = length // 2
-        left_half = merge_sort(collection[:midpoint])
-        right_half = merge_sort(collection[midpoint:])
-        i = 0
-        j = 0
-        k = 0
-        left_length = len(left_half)
-        right_length = len(right_half)
-        while i < left_length and j < right_length:
-            if left_half[i] < right_half[j]:
-                collection[k] = left_half[i]
-                i += 1
-            else:
-                collection[k] = right_half[j]
-                j += 1
-            k += 1
-
-        while i < left_length:
-            collection[k] = left_half[i]
-            i += 1
-            k += 1
-
-        while j < right_length:
-            collection[k] = right_half[j]
-            j += 1
-            k += 1
-
-    return collection
+    def merge(left, right):
+        '''merge left and right
+        :param left: left collection
+        :param right: right collection
+        :return: merge result
+        '''
+        result = []
+        while left and right:
+            result.append(left.pop(0) if left[0] <= right[0] else right.pop(0))
+        return result + left + right
+    if len(collection) <= 1:
+        return collection
+    mid = len(collection) // 2
+    return merge(merge_sort(collection[:mid]), merge_sort(collection[mid:]))
 
 
 if __name__ == '__main__':
@@ -69,4 +53,4 @@ def merge_sort(collection):
 
     user_input = raw_input('Enter numbers separated by a comma:\n').strip()
     unsorted = [int(item) for item in user_input.split(',')]
-    print(merge_sort(unsorted))
+    print(*merge_sort(unsorted), sep=',')
diff --git a/sorts/merge_sort_fastest.py b/sorts/merge_sort_fastest.py
index 9fc9275aacba..86cb8ae1a699 100644
--- a/sorts/merge_sort_fastest.py
+++ b/sorts/merge_sort_fastest.py
@@ -1,19 +1,46 @@
 '''
-Python implementation of merge sort algorithm.
+Python implementation of the fastest merge sort algorithm.
 Takes an average of 0.6 microseconds to sort a list of length 1000 items.
 Best Case Scenario : O(n)
 Worst Case Scenario : O(n)
 '''
-def merge_sort(LIST):
-    start = []
-    end = []
-    while len(LIST) > 1:
-        a = min(LIST)
-        b = max(LIST)
-        start.append(a)
-        end.append(b)
-        LIST.remove(a)
-        LIST.remove(b)
-    if LIST: start.append(LIST[0])
+from __future__ import print_function
+
+
+def merge_sort(collection):
+    """Pure implementation of the fastest merge sort algorithm in Python
+
+    :param collection: some mutable ordered collection with heterogeneous
+    comparable items inside
+    :return: a collection ordered by ascending
+
+    Examples:
+    >>> merge_sort([0, 5, 3, 2, 2])
+    [0, 2, 2, 3, 5]
+
+    >>> merge_sort([])
+    []
+
+    >>> merge_sort([-2, -5, -45])
+    [-45, -5, -2]
+    """
+    start, end = [], []
+    while len(collection) > 1:
+        min_one, max_one = min(collection), max(collection)
+        start.append(min_one)
+        end.append(max_one)
+        collection.remove(min_one)
+        collection.remove(max_one)
     end.reverse()
-    return (start + end)
+    return start + collection + end
+
+
+if __name__ == '__main__':
+    try:
+        raw_input          # Python 2
+    except NameError:
+        raw_input = input  # Python 3
+
+    user_input = raw_input('Enter numbers separated by a comma:\n').strip()
+    unsorted = [int(item) for item in user_input.split(',')]
+    print(*merge_sort(unsorted), sep=',')

From c4d16820bc062ebb1f311e74885e7ca0e2fa5973 Mon Sep 17 00:00:00 2001
From: Erfan Alimohammadi <erfan.aa@gmail.com>
Date: Tue, 14 May 2019 21:45:53 +0430
Subject: [PATCH 009/348] Fix typo (#806)

---
 strings/manacher.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/strings/manacher.py b/strings/manacher.py
index 9a44b19ba77a..e73e173b43e0 100644
--- a/strings/manacher.py
+++ b/strings/manacher.py
@@ -1,4 +1,4 @@
-# calculate palindromic length from center with incresmenting difference
+# calculate palindromic length from center with incrementing difference
 def palindromic_length( center, diff, string):
     if center-diff == -1 or center+diff == len(string) or string[center-diff] != string[center+diff] :
         return 0

From 76061ab2cc7f4e07fa7b2c952ca715cc6d09d7c2 Mon Sep 17 00:00:00 2001
From: Reshad Hasan <reshadhasan555@gmail.com>
Date: Thu, 16 May 2019 17:20:27 +0600
Subject: [PATCH 010/348] added eulerian path and circuit finding algorithm
 (#787)

---
 ...n path and circuit for undirected graph.py | 93 +++++++++++++++++++
 1 file changed, 93 insertions(+)
 create mode 100644 Graphs/Eulerian path and circuit for undirected graph.py

diff --git a/Graphs/Eulerian path and circuit for undirected graph.py b/Graphs/Eulerian path and circuit for undirected graph.py
new file mode 100644
index 000000000000..c6c6a1a25f03
--- /dev/null
+++ b/Graphs/Eulerian path and circuit for undirected graph.py	
@@ -0,0 +1,93 @@
+# Eulerian Path is a path in graph that visits every edge exactly once.
+# Eulerian Circuit is an Eulerian Path which starts and ends on the same
+# vertex.
+# time complexity is O(V+E)
+# space complexity is O(VE)
+
+
+# using dfs for finding eulerian path traversal
+def dfs(u, graph, visited_edge, path=[]):
+    path = path + [u]
+    for v in graph[u]:
+        if visited_edge[u][v] == False:
+            visited_edge[u][v], visited_edge[v][u] = True, True
+            path = dfs(v, graph, visited_edge, path)
+    return path
+
+
+# for checking in graph has euler path or circuit
+def check_circuit_or_path(graph, max_node):
+    odd_degree_nodes = 0
+    odd_node = -1
+    for i in range(max_node):
+        if i not in graph.keys():
+            continue
+        if len(graph[i]) % 2 == 1:
+            odd_degree_nodes += 1
+            odd_node = i
+    if odd_degree_nodes == 0:
+        return 1, odd_node
+    if odd_degree_nodes == 2:
+        return 2, odd_node
+    return 3, odd_node
+
+
+def check_euler(graph, max_node):
+    visited_edge = [[False for _ in range(max_node + 1)] for _ in range(max_node + 1)]
+    check, odd_node = check_circuit_or_path(graph, max_node)
+    if check == 3:
+        print("graph is not Eulerian")
+        print("no path")
+        return
+    start_node = 1
+    if check == 2:
+        start_node = odd_node
+        print("graph has a Euler path")
+    if check == 1:
+        print("graph has a Euler cycle")
+    path = dfs(start_node, graph, visited_edge)
+    print(path)
+
+
+def main():
+    G1 = {
+        1: [2, 3, 4],
+        2: [1, 3],
+        3: [1, 2],
+        4: [1, 5],
+        5: [4]
+    }
+    G2 = {
+        1: [2, 3, 4, 5],
+        2: [1, 3],
+        3: [1, 2],
+        4: [1, 5],
+        5: [1, 4]
+    }
+    G3 = {
+        1: [2, 3, 4],
+        2: [1, 3, 4],
+        3: [1, 2],
+        4: [1, 2, 5],
+        5: [4]
+    }
+    G4 = {
+        1: [2, 3],
+        2: [1, 3],
+        3: [1, 2],
+    }
+    G5 = {
+        1: [],
+        2: []
+        # all degree is zero
+    }
+    max_node = 10
+    check_euler(G1, max_node)
+    check_euler(G2, max_node)
+    check_euler(G3, max_node)
+    check_euler(G4, max_node)
+    check_euler(G5, max_node)
+
+
+if __name__ == "__main__":
+    main()

From c47c1ab03ce80963d5dcd2136d03555f3b283055 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?N=C3=ADkolas=20Vargas?= <vargasnikolass@gmail.com>
Date: Thu, 16 May 2019 08:20:42 -0300
Subject: [PATCH 011/348] enhancement (#803)

---
 compression/huffman.py | 17 ++++++-----------
 1 file changed, 6 insertions(+), 11 deletions(-)

diff --git a/compression/huffman.py b/compression/huffman.py
index b6238b66e9fd..7417551ba209 100644
--- a/compression/huffman.py
+++ b/compression/huffman.py
@@ -18,7 +18,7 @@ def __init__(self, freq, left, right):
 
 
 def parse_file(file_path):
-    """ 
+    """
     Read the file and build a dict of all letters and their
     frequences, then convert the dict into a list of Letters.
     """
@@ -29,15 +29,10 @@ def parse_file(file_path):
             if not c:
                 break
             chars[c] = chars[c] + 1 if c in chars.keys() else 1
-    letters = []
-    for char, freq in chars.items():
-        letter = Letter(char, freq)
-        letters.append(letter)
-    letters.sort(key=lambda l: l.freq)
-    return letters
+    return sorted([Letter(c, f) for c, f in chars.items()], key=lambda l: l.freq)
 
 def build_tree(letters):
-    """ 
+    """
     Run through the list of Letters and build the min heap
     for the Huffman Tree.
     """
@@ -51,7 +46,7 @@ def build_tree(letters):
     return letters[0]
 
 def traverse_tree(root, bitstring):
-    """ 
+    """
     Recursively traverse the Huffman Tree to set each
     Letter's bitstring, and return the list of Letters
     """
@@ -64,9 +59,9 @@ def traverse_tree(root, bitstring):
     return letters
 
 def huffman(file_path):
-    """ 
+    """
     Parse the file, build the tree, then run through the file
-    again, using the list of Letters to find and print out the 
+    again, using the list of Letters to find and print out the
     bitstring for each letter.
     """
     letters_list = parse_file(file_path)

From 13c0c166d8f80398de39ab41632fd54be86ae2cc Mon Sep 17 00:00:00 2001
From: ImNandha <49323522+ImNandha@users.noreply.github.com>
Date: Thu, 16 May 2019 16:53:23 +0530
Subject: [PATCH 012/348] Update graph.py (#809)

---
 graphs/graph.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/graphs/graph.py b/graphs/graph.py
index 9bd61559dcbf..0c981c39d320 100644
--- a/graphs/graph.py
+++ b/graphs/graph.py
@@ -4,7 +4,7 @@
 from __future__ import print_function
 # Author: OMKAR PATHAK
 
-# We can use Python's dictionary for constructing the graph
+# We can use Python's dictionary for constructing the graph.
 
 class AdjacencyList(object):
     def __init__(self):

From a65efd42c4683b628338b84c822d22eab199c058 Mon Sep 17 00:00:00 2001
From: Erfan Alimohammadi <erfan.aa@gmail.com>
Date: Thu, 16 May 2019 15:54:56 +0430
Subject: [PATCH 013/348] Implement check_bipartite_graph using DFS. (#808)

---
 graphs/check_bipartite_graph_dfs.py | 33 +++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 graphs/check_bipartite_graph_dfs.py

diff --git a/graphs/check_bipartite_graph_dfs.py b/graphs/check_bipartite_graph_dfs.py
new file mode 100644
index 000000000000..eeb3a84b7a15
--- /dev/null
+++ b/graphs/check_bipartite_graph_dfs.py
@@ -0,0 +1,33 @@
+# Check whether Graph is Bipartite or Not using DFS
+
+# A Bipartite Graph is a graph whose vertices can be divided into two independent sets,
+# U and V such that every edge (u, v) either connects a vertex from U to V or a vertex
+# from V to U. In other words, for every edge (u, v), either u belongs to U and v to V,
+# or u belongs to V and v to U. We can also say that there is no edge that connects
+# vertices of same set.
+def check_bipartite_dfs(l):
+    visited = [False] * len(l)
+    color = [-1] * len(l)
+
+    def dfs(v, c):
+        visited[v] = True
+        color[v] = c
+        for u in l[v]:
+            if not visited[u]:
+                dfs(u, 1 - c)
+
+    for i in range(len(l)):
+        if not visited[i]:
+            dfs(i, 0)
+
+    for i in range(len(l)):
+        for j in l[i]:
+            if color[i] == color[j]:
+                return False
+
+    return True
+        
+
+# Adjacency list of graph
+l = {0:[1,3], 1:[0,2], 2:[1,3], 3:[0,2], 4: []}
+print(check_bipartite_dfs(l))

From 5b86928c4b6ab23cbff51ddf9023ac230d4dff26 Mon Sep 17 00:00:00 2001
From: cclauss <cclauss@me.com>
Date: Thu, 16 May 2019 13:26:46 +0200
Subject: [PATCH 014/348] Use ==/!= to compare str, bytes, and int literals
 (#767)

* Travis CI: Add more flake8 tests

* Use ==/!= to compare str, bytes, and int literals

./project_euler/problem_17/sol1.py:25:7: F632 use ==/!= to compare str, bytes, and int literals
			if i%100 is not 0:
      ^

* Use ==/!= to compare str, bytes, and int literals

* Update sol1.py
---
 .travis.yml                      | 2 +-
 project_euler/problem_17/sol1.py | 4 ++--
 project_euler/problem_19/sol1.py | 8 ++++----
 3 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index 5fba6987bb66..2440899e4f25 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -16,7 +16,7 @@ install:
     - pip install flake8  # pytest  # add another testing frameworks later
 before_script:
     # stop the build if there are Python syntax errors or undefined names
-    - flake8 . --count --select=E901,E999,F821,F822,F823 --show-source --statistics
+    - flake8 . --count --select=E9,F63,F72,F82 --show-source --statistics
     # exit-zero treats all errors as warnings.  The GitHub editor is 127 chars wide
     - flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
 script:
diff --git a/project_euler/problem_17/sol1.py b/project_euler/problem_17/sol1.py
index 9de5d80b9b29..8dd6f1af2093 100644
--- a/project_euler/problem_17/sol1.py
+++ b/project_euler/problem_17/sol1.py
@@ -22,7 +22,7 @@
 		if i >= 100:
 			count += ones_counts[i/100] + 7 #add number of letters for "n hundred"
 
-			if i%100 is not 0:
+			if i%100 != 0:
 				count += 3 #add number of letters for "and" if number is not multiple of 100
 
 		if 0 < i%100 < 20:
@@ -32,4 +32,4 @@
 	else:
 		count += ones_counts[i/1000] + 8
 
-print(count)
\ No newline at end of file
+print(count)
diff --git a/project_euler/problem_19/sol1.py b/project_euler/problem_19/sol1.py
index 94cf117026a4..13e520ca76e4 100644
--- a/project_euler/problem_19/sol1.py
+++ b/project_euler/problem_19/sol1.py
@@ -30,10 +30,10 @@
 	day += 7
 
 	if (year%4 == 0 and not year%100 == 0) or (year%400 == 0):
-		if day > days_per_month[month-1] and month is not 2:
+		if day > days_per_month[month-1] and month != 2:
 			month += 1
 			day = day-days_per_month[month-2]
-		elif day > 29 and month is 2:
+		elif day > 29 and month == 2:
 			month += 1
 			day = day-29
 	else:
@@ -45,7 +45,7 @@
 		year += 1
 		month = 1
 
-	if year < 2001 and day is 1:
+	if year < 2001 and day == 1:
 		sundays += 1
 
-print(sundays)
\ No newline at end of file
+print(sundays)

From f3608acfd5c3c66531942434769c8260c983e877 Mon Sep 17 00:00:00 2001
From: Sarvesh Dubey <38752758+dubesar@users.noreply.github.com>
Date: Fri, 17 May 2019 08:42:06 +0530
Subject: [PATCH 015/348] Created shortest path using bfs (#794)

* Created shortest path using bfs
---
 graphs/bfs-shortestpath.py | 43 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 43 insertions(+)
 create mode 100644 graphs/bfs-shortestpath.py

diff --git a/graphs/bfs-shortestpath.py b/graphs/bfs-shortestpath.py
new file mode 100644
index 000000000000..5853351a53a3
--- /dev/null
+++ b/graphs/bfs-shortestpath.py
@@ -0,0 +1,43 @@
+graph = {'A': ['B', 'C', 'E'],
+         'B': ['A','D', 'E'],
+         'C': ['A', 'F', 'G'],
+         'D': ['B'],
+         'E': ['A', 'B','D'],
+         'F': ['C'],
+         'G': ['C']}
+
+def bfs_shortest_path(graph, start, goal):
+    # keep track of explored nodes
+    explored = []
+    # keep track of all the paths to be checked
+    queue = [[start]]
+ 
+    # return path if start is goal
+    if start == goal:
+        return "That was easy! Start = goal"
+ 
+    # keeps looping until all possible paths have been checked
+    while queue:
+        # pop the first path from the queue
+        path = queue.pop(0)
+        # get the last node from the path
+        node = path[-1]
+        if node not in explored:
+            neighbours = graph[node]
+            # go through all neighbour nodes, construct a new path and
+            # push it into the queue
+            for neighbour in neighbours:
+                new_path = list(path)
+                new_path.append(neighbour)
+                queue.append(new_path)
+                # return path if neighbour is goal
+                if neighbour == goal:
+                    return new_path
+ 
+            # mark node as explored
+            explored.append(node)
+ 
+    # in case there's no path between the 2 nodes
+    return "So sorry, but a connecting path doesn't exist :("
+ 
+bfs_shortest_path(graph, 'G', 'D')  # returns ['G', 'C', 'A', 'B', 'D']

From b6c3fa8992e1f3430e623b6c4b1268c89e26f71f Mon Sep 17 00:00:00 2001
From: weixuanhu <44716380+weixuanhu@users.noreply.github.com>
Date: Sat, 18 May 2019 10:59:12 +0800
Subject: [PATCH 016/348] Interpolation search - fix endless loop bug, divide 0
 bug and update description (#793)

* fix endless loop bug, divide 0 bug and update description

fix an endless bug, for example, if collection = [10,30,40,45,50,66,77,93], item = 67.

fix divide 0 bug,  when right=left it is not OK to point = left + ((item - sorted_collection[left]) * (right - left)) // (sorted_collection[right] - sorted_collection[left])

update 'sorted' to 'ascending sorted' in description to avoid confusion

* delete swap files

* delete 'address' and add input validation
---
 searches/interpolation_search.py      | 80 +++++++++++++++++------
 searches/quick_select.py              | 11 +++-
 searches/test_interpolation_search.py | 93 +++++++++++++++++++++++++++
 3 files changed, 160 insertions(+), 24 deletions(-)
 create mode 100644 searches/test_interpolation_search.py

diff --git a/searches/interpolation_search.py b/searches/interpolation_search.py
index db9893bdb5d4..329596d340a5 100644
--- a/searches/interpolation_search.py
+++ b/searches/interpolation_search.py
@@ -11,9 +11,9 @@
 
 def interpolation_search(sorted_collection, item):
     """Pure implementation of interpolation search algorithm in Python
-    Be careful collection must be sorted, otherwise result will be
+    Be careful collection must be ascending sorted, otherwise result will be
     unpredictable
-    :param sorted_collection: some sorted collection with comparable items
+    :param sorted_collection: some ascending sorted collection with comparable items
     :param item: item value to search
     :return: index of found item or None if item is not found
     """
@@ -21,6 +21,13 @@ def interpolation_search(sorted_collection, item):
     right = len(sorted_collection) - 1
 
     while left <= right:
+        #avoid devided by 0 during interpolation
+        if sorted_collection[left]==sorted_collection[right]:
+            if sorted_collection[left]==item:
+                return left
+            else:
+                return None
+
         point = left + ((item - sorted_collection[left]) * (right - left)) // (sorted_collection[right] - sorted_collection[left])
         
         #out of range check
@@ -31,66 +38,97 @@ def interpolation_search(sorted_collection, item):
         if current_item == item:
             return point
         else:
-            if item < current_item:
-                right = point - 1
-            else:
-                left = point + 1
+            if point<left:
+                right = left
+                left = point
+            elif point>right:
+                left = right 
+                right = point
+            else:    
+                if item < current_item:
+                    right = point - 1
+                else:
+                    left = point + 1
     return None
 
-
 def interpolation_search_by_recursion(sorted_collection, item, left, right):
 
     """Pure implementation of interpolation search algorithm in Python by recursion
-    Be careful collection must be sorted, otherwise result will be
+    Be careful collection must be ascending sorted, otherwise result will be
     unpredictable
     First recursion should be started with left=0 and right=(len(sorted_collection)-1)
-    :param sorted_collection: some sorted collection with comparable items
+    :param sorted_collection: some ascending sorted collection with comparable items
     :param item: item value to search
     :return: index of found item or None if item is not found
     """
-    point = left + ((item - sorted_collection[left]) * (right - left)) // (sorted_collection[right] - sorted_collection[left])
 
+    #avoid devided by 0 during interpolation
+    if sorted_collection[left]==sorted_collection[right]:
+        if sorted_collection[left]==item:
+            return left
+        else:
+            return None
+
+    point = left + ((item - sorted_collection[left]) * (right - left)) // (sorted_collection[right] - sorted_collection[left])
+    
     #out of range check
     if point<0 or point>=len(sorted_collection):
         return None
 
     if sorted_collection[point] == item:
         return point
-    elif sorted_collection[point] > item:
-        return interpolation_search_by_recursion(sorted_collection, item, left, point-1)
+    elif point<left:
+        return interpolation_search_by_recursion(sorted_collection, item, point, left)
+    elif point>right:
+        return interpolation_search_by_recursion(sorted_collection, item, right, left)
     else:
-        return interpolation_search_by_recursion(sorted_collection, item, point+1, right)
+        if sorted_collection[point] > item:
+            return interpolation_search_by_recursion(sorted_collection, item, left, point-1)
+        else:
+            return interpolation_search_by_recursion(sorted_collection, item, point+1, right)
       
 def __assert_sorted(collection):
-    """Check if collection is sorted, if not - raises :py:class:`ValueError`
+    """Check if collection is ascending sorted, if not - raises :py:class:`ValueError`
     :param collection: collection
-    :return: True if collection is sorted
-    :raise: :py:class:`ValueError` if collection is not sorted
+    :return: True if collection is ascending sorted
+    :raise: :py:class:`ValueError` if collection is not ascending sorted
     Examples:
     >>> __assert_sorted([0, 1, 2, 4])
     True
     >>> __assert_sorted([10, -1, 5])
     Traceback (most recent call last):
     ...
-    ValueError: Collection must be sorted
+    ValueError: Collection must be ascending sorted
     """
     if collection != sorted(collection):
-        raise ValueError('Collection must be sorted')
+        raise ValueError('Collection must be ascending sorted')
     return True
 
 
 if __name__ == '__main__':
     import sys
-
-    user_input = raw_input('Enter numbers separated by comma:\n').strip()
+    
+    """
+	user_input = raw_input('Enter numbers separated by comma:\n').strip()
     collection = [int(item) for item in user_input.split(',')]
     try:
         __assert_sorted(collection)
     except ValueError:
-        sys.exit('Sequence must be sorted to apply interpolation search')
+        sys.exit('Sequence must be ascending sorted to apply interpolation search')
 
     target_input = raw_input('Enter a single number to be found in the list:\n')
     target = int(target_input)
+	"""
+
+    debug = 0
+    if debug == 1:
+        collection = [10,30,40,45,50,66,77,93]
+        try:
+            __assert_sorted(collection)
+        except ValueError:
+            sys.exit('Sequence must be ascending sorted to apply interpolation search')
+        target = 67
+        
     result = interpolation_search(collection, target)
     if result is not None:
         print('{} found at positions: {}'.format(target, result))
diff --git a/searches/quick_select.py b/searches/quick_select.py
index 1596cf040e0c..76d09cb97f97 100644
--- a/searches/quick_select.py
+++ b/searches/quick_select.py
@@ -14,9 +14,9 @@ def _partition(data, pivot):
     """
     less, equal, greater = [], [], []
     for element in data:
-        if element.address < pivot.address:
+        if element < pivot:
             less.append(element)
-        elif element.address > pivot.address:
+        elif element > pivot:
             greater.append(element)
         else:
             equal.append(element)
@@ -24,6 +24,11 @@ def _partition(data, pivot):
     
 def quickSelect(list, k):
     #k = len(list) // 2 when trying to find the median (index that value would be when list is sorted)
+    
+    #invalid input
+    if k>=len(list) or k<0:
+        return None
+    
     smaller = []
     larger = []
     pivot = random.randint(0, len(list) - 1)
@@ -41,4 +46,4 @@ def quickSelect(list, k):
         return quickSelect(smaller, k)
     #must be in larger
     else:
-        return quickSelect(larger, k - (m + count))
+        return quickSelect(larger, k - (m + count))
\ No newline at end of file
diff --git a/searches/test_interpolation_search.py b/searches/test_interpolation_search.py
new file mode 100644
index 000000000000..60bb3af22e0f
--- /dev/null
+++ b/searches/test_interpolation_search.py
@@ -0,0 +1,93 @@
+import unittest
+from interpolation_search import interpolation_search, interpolation_search_by_recursion
+
+class Test_interpolation_search(unittest.TestCase):
+    def setUp(self):
+        # un-sorted case
+        self.collection1 = [5,3,4,6,7]
+        self.item1 = 4
+        # sorted case, result exists
+        self.collection2 = [10,30,40,45,50,66,77,93]
+        self.item2 = 66
+        # sorted case, result doesn't exist
+        self.collection3 = [10,30,40,45,50,66,77,93]
+        self.item3 = 67
+        # equal elements case, result exists
+        self.collection4 = [10,10,10,10,10]
+        self.item4 = 10
+        # equal elements case, result doesn't exist
+        self.collection5 = [10,10,10,10,10]
+        self.item5 = 3
+        # 1 element case, result exists
+        self.collection6 = [10]
+        self.item6 = 10
+        # 1 element case, result doesn't exists
+        self.collection7 = [10]
+        self.item7 = 1
+
+    def tearDown(self):
+        pass
+
+    def test_interpolation_search(self):
+        self.assertEqual(interpolation_search(self.collection1, self.item1), None)
+        
+        self.assertEqual(interpolation_search(self.collection2, self.item2), self.collection2.index(self.item2))
+        
+        self.assertEqual(interpolation_search(self.collection3, self.item3), None)
+        
+        self.assertEqual(interpolation_search(self.collection4, self.item4), self.collection4.index(self.item4))
+
+        self.assertEqual(interpolation_search(self.collection5, self.item5), None)
+        
+        self.assertEqual(interpolation_search(self.collection6, self.item6), self.collection6.index(self.item6))
+        
+        self.assertEqual(interpolation_search(self.collection7, self.item7), None)
+        
+
+
+class Test_interpolation_search_by_recursion(unittest.TestCase):
+    def setUp(self):
+        # un-sorted case
+        self.collection1 = [5,3,4,6,7]
+        self.item1 = 4
+        # sorted case, result exists
+        self.collection2 = [10,30,40,45,50,66,77,93]
+        self.item2 = 66
+        # sorted case, result doesn't exist
+        self.collection3 = [10,30,40,45,50,66,77,93]
+        self.item3 = 67
+        # equal elements case, result exists
+        self.collection4 = [10,10,10,10,10]
+        self.item4 = 10
+        # equal elements case, result doesn't exist
+        self.collection5 = [10,10,10,10,10]
+        self.item5 = 3
+        # 1 element case, result exists
+        self.collection6 = [10]
+        self.item6 = 10
+        # 1 element case, result doesn't exists
+        self.collection7 = [10]
+        self.item7 = 1
+
+    def tearDown(self):
+        pass
+
+    def test_interpolation_search_by_recursion(self):
+        self.assertEqual(interpolation_search_by_recursion(self.collection1, self.item1, 0, len(self.collection1)-1), None)
+        
+        self.assertEqual(interpolation_search_by_recursion(self.collection2, self.item2, 0, len(self.collection2)-1), self.collection2.index(self.item2))
+        
+        self.assertEqual(interpolation_search_by_recursion(self.collection3, self.item3, 0, len(self.collection3)-1), None)
+        
+        self.assertEqual(interpolation_search_by_recursion(self.collection4, self.item4, 0, len(self.collection4)-1), self.collection4.index(self.item4))
+
+        self.assertEqual(interpolation_search_by_recursion(self.collection5, self.item5, 0, len(self.collection5)-1), None)
+        
+        self.assertEqual(interpolation_search_by_recursion(self.collection6, self.item6, 0, len(self.collection6)-1), self.collection6.index(self.item6))
+        
+        self.assertEqual(interpolation_search_by_recursion(self.collection7, self.item7, 0, len(self.collection7)-1), None)
+ 
+
+
+if __name__ == '__main__':
+    unittest.main()

From f5abc04176b9635da963ca701f643acde5da24dc Mon Sep 17 00:00:00 2001
From: Andy Lau <andy1970635726@gmail.com>
Date: Sun, 19 May 2019 17:00:54 +0800
Subject: [PATCH 017/348] Update bucket_sort.py (#821)

* Some simplification
---
 sorts/bucket_sort.py | 64 +++++++++++++++++++-------------------------
 1 file changed, 27 insertions(+), 37 deletions(-)

diff --git a/sorts/bucket_sort.py b/sorts/bucket_sort.py
index bd4281e463eb..5c17703c26f0 100644
--- a/sorts/bucket_sort.py
+++ b/sorts/bucket_sort.py
@@ -13,45 +13,35 @@
 #  Time Complexity of Solution:
 #  Best Case O(n); Average Case O(n); Worst Case O(n)
 
-from __future__ import print_function
-from insertion_sort import insertion_sort
-import math
-
-DEFAULT_BUCKET_SIZE = 5
-
-def bucketSort(myList, bucketSize=DEFAULT_BUCKET_SIZE):
-    if(len(myList) == 0):
-        print('You don\'t have any elements in array!')
-
-    minValue = myList[0]
-    maxValue = myList[0]
-
-    # For finding minimum and maximum values
-    for i in range(0, len(myList)):
-        if myList[i] < minValue:
-            minValue = myList[i]
-        elif myList[i] > maxValue:
-            maxValue = myList[i]
-
-    # Initialize buckets
-    bucketCount = math.floor((maxValue - minValue) / bucketSize) + 1
-    buckets = []
-    for i in range(0, bucketCount):
+DEFAULT_BUCKET_SIZE=5
+def bucket_sort(my_list,bucket_size=DEFAULT_BUCKET_SIZE):
+    if(my_list==0):
+        print("you don't have any elements in array!")
+
+
+    min_value=min(my_list)
+    max_value=max(my_list)
+
+    bucket_count=(max_value-min_value)//bucket_size+1
+    buckets=[]
+    for i in range(bucket_count):
         buckets.append([])
+    for i in range(len(my_list)):
+        buckets[(my_list[i]-min_value)//bucket_size].append(my_list[i])
+
+
+    sorted_array=[]
+    for i in range(len(buckets)):
+        buckets[i].sort()
+        for j in range(len(buckets[i])):
+            sorted_array.append(buckets[i][j])
+    return sorted_array
 
-    # For putting values in buckets
-    for i in range(0, len(myList)):
-        buckets[math.floor((myList[i] - minValue) / bucketSize)].append(myList[i])
 
-    # Sort buckets and place back into input array
-    sortedArray = []
-    for i in range(0, len(buckets)):
-        insertion_sort(buckets[i])
-        for j in range(0, len(buckets[i])):
-            sortedArray.append(buckets[i][j])
 
-    return sortedArray
 
-if __name__ == '__main__':
-    sortedArray = bucketSort([12, 23, 4, 5, 3, 2, 12, 81, 56, 95])
-    print(sortedArray)
+#test
+#besd on python 3.7.3
+user_input =input('Enter numbers separated by a comma:').strip()
+unsorted =[int(item) for item in user_input.split(',')]
+print(bucket_sort(unsorted))

From 316d5ffa374a35cb1a0237a7da1e12309da7aece Mon Sep 17 00:00:00 2001
From: DaveAxiom <dmakray@gmail.com>
Date: Sun, 19 May 2019 16:36:46 -0400
Subject: [PATCH 018/348] Add NQueens backtracking search implementation (#504)

---
 other/nqueens.py | 77 ++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 77 insertions(+)
 create mode 100644 other/nqueens.py

diff --git a/other/nqueens.py b/other/nqueens.py
new file mode 100644
index 000000000000..1b1c75878ae6
--- /dev/null
+++ b/other/nqueens.py
@@ -0,0 +1,77 @@
+#! /usr/bin/python3
+import sys
+
+def nqueens(board_width):
+	board = [0]
+	current_row = 0
+	while True:
+		conflict = False
+		
+		for review_index in range(0, current_row):
+			left = board[review_index] - (current_row - review_index)
+			right = board[review_index] + (current_row - review_index);
+			if (board[current_row] == board[review_index] or (left >= 0 and left == board[current_row]) or (right < board_width and right == board[current_row])):
+				conflict = True;
+				break
+	
+		if (current_row == 0 and conflict == False):
+			board.append(0)
+			current_row = 1
+			continue
+
+		if (conflict == True):
+			board[current_row] += 1
+			
+			if (current_row == 0 and board[current_row] == board_width):
+				print("No solution exists for specificed board size.")
+				return None
+			
+			while True:
+				if (board[current_row] == board_width):
+					board[current_row] = 0
+					if (current_row == 0):
+						print("No solution exists for specificed board size.")
+						return None
+					
+					board.pop()
+					current_row -= 1
+					board[current_row] += 1
+					
+				if board[current_row] != board_width:
+					break
+		else:
+			current_row += 1
+			if (current_row == board_width):
+				break
+
+			board.append(0)
+	return board
+
+def print_board(board):
+	if (board == None):
+		return
+
+	board_width = len(board)
+	for row in range(board_width):
+		line_print = []
+		for column in range(board_width):
+			if column == board[row]:
+				line_print.append("Q")
+			else:
+				line_print.append(".")
+		print(line_print)
+
+
+if __name__ == '__main__':
+	default_width = 8
+	for arg in sys.argv:
+		if (arg.isdecimal() and int(arg) > 3):
+			default_width = int(arg)
+			break
+		
+	if (default_width == 8):
+		print("Running algorithm with board size of 8. Specify an alternative Chess board size for N-Queens as a command line argument.")
+	
+	board = nqueens(default_width)
+	print(board)
+	print_board(board)
\ No newline at end of file

From c1130490d7534412bea66cb3864e2bb7f7e13dd7 Mon Sep 17 00:00:00 2001
From: Adam <34916469+coderpower0@users.noreply.github.com>
Date: Mon, 20 May 2019 21:22:20 +0800
Subject: [PATCH 019/348] fix spelling on line 44 of bucket sort (#824)

* change besd to best
---
 sorts/bucket_sort.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/sorts/bucket_sort.py b/sorts/bucket_sort.py
index 5c17703c26f0..aba0124ad909 100644
--- a/sorts/bucket_sort.py
+++ b/sorts/bucket_sort.py
@@ -41,7 +41,7 @@ def bucket_sort(my_list,bucket_size=DEFAULT_BUCKET_SIZE):
 
 
 #test
-#besd on python 3.7.3
+#best on python 3.7.3
 user_input =input('Enter numbers separated by a comma:').strip()
 unsorted =[int(item) for item in user_input.split(',')]
 print(bucket_sort(unsorted))

From b5667e5ee98f9f68c8f40dd9691bb9006a5ac832 Mon Sep 17 00:00:00 2001
From: Anirudh Ajith <anirudh.ajith@gmail.com>
Date: Tue, 21 May 2019 11:36:05 +0530
Subject: [PATCH 020/348] Removed the (incorrectly named) redundant file
 graph_list.py and renamed graph.py to graph_list.py (#820)

---
 graphs/graph.py      | 44 --------------------------
 graphs/graph_list.py | 73 ++++++++++++++++++++++++++------------------
 2 files changed, 43 insertions(+), 74 deletions(-)
 delete mode 100644 graphs/graph.py

diff --git a/graphs/graph.py b/graphs/graph.py
deleted file mode 100644
index 0c981c39d320..000000000000
--- a/graphs/graph.py
+++ /dev/null
@@ -1,44 +0,0 @@
-#!/usr/bin/python
-# encoding=utf8
-
-from __future__ import print_function
-# Author: OMKAR PATHAK
-
-# We can use Python's dictionary for constructing the graph.
-
-class AdjacencyList(object):
-    def __init__(self):
-        self.List = {}
-
-    def addEdge(self, fromVertex, toVertex):
-        # check if vertex is already present
-        if fromVertex in self.List.keys():
-            self.List[fromVertex].append(toVertex)
-        else:
-            self.List[fromVertex] = [toVertex]
-
-    def printList(self):
-        for i  in self.List:
-            print((i,'->',' -> '.join([str(j) for j in self.List[i]])))
-
-if __name__ == '__main__':
-    al = AdjacencyList()
-    al.addEdge(0, 1)
-    al.addEdge(0, 4)
-    al.addEdge(4, 1)
-    al.addEdge(4, 3)
-    al.addEdge(1, 0)
-    al.addEdge(1, 4)
-    al.addEdge(1, 3)
-    al.addEdge(1, 2)
-    al.addEdge(2, 3)
-    al.addEdge(3, 4)
-
-    al.printList()
-
-    # OUTPUT:
-    # 0 -> 1 -> 4
-    # 1 -> 0 -> 4 -> 3 -> 2
-    # 2 -> 3
-    # 3 -> 4
-    # 4 -> 1 -> 3
diff --git a/graphs/graph_list.py b/graphs/graph_list.py
index d67bc96c4a81..0c981c39d320 100644
--- a/graphs/graph_list.py
+++ b/graphs/graph_list.py
@@ -1,31 +1,44 @@
-from __future__ import print_function
-
-
-class Graph:
-    def __init__(self, vertex):
-        self.vertex = vertex
-        self.graph = [[0] for i in range(vertex)]
-
-    def add_edge(self, u, v):
-        self.graph[u - 1].append(v - 1)
-
-    def show(self):
-        for i in range(self.vertex):
-            print('%d: '% (i + 1), end=' ')
-            for j in self.graph[i]:
-                print('%d-> '% (j + 1), end=' ')
-            print(' ')
-
-
-
-g = Graph(100)
-
-g.add_edge(1,3)
-g.add_edge(2,3)
-g.add_edge(3,4)
-g.add_edge(3,5)
-g.add_edge(4,5)
-
-
-g.show()
+#!/usr/bin/python
+# encoding=utf8
 
+from __future__ import print_function
+# Author: OMKAR PATHAK
+
+# We can use Python's dictionary for constructing the graph.
+
+class AdjacencyList(object):
+    def __init__(self):
+        self.List = {}
+
+    def addEdge(self, fromVertex, toVertex):
+        # check if vertex is already present
+        if fromVertex in self.List.keys():
+            self.List[fromVertex].append(toVertex)
+        else:
+            self.List[fromVertex] = [toVertex]
+
+    def printList(self):
+        for i  in self.List:
+            print((i,'->',' -> '.join([str(j) for j in self.List[i]])))
+
+if __name__ == '__main__':
+    al = AdjacencyList()
+    al.addEdge(0, 1)
+    al.addEdge(0, 4)
+    al.addEdge(4, 1)
+    al.addEdge(4, 3)
+    al.addEdge(1, 0)
+    al.addEdge(1, 4)
+    al.addEdge(1, 3)
+    al.addEdge(1, 2)
+    al.addEdge(2, 3)
+    al.addEdge(3, 4)
+
+    al.printList()
+
+    # OUTPUT:
+    # 0 -> 1 -> 4
+    # 1 -> 0 -> 4 -> 3 -> 2
+    # 2 -> 3
+    # 3 -> 4
+    # 4 -> 1 -> 3

From 023f5e092d38f7e220ae68a23f7183eeb8fd9e04 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?N=C3=ADkolas=20Vargas?= <vargasnikolass@gmail.com>
Date: Wed, 22 May 2019 09:09:36 -0300
Subject: [PATCH 021/348] fix empty list validation and code data structures
 (#826)

* fix empty list validation and code data structures

* Update bucket_sort.py

https://github.com/TheAlgorithms/Python/pull/826#pullrequestreview-240357549
---
 sorts/bucket_sort.py | 38 +++++++++++++-------------------------
 1 file changed, 13 insertions(+), 25 deletions(-)

diff --git a/sorts/bucket_sort.py b/sorts/bucket_sort.py
index aba0124ad909..cca913328e40 100644
--- a/sorts/bucket_sort.py
+++ b/sorts/bucket_sort.py
@@ -14,34 +14,22 @@
 #  Best Case O(n); Average Case O(n); Worst Case O(n)
 
 DEFAULT_BUCKET_SIZE=5
-def bucket_sort(my_list,bucket_size=DEFAULT_BUCKET_SIZE):
-    if(my_list==0):
-        print("you don't have any elements in array!")
 
+def bucket_sort(my_list, bucket_size=DEFAULT_BUCKET_SIZE):
+    if len(my_list) == 0:
+        raise Exception("Please add some elements in the array.")
 
-    min_value=min(my_list)
-    max_value=max(my_list)
+    min_value, max_value = (min(my_list), max(my_list))
+    bucket_count = ((max_value - min_value) // bucket_size + 1)
+    buckets = [[] for _ in range(int(bucket_count))]
 
-    bucket_count=(max_value-min_value)//bucket_size+1
-    buckets=[]
-    for i in range(bucket_count):
-        buckets.append([])
     for i in range(len(my_list)):
-        buckets[(my_list[i]-min_value)//bucket_size].append(my_list[i])
+        buckets[int((my_list[i] - min_value) // bucket_size)].append(my_list[i])
 
+    return sorted([buckets[i][j] for i in range(len(buckets))
+                                 for j in range(len(buckets[i]))])
 
-    sorted_array=[]
-    for i in range(len(buckets)):
-        buckets[i].sort()
-        for j in range(len(buckets[i])):
-            sorted_array.append(buckets[i][j])
-    return sorted_array
-
-
-
-
-#test
-#best on python 3.7.3
-user_input =input('Enter numbers separated by a comma:').strip()
-unsorted =[int(item) for item in user_input.split(',')]
-print(bucket_sort(unsorted))
+if __name__ == "__main__":
+    user_input = input('Enter numbers separated by a comma:').strip()
+    unsorted = [float(n) for n in user_input.split(',') if len(user_input) > 0]
+    print(bucket_sort(unsorted))

From a0ab3ce098c95c7edf3f32fedc9d3930d2d641e8 Mon Sep 17 00:00:00 2001
From: BruceLee569 <49506152+BruceLee569@users.noreply.github.com>
Date: Fri, 24 May 2019 23:54:03 +0800
Subject: [PATCH 022/348] Update quick_sort.py (#830)

Modify the list comprehensions to reduce the number of judgments, the speed has increased by more than 50%.
---
 sorts/quick_sort.py | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/sorts/quick_sort.py b/sorts/quick_sort.py
index e01d319a4b29..223c26fde1fe 100644
--- a/sorts/quick_sort.py
+++ b/sorts/quick_sort.py
@@ -34,8 +34,16 @@ def quick_sort(collection):
         return collection
     else:
         pivot = collection[0]
-        greater = [element for element in collection[1:] if element > pivot]
-        lesser = [element for element in collection[1:] if element <= pivot]
+        # Modify the list comprehensions to reduce the number of judgments, the speed has increased by more than 50%.
+        greater = []
+        lesser = []
+        for element in collection[1:]:
+            if element > pivot:
+                greater.append(element)
+            else:
+                lesser.append(element)
+        # greater = [element for element in collection[1:] if element > pivot]
+        # lesser = [element for element in collection[1:] if element <= pivot]
         return quick_sort(lesser) + [pivot] + quick_sort(greater)
 
 

From 9f982a83c8a1f9f5b06a8720eaf78d60485a18fa Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Henrique=20Ivanchechen?=
 <joseivanchechen@outlook.com>
Date: Fri, 24 May 2019 14:16:39 -0300
Subject: [PATCH 023/348] add pigeon hole sort (#833)

---
 sorts/pigeon_sort.py | 50 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 50 insertions(+)
 create mode 100644 sorts/pigeon_sort.py

diff --git a/sorts/pigeon_sort.py b/sorts/pigeon_sort.py
new file mode 100644
index 000000000000..65eb8896ea9c
--- /dev/null
+++ b/sorts/pigeon_sort.py
@@ -0,0 +1,50 @@
+'''
+    This is an implementation of Pigeon Hole Sort.
+'''
+
+from __future__ import print_function
+
+def pigeon_sort(array):
+    # Manually finds the minimum and maximum of the array.
+    min = array[0]
+    max = array[0]
+
+    for i in range(len(array)):
+        if(array[i] < min): min = array[i]
+        elif(array[i] > max): max = array[i]
+
+    # Compute the variables
+    holes_range = max-min + 1
+    holes = [0 for _ in range(holes_range)]
+    holes_repeat = [0 for _ in range(holes_range)]
+
+    # Make the sorting.
+    for i in range(len(array)):
+        index = array[i] - min
+        if(holes[index] != array[i]):
+            holes[index] = array[i]
+            holes_repeat[index] += 1
+        else: holes_repeat[index] += 1
+
+    # Makes the array back by replacing the numbers.
+    index = 0
+    for i in range(holes_range):
+        while(holes_repeat[i] > 0):
+            array[index] = holes[i]
+            index += 1
+            holes_repeat[i] -= 1
+
+    # Returns the sorted array.
+    return array
+
+if __name__ == '__main__':
+    try:
+        raw_input           # Python2
+    except NameError:
+        raw_input = input   # Python 3
+    
+    user_input = raw_input('Enter numbers separated by comma:\n')
+    unsorted = [int(x) for x in user_input.split(',')]
+    sorted = pigeon_sort(unsorted)
+
+    print(sorted)

From 02c0daf9e5c7dc44205b9270507348109888877a Mon Sep 17 00:00:00 2001
From: Mehdi ALAOUI <alaoui.mehdi.1995@gmail.com>
Date: Sat, 25 May 2019 15:41:24 +0200
Subject: [PATCH 024/348] Adding unit tests for sorting functions, and
 improving readability on some sorting algorithms (#784)

* Adding variable to fade out ambiguity

* More readability on merge sorting algorithm

* Updating merge_sort_fastest description and explaining why

* Adding tests file with imports

* Standardazing filenames and function names

* Adding test cases and test functions

* Adding test loop

* Putting 'user oriented code' inside main condition for having valid imports

* Fixing condition

* Updating tests: adding cases and todo list

* Refactoring first euler problem's first solution
---
 project_euler/problem_01/sol1.py      |  6 +--
 sorts/{bogosort.py => bogo_sort.py}   | 16 +++---
 sorts/bucket_sort.py                  |  2 +-
 sorts/{cyclesort.py => cycle_sort.py} | 16 +++---
 sorts/insertion_sort.py               | 10 ++--
 sorts/merge_sort.py                   |  2 +-
 sorts/merge_sort_fastest.py           |  2 +-
 sorts/pancake_sort.py                 |  5 +-
 sorts/radix_sort.py                   |  2 +-
 sorts/tests.py                        | 74 +++++++++++++++++++++++++++
 sorts/{timsort.py => tim_sort.py}     |  4 +-
 sorts/topological_sort.py             |  6 +--
 sorts/tree_sort.py                    |  5 +-
 sorts/wiggle_sort.py                  | 18 +++----
 14 files changed, 120 insertions(+), 48 deletions(-)
 rename sorts/{bogosort.py => bogo_sort.py} (81%)
 rename sorts/{cyclesort.py => cycle_sort.py} (83%)
 create mode 100644 sorts/tests.py
 rename sorts/{timsort.py => tim_sort.py} (97%)

diff --git a/project_euler/problem_01/sol1.py b/project_euler/problem_01/sol1.py
index 27031c3cfa9a..c9a8c0f1ebeb 100644
--- a/project_euler/problem_01/sol1.py
+++ b/project_euler/problem_01/sol1.py
@@ -10,8 +10,4 @@
 except NameError:
     raw_input = input  # Python 3
 n = int(raw_input().strip())
-sum=0
-for a in range(3,n):
-    if(a%3==0 or a%5==0):
-        sum+=a
-print(sum)
+print(sum([e for e in range(3, n) if e % 3 == 0 or e % 5 == 0]))
diff --git a/sorts/bogosort.py b/sorts/bogo_sort.py
similarity index 81%
rename from sorts/bogosort.py
rename to sorts/bogo_sort.py
index 33eac66bf21c..056e8e68a92e 100644
--- a/sorts/bogosort.py
+++ b/sorts/bogo_sort.py
@@ -1,28 +1,28 @@
 """
 This is a pure python implementation of the bogosort algorithm
 For doctests run following command:
-python -m doctest -v bogosort.py
+python -m doctest -v bogo_sort.py
 or
-python3 -m doctest -v bogosort.py
+python3 -m doctest -v bogo_sort.py
 For manual testing run:
-python bogosort.py
+python bogo_sort.py
 """
 
 from __future__ import print_function
 import random
 
 
-def bogosort(collection):
+def bogo_sort(collection):
     """Pure implementation of the bogosort algorithm in Python
     :param collection: some mutable ordered collection with heterogeneous
     comparable items inside
     :return: the same collection ordered by ascending
     Examples:
-    >>> bogosort([0, 5, 3, 2, 2])
+    >>> bogo_sort([0, 5, 3, 2, 2])
     [0, 2, 2, 3, 5]
-    >>> bogosort([])
+    >>> bogo_sort([])
     []
-    >>> bogosort([-2, -5, -45])
+    >>> bogo_sort([-2, -5, -45])
     [-45, -5, -2]
     """
 
@@ -46,4 +46,4 @@ def isSorted(collection):
 
     user_input = raw_input('Enter numbers separated by a comma:\n').strip()
     unsorted = [int(item) for item in user_input.split(',')]
-    print(bogosort(unsorted))
+    print(bogo_sort(unsorted))
diff --git a/sorts/bucket_sort.py b/sorts/bucket_sort.py
index cca913328e40..c4d61874fc47 100644
--- a/sorts/bucket_sort.py
+++ b/sorts/bucket_sort.py
@@ -32,4 +32,4 @@ def bucket_sort(my_list, bucket_size=DEFAULT_BUCKET_SIZE):
 if __name__ == "__main__":
     user_input = input('Enter numbers separated by a comma:').strip()
     unsorted = [float(n) for n in user_input.split(',') if len(user_input) > 0]
-    print(bucket_sort(unsorted))
+    print(bucket_sort(unsorted))
\ No newline at end of file
diff --git a/sorts/cyclesort.py b/sorts/cycle_sort.py
similarity index 83%
rename from sorts/cyclesort.py
rename to sorts/cycle_sort.py
index ee19a1ade360..492022164427 100644
--- a/sorts/cyclesort.py
+++ b/sorts/cycle_sort.py
@@ -50,11 +50,11 @@ def cycle_sort(array):
     except NameError:
         raw_input = input  # Python 3
         
-user_input = raw_input('Enter numbers separated by a comma:\n')
-unsorted = [int(item) for item in user_input.split(',')]
-n = len(unsorted)
-cycle_sort(unsorted)
-
-print("After sort : ")
-for i in range(0, n):
-    print(unsorted[i], end=' ')
+    user_input = raw_input('Enter numbers separated by a comma:\n')
+    unsorted = [int(item) for item in user_input.split(',')]
+    n = len(unsorted)
+    cycle_sort(unsorted)
+
+    print("After sort : ")
+    for i in range(0, n):
+        print(unsorted[i], end=' ')
diff --git a/sorts/insertion_sort.py b/sorts/insertion_sort.py
index 59917ac059a7..e088705947d4 100644
--- a/sorts/insertion_sort.py
+++ b/sorts/insertion_sort.py
@@ -29,10 +29,12 @@ def insertion_sort(collection):
     >>> insertion_sort([-2, -5, -45])
     [-45, -5, -2]
     """
-    for index in range(1, len(collection)):
-        while index > 0 and collection[index - 1] > collection[index]:
-            collection[index], collection[index - 1] = collection[index - 1], collection[index]
-            index -= 1
+
+    for loop_index in range(1, len(collection)):
+        insertion_index = loop_index
+        while insertion_index > 0 and collection[insertion_index - 1] > collection[insertion_index]:
+            collection[insertion_index], collection[insertion_index - 1] = collection[insertion_index - 1], collection[insertion_index]
+            insertion_index -= 1
 
     return collection
 
diff --git a/sorts/merge_sort.py b/sorts/merge_sort.py
index 4a6201a40cb4..ecbad7075119 100644
--- a/sorts/merge_sort.py
+++ b/sorts/merge_sort.py
@@ -53,4 +53,4 @@ def merge(left, right):
 
     user_input = raw_input('Enter numbers separated by a comma:\n').strip()
     unsorted = [int(item) for item in user_input.split(',')]
-    print(*merge_sort(unsorted), sep=',')
+    print(*merge_sort(unsorted), sep=',')
\ No newline at end of file
diff --git a/sorts/merge_sort_fastest.py b/sorts/merge_sort_fastest.py
index 86cb8ae1a699..bd356c935ca0 100644
--- a/sorts/merge_sort_fastest.py
+++ b/sorts/merge_sort_fastest.py
@@ -2,7 +2,7 @@
 Python implementation of the fastest merge sort algorithm.
 Takes an average of 0.6 microseconds to sort a list of length 1000 items.
 Best Case Scenario : O(n)
-Worst Case Scenario : O(n)
+Worst Case Scenario : O(n^2) because native python functions:min, max and remove are already O(n)
 '''
 from __future__ import print_function
 
diff --git a/sorts/pancake_sort.py b/sorts/pancake_sort.py
index 26fd40b7f67c..478a9a967d27 100644
--- a/sorts/pancake_sort.py
+++ b/sorts/pancake_sort.py
@@ -1,7 +1,7 @@
 # Pancake sort algorithm 
 # Only can reverse array from 0 to i
 
-def pancakesort(arr):
+def pancake_sort(arr):
     cur = len(arr)
     while cur > 1:
         # Find the maximum number in arr
@@ -13,4 +13,5 @@ def pancakesort(arr):
         cur -= 1
     return arr
 
-print(pancakesort([0,10,15,3,2,9,14,13]))
+if __name__ == '__main__':
+    print(pancake_sort([0,10,15,3,2,9,14,13]))
diff --git a/sorts/radix_sort.py b/sorts/radix_sort.py
index e4cee61f35e3..8dfc66b17b23 100644
--- a/sorts/radix_sort.py
+++ b/sorts/radix_sort.py
@@ -1,4 +1,4 @@
-def radixsort(lst):
+def radix_sort(lst):
     RADIX = 10
     placement = 1
 
diff --git a/sorts/tests.py b/sorts/tests.py
new file mode 100644
index 000000000000..225763625f51
--- /dev/null
+++ b/sorts/tests.py
@@ -0,0 +1,74 @@
+from bogo_sort import bogo_sort
+from bubble_sort import bubble_sort
+from bucket_sort import bucket_sort
+from cocktail_shaker_sort import cocktail_shaker_sort
+from comb_sort import comb_sort
+from counting_sort import counting_sort
+from cycle_sort import cycle_sort
+from gnome_sort import gnome_sort
+from heap_sort import heap_sort
+from insertion_sort import insertion_sort
+from merge_sort_fastest import merge_sort as merge_sort_fastest
+from merge_sort import merge_sort
+from pancake_sort import pancake_sort
+from quick_sort_3_partition import quick_sort_3partition
+from quick_sort import quick_sort
+from radix_sort import radix_sort
+from random_pivot_quick_sort import quick_sort_random
+from selection_sort import selection_sort
+from shell_sort import shell_sort
+from tim_sort import tim_sort
+from topological_sort import topological_sort
+from tree_sort import tree_sort
+from wiggle_sort import wiggle_sort
+
+
+TEST_CASES = [
+    {'input': [8, 7, 6, 5, 4, 3, -2, -5], 'expected': [-5, -2, 3, 4, 5, 6, 7, 8]},
+    {'input': [-5, -2, 3, 4, 5, 6, 7, 8], 'expected': [-5, -2, 3, 4, 5, 6, 7, 8]},
+    {'input': [5, 6, 1, 4, 0, 1, -2, -5, 3, 7], 'expected': [-5, -2, 0, 1, 1, 3, 4, 5, 6, 7]},
+    {'input': [2, -2], 'expected': [-2, 2]},
+    {'input': [1], 'expected': [1]},
+    {'input': [], 'expected': []},
+]
+
+'''
+    TODO:
+    - Fix some broken tests in particular cases (as [] for example),
+    - Unify the input format: should always be function(input_collection) (no additional args)
+    - Unify the output format: should always be a collection instead of updating input elements
+      and returning None
+    - Rewrite some algorithms in function format (in case there is no function definition)
+'''
+
+TEST_FUNCTIONS = [
+    bogo_sort,
+    bubble_sort,
+    bucket_sort,
+    cocktail_shaker_sort,
+    comb_sort,
+    counting_sort,
+    cycle_sort,
+    gnome_sort,
+    heap_sort,
+    insertion_sort,
+    merge_sort_fastest,
+    merge_sort,
+    pancake_sort,
+    quick_sort_3partition,
+    quick_sort,
+    radix_sort,
+    quick_sort_random,
+    selection_sort,
+    shell_sort,
+    tim_sort,
+    topological_sort,
+    tree_sort,
+    wiggle_sort,
+]
+
+
+for function in TEST_FUNCTIONS:
+    for case in TEST_CASES:
+        result = function(case['input'])
+        assert result  == case['expected'], 'Executed function: {}, {} != {}'.format(function.__name__, result, case['expected'])
diff --git a/sorts/timsort.py b/sorts/tim_sort.py
similarity index 97%
rename from sorts/timsort.py
rename to sorts/tim_sort.py
index 80c5cd1e8d3f..b4032b91aec1 100644
--- a/sorts/timsort.py
+++ b/sorts/tim_sort.py
@@ -41,7 +41,7 @@ def merge(left, right):
     return [right[0]] + merge(left, right[1:])
 
 
-def timsort(lst):
+def tim_sort(lst):
     runs, sorted_runs = [], []
     length = len(lst)
     new_run = [lst[0]]
@@ -75,7 +75,7 @@ def timsort(lst):
 def main():
 
     lst = [5,9,10,3,-4,5,178,92,46,-18,0,7]
-    sorted_lst = timsort(lst)
+    sorted_lst = tim_sort(lst)
     print(sorted_lst)
 
 if __name__ == '__main__':
diff --git a/sorts/topological_sort.py b/sorts/topological_sort.py
index 52dc34f4f733..db4dd250a119 100644
--- a/sorts/topological_sort.py
+++ b/sorts/topological_sort.py
@@ -28,6 +28,6 @@ def topological_sort(start, visited, sort):
     # return sort
     return sort
 
-
-sort = topological_sort('a', [], [])
-print(sort)
+if __name__ == '__main__':
+    sort = topological_sort('a', [], [])
+    print(sort)
diff --git a/sorts/tree_sort.py b/sorts/tree_sort.py
index f8ecf84c6ff8..d06b0de28e56 100644
--- a/sorts/tree_sort.py
+++ b/sorts/tree_sort.py
@@ -30,7 +30,7 @@ def inorder(root, res):
         res.append(root.val)
         inorder(root.right,res)
 
-def treesort(arr):
+def tree_sort(arr):
     # Build BST
     if len(arr) == 0:
         return arr
@@ -42,4 +42,5 @@ def treesort(arr):
     inorder(root,res)
     return res
 
-print(treesort([10,1,3,2,9,14,13]))
\ No newline at end of file
+if __name__ == '__main__':
+    print(tree_sort([10,1,3,2,9,14,13]))
diff --git a/sorts/wiggle_sort.py b/sorts/wiggle_sort.py
index cc83487bdeb1..0d4f20e3f96b 100644
--- a/sorts/wiggle_sort.py
+++ b/sorts/wiggle_sort.py
@@ -9,13 +9,11 @@ def wiggle_sort(nums):
         if (i % 2 == 1) == (nums[i-1] > nums[i]):
             nums[i-1], nums[i] = nums[i], nums[i-1]
 
-
-print("Enter the array elements:\n")
-array=list(map(int,input().split()))
-print("The unsorted array is:\n")
-print(array)
-wiggle_sort(array)
-print("Array after Wiggle sort:\n")
-print(array)
-
-
+if __name__ == '__main__':
+    print("Enter the array elements:\n")
+    array=list(map(int,input().split()))
+    print("The unsorted array is:\n")
+    print(array)
+    wiggle_sort(array)
+    print("Array after Wiggle sort:\n")
+    print(array)

From 94380a17a806e28fc73695d84581d638eabd286a Mon Sep 17 00:00:00 2001
From: Artyom Belousov <flygrounder@yandex.ru>
Date: Sun, 26 May 2019 01:20:37 +0300
Subject: [PATCH 025/348] Added treap (#797)

* Added treap

* Added comments to treap
---
 data_structures/binary tree/treap.py | 129 +++++++++++++++++++++++++++
 1 file changed, 129 insertions(+)
 create mode 100644 data_structures/binary tree/treap.py

diff --git a/data_structures/binary tree/treap.py b/data_structures/binary tree/treap.py
new file mode 100644
index 000000000000..0399ff67030a
--- /dev/null
+++ b/data_structures/binary tree/treap.py	
@@ -0,0 +1,129 @@
+from random import random
+from typing import Tuple
+
+
+class Node:
+    """
+    Treap's node
+    Treap is a binary tree by key and heap by priority
+    """
+    def __init__(self, key: int):
+        self.key = key
+        self.prior = random()
+        self.l = None
+        self.r = None
+
+
+def split(root: Node, key: int) -> Tuple[Node, Node]:
+    """
+    We split current tree into 2 trees with key:
+
+    Left tree contains all keys less than split key.
+    Right tree contains all keys greater or equal, than split key
+    """
+    if root is None:  # None tree is split into 2 Nones
+        return (None, None)
+    if root.key >= key:
+        """
+        Right tree's root will be current node.
+        Now we split(with the same key) current node's left son
+        Left tree: left part of that split
+        Right tree's left son: right part of that split
+        """
+        l, root.l = split(root.l, key)
+        return (l, root)
+    else:
+        """
+        Just symmetric to previous case
+        """
+        root.r, r = split(root.r, key)
+        return (root, r)
+
+
+def merge(left: Node, right: Node) -> Node:
+    """
+    We merge 2 trees into one.
+    Note: all left tree's keys must be less than all right tree's
+    """
+    if (not left) or (not right):
+        """
+        If one node is None, return the other
+        """
+        return left or right
+    if left.key > right.key:
+        """
+        Left will be root because it has more priority
+        Now we need to merge left's right son and right tree
+        """
+        left.r = merge(left.r, right)
+        return left
+    else:
+        """
+        Symmetric as well
+        """
+        right.l = merge(left, right.l)
+        return right
+
+
+def insert(root: Node, key: int) -> Node:
+    """
+    Insert element
+
+    Split current tree with a key into l, r,
+    Insert new node into the middle
+    Merge l, node, r into root
+    """
+    node = Node(key)
+    l, r = split(root, key)
+    root = merge(l, node)
+    root = merge(root, r)
+    return root
+
+
+def erase(root: Node, key: int) -> Node:
+    """
+    Erase element
+
+    Split all nodes with keys less into l,
+    Split all nodes with keys greater into r.
+    Merge l, r
+    """
+    l, r = split(root, key)
+    _, r = split(r, key + 1)
+    return merge(l, r)
+
+
+def node_print(root: Node):
+    """
+    Just recursive print of a tree
+    """
+    if not root:
+        return
+    node_print(root.l)
+    print(root.key, end=" ")
+    node_print(root.r)
+
+
+def interactTreap():
+    """
+    Commands:
+    + key to add key into treap
+    - key to erase all nodes with key
+
+    After each command, program prints treap
+    """
+    root = None
+    while True:
+        cmd = input().split()
+        cmd[1] = int(cmd[1])
+        if cmd[0] == "+":
+            root = insert(root, cmd[1])
+        elif cmd[0] == "-":
+            root = erase(root, cmd[1])
+        else:
+            print("Unknown command")
+        node_print(root)
+
+
+if __name__ == "__main__":
+    interactTreap()

From 23938708ac53f6544f013a6dbb292beb35e14177 Mon Sep 17 00:00:00 2001
From: Anup Kumar Panwar <1anuppanwar@gmail.com>
Date: Sun, 26 May 2019 17:11:41 +0530
Subject: [PATCH 026/348] Update README.md

---
 README.md | 354 ++----------------------------------------------------
 1 file changed, 9 insertions(+), 345 deletions(-)

diff --git a/README.md b/README.md
index 9b61f1b63287..8172df62309f 100644
--- a/README.md
+++ b/README.md
@@ -4,352 +4,16 @@
 
 ### All algorithms implemented in Python (for education)
 
-These implementations are for demonstration purposes. They are less efficient than the implementations in the Python standard library.
+These implementations are for learning purposes. They may be efficient than the implementations in the Python standard library.
 
-## Sorting Algorithms
+## Contribution Guidelines
 
+* File name should be in camel case.
+* Write proper documentation of the code.
+* Avoid input methods as far as possible. Assign values to the variables statically. This will make the code easy to understand and algorithm can be traced easily.
+* Add a corresponding explaination to [Algorithms-Explanation](https://github.com/TheAlgorithms/Algorithms-Explanation) (Optional but recommended).
+* Avoid importing external libraries for basic algorithms.
 
-### Bubble Sort
-![alt text][bubble-image]
+## Community Channel
 
-**Bubble sort**, sometimes referred to as *sinking sort*, is a simple sorting algorithm that repeatedly steps through the list to be sorted, compares each pair of adjacent items and swaps them if they are in the wrong order. The pass through the list is repeated until no swaps are needed, which indicates that the list is sorted.
-
-__Properties__
-* Worst case performance	O(n<sup>2</sup>)
-* Best case performance	O(n)
-* Average case performance	O(n<sup>2</sup>)
-
-###### Source: [Wikipedia][bubble-wiki] 
-###### View the algorithm in [action][bubble-toptal]
-
-### Bucket
-![alt text][bucket-image-1]
-![alt text][bucket-image-2]
-
-**Bucket sort**, or _bin sort_, is a sorting algorithm that works by distributing the elements of an array into a number of buckets. Each bucket is then sorted individually, either using a different sorting algorithm, or by recursively applying the bucket sorting algorithm.
-
-__Properties__
-* Worst case performance	O(n<sup>2</sup>)
-* Best case performance	O(n+k)
-* Average case performance	O(n+k)
-
-###### Source: [Wikipedia][bucket-wiki] 
-
-
-### Cocktail shaker
-![alt text][cocktail-shaker-image]
-
-**Cocktail shaker sort**, also known as _bidirectional bubble sort_, _cocktail sort_, _shaker sort_ (which can also refer to a variant of _selection sort_), _ripple sort_, _shuffle sort_, or _shuttle sort_, is a variation of bubble sort that is both a stable sorting algorithm and a comparison sort. The algorithm differs from a bubble sort in that it sorts in both directions on each pass through the list.
-
-__Properties__
-* Worst case performance	O(n<sup>2</sup>)
-* Best case performance	O(n)
-* Average case performance	O(n<sup>2</sup>)
-
-###### Source: [Wikipedia][cocktail-shaker-wiki] 
-
-
-### Insertion Sort
-![alt text][insertion-image]
-
-**Insertion sort** is a simple sorting algorithm that builds the final sorted array (or list) one item at a time. It is much less efficient on *large* lists than more advanced algorithms such as quicksort, heapsort, or merge sort.
-
-__Properties__
-* Worst case performance	O(n<sup>2</sup>)
-* Best case performance	O(n)
-* Average case performance	O(n<sup>2</sup>)
-
-###### Source: [Wikipedia][insertion-wiki]
-###### View the algorithm in [action][insertion-toptal]
-
-
-### Merge Sort
-![alt text][merge-image]
-
-**Merge sort** (also commonly spelled *mergesort*) is an efficient, general-purpose, comparison-based sorting algorithm. Most implementations produce a stable sort, which means that the implementation preserves the input order of equal elements in the sorted output. Mergesort is a divide and conquer algorithm that was invented by John von Neumann in 1945.
-
-__Properties__
-* Worst case performance	O(n log n)
-* Best case performance	O(n log n)
-* Average case performance	O(n log n)
-
-###### Source: [Wikipedia][merge-wiki] 
-###### View the algorithm in [action][merge-toptal]
-
-### Quick
-![alt text][quick-image]
-
-**Quicksort** (sometimes called *partition-exchange sort*) is an efficient sorting algorithm, serving as a systematic method for placing the elements of an array in order.
-
-__Properties__
-* Worst case performance	O(n<sup>2</sup>)
-* Best case performance	O(*n* log *n*) or O(n) with three-way partition
-* Average case performance	O(*n* log *n*)
-
-###### Source: [Wikipedia][quick-wiki]
-###### View the algorithm in [action][quick-toptal]
-
-
-### Heap
-![alt text][heapsort-image]
-
-**Heapsort** is a _comparison-based_ sorting algorithm. It can be thought of as an improved selection sort. It divides its input into a sorted and an unsorted region, and it iteratively shrinks the unsorted region by extracting the largest element and moving that to the sorted region.
-
-__Properties__
-* Worst case performance	O(*n* log *n*)
-* Best case performance	O(*n* log *n*)
-* Average case performance	O(*n* log *n*)
-
-###### Source: [Wikipedia][heap-wiki]
-###### View the algorithm in [action](https://www.toptal.com/developers/sorting-algorithms/heap-sort)
-
-
-### Radix
-
-From [Wikipedia][radix-wiki]: Radix sort is a non-comparative integer sorting algorithm that sorts data with integer keys by grouping keys by the individual digits which share the same significant position and value.
-
-__Properties__
-* Worst case performance	O(wn)
-* Best case performance	O(wn)
-* Average case performance	O(wn)
-
-###### Source: [Wikipedia][radix-wiki] 
-
-
-### Selection
-![alt text][selection-image]
-
-**Selection sort** is an algorithm that divides the input list into two parts: the sublist of items already sorted, which is built up from left to right at the front (left) of the list, and the sublist of items remaining to be sorted that occupy the rest of the list. Initially, the sorted sublist is empty and the unsorted sublist is the entire input list. The algorithm proceeds by finding the smallest (or largest, depending on sorting order) element in the unsorted sublist, exchanging (swapping) it with the leftmost unsorted element (putting it in sorted order), and moving the sublist boundaries one element to the right.
-
-__Properties__
-* Worst case performance	O(n<sup>2</sup>)
-* Best case performance	O(n<sup>2</sup>)
-* Average case performance	O(n<sup>2</sup>)
-
-###### Source: [Wikipedia][selection-wiki] 
-###### View the algorithm in [action][selection-toptal]
-
-
-### Shell
-![alt text][shell-image]
-
-**Shellsort** is a generalization of *insertion sort* that allows the exchange of items that are far apart.  The idea is to arrange the list of elements so that, starting anywhere, considering every nth element gives a sorted list.  Such a list is said to be h-sorted.  Equivalently, it can be thought of as h interleaved lists, each individually sorted.
-
-__Properties__
-* Worst case performance O(*n*log<sup>2</sup>*n*)
-* Best case performance O(*n* log *n*)
-* Average case performance depends on gap sequence
-
-###### Source: [Wikipedia][shell-wiki]
-###### View the algorithm in [action][shell-toptal]
-
-
-### Topological
-
-From [Wikipedia][topological-wiki]: **Topological sort**, or _topological ordering of a directed graph_ is a linear ordering of its vertices such that for every directed edge _uv_ from vertex _u_ to vertex _v_, _u_ comes before _v_ in the ordering. For instance, the vertices of the graph may represent tasks to be performed, and the edges may represent constraints that one task must be performed before another; in this application, a topological ordering is just a valid sequence for the tasks. A topological ordering is possible if and only if the graph has no directed cycles, that is, if it is a _directed acyclic graph_ (DAG). Any DAG has at least one topological ordering, and algorithms are known for constructing a topological ordering of any DAG in linear time.
-
-### Time-Complexity Graphs
-
-Comparing the complexity of sorting algorithms (*Bubble Sort*, *Insertion Sort*, *Selection Sort*)
-
-![Complexity Graphs](https://github.com/prateekiiest/Python/blob/master/sorts/sortinggraphs.png)
-
-Comparing the sorting algorithms:
-<br>  -Quicksort is a very fast algorithm but can be pretty tricky to implement
-<br>  -Bubble sort is a slow algorithm but is very easy to implement. To sort small sets of data, bubble sort may be a better option since it can be implemented quickly, but for larger datasets, the speedup from quicksort might be worth the trouble implementing the algorithm.
-
-----------------------------------------------------------------------------------
-
-## Search Algorithms
-
-### Linear
-![alt text][linear-image]
-
-**Linear search** or *sequential search* is a method for finding a target value within a list. It sequentially checks each element of the list for the target value until a match is found or until all the elements have been searched. Linear search runs in at worst linear time and makes at most n comparisons, where n is the length of the list.
-
-__Properties__
-* Worst case performance	O(n)
-* Best case performance	O(1)
-* Average case performance	O(n)
-* Worst case space complexity	O(1) iterative
-
-###### Source: [Wikipedia][linear-wiki]
-
-
-### Binary
-![alt text][binary-image]
-
-**Binary search**, also known as *half-interval search* or *logarithmic search*, is a search algorithm that finds the position of a target value within a sorted array. It compares the target value to the middle element of the array; if they are unequal, the half in which the target cannot lie is eliminated and the search continues on the remaining half until it is successful.
-
-__Properties__
-* Worst case performance	O(log n)
-* Best case performance	O(1)
-* Average case performance	O(log n)
-* Worst case space complexity	O(1)
-
-###### Source: [Wikipedia][binary-wiki]
-
-
-## Interpolation
-**Interpolation search** is an algorithm for searching for a key in an array that has been ordered by numerical values assigned to the keys (key values). It was first described by W. W. Peterson in 1957. Interpolation search resembles the method by which people search a telephone directory for a name (the key value by which the book's entries are ordered): in each step the algorithm calculates where in the remaining search space the sought item might be, based on the key values at the bounds of the search space and the value of the sought key, usually via a linear interpolation. The key value actually found at this estimated position is then compared to the key value being sought. If it is not equal, then depending on the comparison, the remaining search space is reduced to the part before or after the estimated position. This method will only work if calculations on the size of differences between key values are sensible.
-
-By comparison, binary search always chooses the middle of the remaining search space, discarding one half or the other, depending on the comparison between the key found at the estimated position and the key sought — it does not require numerical values for the keys, just a total order on them. The remaining search space is reduced to the part before or after the estimated position. The linear search uses equality only as it compares elements one-by-one from the start, ignoring any sorting.
-
-On average the interpolation search makes about log(log(n)) comparisons (if the elements are uniformly distributed), where n is the number of elements to be searched. In the worst case (for instance where the numerical values of the keys increase exponentially) it can make up to O(n) comparisons.
-
-In interpolation-sequential search, interpolation is used to find an item near the one being searched for, then linear search is used to find the exact item.
-
-###### Source: [Wikipedia][interpolation-wiki] 
-
-
-## Jump Search
-**Jump search** or _block search_ refers to a search algorithm for ordered lists. It works by first checking all items Lkm, where {\displaystyle k\in \mathbb {N} } k\in \mathbb {N}  and m is the block size, until an item is found that is larger than the search key. To find the exact position of the search key in the list a linear search is performed on the sublist L[(k-1)m, km].
-
-The optimal value of m is √n, where n is the length of the list L. Because both steps of the algorithm look at, at most, √n items the algorithm runs in O(√n) time. This is better than a linear search, but worse than a binary search. The advantage over the latter is that a jump search only needs to jump backwards once, while a binary can jump backwards up to log n times. This can be important if a jumping backwards takes significantly more time than jumping forward.
-
-The algorithm can be modified by performing multiple levels of jump search on the sublists, before finally performing the linear search. For an k-level jump search the optimum block size ml for the lth level (counting from 1) is n(k-l)/k. The modified algorithm will perform k backward jumps and runs in O(kn1/(k+1)) time.
-
-###### Source: [Wikipedia][jump-wiki]
-
-
-## Quick Select
-![alt text][QuickSelect-image]
-
-**Quick Select** is a selection algorithm to find the kth smallest element in an unordered list. It is related to the quicksort sorting algorithm. Like quicksort, it was developed by Tony Hoare, and thus is also known as Hoare's selection algorithm.[1] Like quicksort, it is efficient in practice and has good average-case performance, but has poor worst-case performance. Quickselect and its variants are the selection algorithms most often used in efficient real-world implementations.
-
-Quickselect uses the same overall approach as quicksort, choosing one element as a pivot and partitioning the data in two based on the pivot, accordingly as less than or greater than the pivot. However, instead of recursing into both sides, as in quicksort, quickselect only recurses into one side – the side with the element it is searching for. This reduces the average complexity from O(n log n) to O(n), with a worst case of O(n<sup>2</sup>).
-
-As with quicksort, quickselect is generally implemented as an in-place algorithm, and beyond selecting the k'th element, it also partially sorts the data. See selection algorithm for further discussion of the connection with sorting.
-
-###### Source: [Wikipedia][quick-wiki]
-
-
-## Tabu
-**Tabu search** uses a local or neighborhood search procedure to iteratively move from one potential solution {\displaystyle x} x to an improved solution {\displaystyle x'} x' in the neighborhood of {\displaystyle x} x, until some stopping criterion has been satisfied (generally, an attempt limit or a score threshold). Local search procedures often become stuck in poor-scoring areas or areas where scores plateau. In order to avoid these pitfalls and explore regions of the search space that would be left unexplored by other local search procedures, tabu search carefully explores the neighborhood of each solution as the search progresses. The solutions admitted to the new neighborhood, {\displaystyle N^{*}(x)} N^*(x), are determined through the use of memory structures. Using these memory structures, the search progresses by iteratively moving from the current solution {\displaystyle x} x to an improved solution {\displaystyle x'} x' in {\displaystyle N^{*}(x)} N^*(x).
-
-These memory structures form what is known as the tabu list, a set of rules and banned solutions used to filter which solutions will be admitted to the neighborhood {\displaystyle N^{*}(x)} N^*(x) to be explored by the search. In its simplest form, a tabu list is a short-term set of the solutions that have been visited in the recent past (less than {\displaystyle n} n iterations ago, where {\displaystyle n} n is the number of previous solutions to be stored — is also called the tabu tenure). More commonly, a tabu list consists of solutions that have changed by the process of moving from one solution to another. It is convenient, for ease of description, to understand a “solution” to be coded and represented by such attributes.
-
-###### Source: [Wikipedia][tabu-wiki] 
-
-----------------------------------------------------------------------------------------------------------------------
-
-## Ciphers
-
-### Caesar
-![alt text][caesar]
-
-**Caesar cipher**, also known as _Caesar's cipher_, the _shift cipher_, _Caesar's code_ or _Caesar shift_, is one of the simplest and most widely known encryption techniques.<br>
-It is **a type of substitution cipher** in which each letter in the plaintext is replaced by a letter some fixed number of positions down the alphabet. For example, with a left shift of 3, D would be replaced by A, E would become B, and so on. <br>
-The method is named after **Julius Caesar**, who used it in his private correspondence.<br>
-The encryption step performed by a Caesar cipher is often incorporated as part of more complex schemes, such as the Vigenère cipher, and still has modern application in the ROT13 system. As with all single-alphabet substitution ciphers, the Caesar cipher is easily broken and in modern practice offers essentially no communication security.
-
-###### Source: [Wikipedia](https://en.wikipedia.org/wiki/Caesar_cipher)
-
-
-### Vigenère
-
-**Vigenère cipher** is a method of encrypting alphabetic text by using a series of **interwoven Caesar ciphers** based on the letters of a keyword. It is **a form of polyalphabetic substitution**.<br>
-The Vigenère cipher has been reinvented many times. The method was originally described by Giovan Battista Bellaso in his 1553 book La cifra del. Sig. Giovan Battista Bellaso; however, the scheme was later misattributed to Blaise de Vigenère in the 19th century, and is now widely known as the "Vigenère cipher".<br>
-Though the cipher is easy to understand and implement, for three centuries it resisted all attempts to break it; this earned it the description **le chiffre indéchiffrable**(French for 'the indecipherable cipher').
-Many people have tried to implement encryption schemes that are essentially Vigenère ciphers. Friedrich Kasiski was the first to publish a general method of deciphering a Vigenère cipher in 1863.
-
-###### Source: [Wikipedia](https://en.wikipedia.org/wiki/Vigen%C3%A8re_cipher)
-
-
-### Transposition
-
-**Transposition cipher** is a method of encryption by which the positions held by units of *plaintext* (which are commonly characters or groups of characters) are shifted according to a regular system, so that the *ciphertext* constitutes a permutation of the plaintext. That is, the order of the units is changed (the plaintext is reordered).<br> 
-
-Mathematically a bijective function is used on the characters' positions to encrypt and an inverse function to decrypt.
-
-###### Source: [Wikipedia](https://en.wikipedia.org/wiki/Transposition_cipher)
-
-
-### RSA (Rivest–Shamir–Adleman)
-**RSA** _(Rivest–Shamir–Adleman)_ is one of the first public-key cryptosystems and is widely used for secure data transmission. In such a cryptosystem, the encryption key is public and it is different from the decryption key which is kept secret (private). In RSA, this asymmetry is based on the practical difficulty of the factorization of the product of two large prime numbers, the "factoring problem". The acronym RSA is made of the initial letters of the surnames of Ron Rivest, Adi Shamir, and Leonard Adleman, who first publicly described the algorithm in 1978. Clifford Cocks, an English mathematician working for the British intelligence agency Government Communications Headquarters (GCHQ), had developed an equivalent system in 1973, but this was not declassified until 1997.[1]
-
-A user of RSA creates and then publishes a public key based on two large prime numbers, along with an auxiliary value. The prime numbers must be kept secret. Anyone can use the public key to encrypt a message, but with currently published methods, and if the public key is large enough, only someone with knowledge of the prime numbers can decode the message feasibly.[2] Breaking RSA encryption is known as the RSA problem. Whether it is as difficult as the factoring problem remains an open question.
-
-###### Source: [Wikipedia](https://en.wikipedia.org/wiki/RSA_(cryptosystem))
-
-
-## ROT13
-![alt text][ROT13-image]
-
-**ROT13** ("rotate by 13 places", sometimes hyphenated _ROT-13_) is a simple letter substitution cipher that replaces a letter with the 13th letter after it, in the alphabet. ROT13 is a special case of the Caesar cipher which was developed in ancient Rome.
-
-Because there are 26 letters (2×13) in the basic Latin alphabet, ROT13 is its own inverse; that is, to undo ROT13, the same algorithm is applied, so the same action can be used for encoding and decoding. The algorithm provides virtually no cryptographic security, and is often cited as a canonical example of weak encryption.[1]
-
-###### Source: [Wikipedia](https://en.wikipedia.org/wiki/ROT13)
-
-
-## XOR
-**XOR cipher** is a simple type of additive cipher,[1] an encryption algorithm that operates according to the principles:
-
-A {\displaystyle \oplus } \oplus  0 = A,
-A {\displaystyle \oplus } \oplus  A = 0,
-(A {\displaystyle \oplus } \oplus  B) {\displaystyle \oplus } \oplus  C = A {\displaystyle \oplus } \oplus  (B {\displaystyle \oplus } \oplus  C),
-(B {\displaystyle \oplus } \oplus  A) {\displaystyle \oplus } \oplus  A = B {\displaystyle \oplus } \oplus  0 = B,
-where {\displaystyle \oplus } \oplus  denotes the exclusive disjunction (XOR) operation. This operation is sometimes called modulus 2 addition (or subtraction, which is identical).[2] With this logic, a string of text can be encrypted by applying the bitwise XOR operator to every character using a given key. To decrypt the output, merely reapplying the XOR function with the key will remove the cipher.
-
-###### Source: [Wikipedia](https://en.wikipedia.org/wiki/XOR_cipher)
-
-
-[bubble-toptal]: https://www.toptal.com/developers/sorting-algorithms/bubble-sort
-[bubble-wiki]: https://en.wikipedia.org/wiki/Bubble_sort
-[bubble-image]: https://upload.wikimedia.org/wikipedia/commons/thumb/8/83/Bubblesort-edited-color.svg/220px-Bubblesort-edited-color.svg.png "Bubble Sort"
-
-[bucket-wiki]: https://en.wikipedia.org/wiki/Bucket_sort
-[bucket-image-1]: https://upload.wikimedia.org/wikipedia/commons/thumb/6/61/Bucket_sort_1.svg/311px-Bucket_sort_1.svg.png "Bucket Sort"
-[bucket-image-2]: https://upload.wikimedia.org/wikipedia/commons/thumb/e/e3/Bucket_sort_2.svg/311px-Bucket_sort_2.svg.png "Bucket Sort"
-
-[cocktail-shaker-wiki]: https://en.wikipedia.org/wiki/Cocktail_shaker_sort
-[cocktail-shaker-image]: https://upload.wikimedia.org/wikipedia/commons/e/ef/Sorting_shaker_sort_anim.gif "Cocktail Shaker Sort"
-
-[insertion-toptal]: https://www.toptal.com/developers/sorting-algorithms/insertion-sort
-[insertion-wiki]: https://en.wikipedia.org/wiki/Insertion_sort
-[insertion-image]: https://upload.wikimedia.org/wikipedia/commons/7/7e/Insertionsort-edited.png "Insertion Sort"
-
-[quick-toptal]: https://www.toptal.com/developers/sorting-algorithms/quick-sort
-[quick-wiki]: https://en.wikipedia.org/wiki/Quicksort
-[quick-image]: https://upload.wikimedia.org/wikipedia/commons/6/6a/Sorting_quicksort_anim.gif "Quick Sort"
-
-[heapsort-image]: https://upload.wikimedia.org/wikipedia/commons/4/4d/Heapsort-example.gif "Heap Sort"
-[heap-wiki]: https://en.wikipedia.org/wiki/Heapsort
-
-[radix-wiki]: https://en.wikipedia.org/wiki/Radix_sort
-
-[merge-toptal]: https://www.toptal.com/developers/sorting-algorithms/merge-sort
-[merge-wiki]: https://en.wikipedia.org/wiki/Merge_sort
-[merge-image]: https://upload.wikimedia.org/wikipedia/commons/c/cc/Merge-sort-example-300px.gif "Merge Sort"
-
-[selection-toptal]: https://www.toptal.com/developers/sorting-algorithms/selection-sort
-[selection-wiki]: https://en.wikipedia.org/wiki/Selection_sort
-[selection-image]: https://upload.wikimedia.org/wikipedia/commons/thumb/b/b0/Selection_sort_animation.gif/250px-Selection_sort_animation.gif "Selection Sort Sort"
-
-[shell-toptal]: https://www.toptal.com/developers/sorting-algorithms/shell-sort
-[shell-wiki]: https://en.wikipedia.org/wiki/Shellsort
-[shell-image]: https://upload.wikimedia.org/wikipedia/commons/d/d8/Sorting_shellsort_anim.gif "Shell Sort"
-
-[topological-wiki]: https://en.wikipedia.org/wiki/Topological_sorting
-
-[linear-wiki]: https://en.wikipedia.org/wiki/Linear_search
-[linear-image]: http://www.tutorialspoint.com/data_structures_algorithms/images/linear_search.gif "Linear Search"
-
-[binary-wiki]: https://en.wikipedia.org/wiki/Binary_search_algorithm
-[binary-image]: https://upload.wikimedia.org/wikipedia/commons/f/f7/Binary_search_into_array.png "Binary Search"
-
-
-[interpolation-wiki]: https://en.wikipedia.org/wiki/Interpolation_search
-
-[jump-wiki]: https://en.wikipedia.org/wiki/Jump_search
-
-[quick-wiki]: https://en.wikipedia.org/wiki/Quickselect
-
-[tabu-wiki]: https://en.wikipedia.org/wiki/Tabu_search
-
-[ROT13-image]: https://upload.wikimedia.org/wikipedia/commons/3/33/ROT13_table_with_example.svg "ROT13"
-
-[JumpSearch-image]: https://i1.wp.com/theoryofprogramming.com/wp-content/uploads/2016/11/jump-search-1.jpg "Jump Search"
-
-[QuickSelect-image]: https://upload.wikimedia.org/wikipedia/commons/0/04/Selecting_quickselect_frames.gif "Quick Select"
+https://gitter.im/TheAlgorithms

From 3033c1e06ec477dd62a84470926492e28fadecf5 Mon Sep 17 00:00:00 2001
From: Ayman Mohamed Ali <ayman_pharma@hotmail.com>
Date: Sun, 26 May 2019 15:46:45 +0300
Subject: [PATCH 027/348] Implement check_bipartite_graph using DFS. (#836)


From 71be23999c44c5c41d48ee2b64bc155ec2c4da18 Mon Sep 17 00:00:00 2001
From: Anup Kumar Panwar <1anuppanwar@gmail.com>
Date: Sun, 26 May 2019 21:56:10 +0530
Subject: [PATCH 028/348] refactor

---
 License                                                        | 2 +-
 README.md                                                      | 3 ++-
 data_structures/binary tree/{AVLtree.py => AVL_tree.py}        | 0
 data_structures/queue/{deqeue.py => double_ended_queue.py}     | 0
 .../{FractionalKnapsack.py => Fractional_Knapsack.py}          | 0
 dynamic_programming/{fastfibonacci.py => fast_fibonacci.py}    | 0
 ...d) Graph.py => Directed_and_Undirected_(Weighted)_Graph.py} | 0
 .../Eulerian_path_and_circuit_for_undirected_graph.py          | 0
 graphs/{bfs-shortestpath.py => bfs_shortest_path.py}           | 0
 .../edmonds_karp_multiple_source_and_sink.py                   | 0
 Graphs/pagerank.py => graphs/page_rank.py                      | 0
 maths/{BinaryExponentiation.py => Binary_Exponentiation.py}    | 0
 maths/{FindMax.py => Find_Max.py}                              | 0
 maths/{FindMin.py => Find_Min.py}                              | 0
 maths/{PrimeCheck.py => Prime_Check.py}                        | 0
 maths/{absMax.py => abs_Max.py}                                | 0
 maths/{absMin.py => abs_Min.py}                                | 0
 other/{findingPrimes.py => finding_Primes.py}                  | 0
 sorts/{BitonicSort.py => Bitonic_Sort.py}                      | 0
 sorts/{external-sort.py => external_sort.py}                   | 0
 strings/{naiveStringSearch.py => naive_String_Search.py}       | 0
 21 files changed, 3 insertions(+), 2 deletions(-)
 rename data_structures/binary tree/{AVLtree.py => AVL_tree.py} (100%)
 rename data_structures/queue/{deqeue.py => double_ended_queue.py} (100%)
 rename dynamic_programming/{FractionalKnapsack.py => Fractional_Knapsack.py} (100%)
 rename dynamic_programming/{fastfibonacci.py => fast_fibonacci.py} (100%)
 rename graphs/{Directed and Undirected (Weighted) Graph.py => Directed_and_Undirected_(Weighted)_Graph.py} (100%)
 rename Graphs/Eulerian path and circuit for undirected graph.py => graphs/Eulerian_path_and_circuit_for_undirected_graph.py (100%)
 rename graphs/{bfs-shortestpath.py => bfs_shortest_path.py} (100%)
 rename Graphs/edmonds_karp_Multiple_SourceAndSink.py => graphs/edmonds_karp_multiple_source_and_sink.py (100%)
 rename Graphs/pagerank.py => graphs/page_rank.py (100%)
 rename maths/{BinaryExponentiation.py => Binary_Exponentiation.py} (100%)
 rename maths/{FindMax.py => Find_Max.py} (100%)
 rename maths/{FindMin.py => Find_Min.py} (100%)
 rename maths/{PrimeCheck.py => Prime_Check.py} (100%)
 rename maths/{absMax.py => abs_Max.py} (100%)
 rename maths/{absMin.py => abs_Min.py} (100%)
 rename other/{findingPrimes.py => finding_Primes.py} (100%)
 rename sorts/{BitonicSort.py => Bitonic_Sort.py} (100%)
 rename sorts/{external-sort.py => external_sort.py} (100%)
 rename strings/{naiveStringSearch.py => naive_String_Search.py} (100%)

diff --git a/License b/License
index c84ae570c084..a20869d96300 100644
--- a/License
+++ b/License
@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2016 The Algorithms
+Copyright (c) 2019 The Algorithms
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/README.md b/README.md
index 8172df62309f..f8faf38736b6 100644
--- a/README.md
+++ b/README.md
@@ -1,5 +1,6 @@
 # The Algorithms - Python <!-- [![Build Status](https://travis-ci.org/TheAlgorithms/Python.svg)](https://travis-ci.org/TheAlgorithms/Python) -->
-[![Donate](https://img.shields.io/badge/Donate-PayPal-green.svg)](https://www.paypal.me/TheAlgorithms/100)
+[![Donate](https://img.shields.io/badge/Donate-PayPal-green.svg)](https://www.paypal.me/TheAlgorithms/100) &nbsp; 
+[![Gitter chat](https://badges.gitter.im/gitterHQ/gitter.png)](https://gitter.im/TheAlgorithms)
 
 
 ### All algorithms implemented in Python (for education)
diff --git a/data_structures/binary tree/AVLtree.py b/data_structures/binary tree/AVL_tree.py
similarity index 100%
rename from data_structures/binary tree/AVLtree.py
rename to data_structures/binary tree/AVL_tree.py
diff --git a/data_structures/queue/deqeue.py b/data_structures/queue/double_ended_queue.py
similarity index 100%
rename from data_structures/queue/deqeue.py
rename to data_structures/queue/double_ended_queue.py
diff --git a/dynamic_programming/FractionalKnapsack.py b/dynamic_programming/Fractional_Knapsack.py
similarity index 100%
rename from dynamic_programming/FractionalKnapsack.py
rename to dynamic_programming/Fractional_Knapsack.py
diff --git a/dynamic_programming/fastfibonacci.py b/dynamic_programming/fast_fibonacci.py
similarity index 100%
rename from dynamic_programming/fastfibonacci.py
rename to dynamic_programming/fast_fibonacci.py
diff --git a/graphs/Directed and Undirected (Weighted) Graph.py b/graphs/Directed_and_Undirected_(Weighted)_Graph.py
similarity index 100%
rename from graphs/Directed and Undirected (Weighted) Graph.py
rename to graphs/Directed_and_Undirected_(Weighted)_Graph.py
diff --git a/Graphs/Eulerian path and circuit for undirected graph.py b/graphs/Eulerian_path_and_circuit_for_undirected_graph.py
similarity index 100%
rename from Graphs/Eulerian path and circuit for undirected graph.py
rename to graphs/Eulerian_path_and_circuit_for_undirected_graph.py
diff --git a/graphs/bfs-shortestpath.py b/graphs/bfs_shortest_path.py
similarity index 100%
rename from graphs/bfs-shortestpath.py
rename to graphs/bfs_shortest_path.py
diff --git a/Graphs/edmonds_karp_Multiple_SourceAndSink.py b/graphs/edmonds_karp_multiple_source_and_sink.py
similarity index 100%
rename from Graphs/edmonds_karp_Multiple_SourceAndSink.py
rename to graphs/edmonds_karp_multiple_source_and_sink.py
diff --git a/Graphs/pagerank.py b/graphs/page_rank.py
similarity index 100%
rename from Graphs/pagerank.py
rename to graphs/page_rank.py
diff --git a/maths/BinaryExponentiation.py b/maths/Binary_Exponentiation.py
similarity index 100%
rename from maths/BinaryExponentiation.py
rename to maths/Binary_Exponentiation.py
diff --git a/maths/FindMax.py b/maths/Find_Max.py
similarity index 100%
rename from maths/FindMax.py
rename to maths/Find_Max.py
diff --git a/maths/FindMin.py b/maths/Find_Min.py
similarity index 100%
rename from maths/FindMin.py
rename to maths/Find_Min.py
diff --git a/maths/PrimeCheck.py b/maths/Prime_Check.py
similarity index 100%
rename from maths/PrimeCheck.py
rename to maths/Prime_Check.py
diff --git a/maths/absMax.py b/maths/abs_Max.py
similarity index 100%
rename from maths/absMax.py
rename to maths/abs_Max.py
diff --git a/maths/absMin.py b/maths/abs_Min.py
similarity index 100%
rename from maths/absMin.py
rename to maths/abs_Min.py
diff --git a/other/findingPrimes.py b/other/finding_Primes.py
similarity index 100%
rename from other/findingPrimes.py
rename to other/finding_Primes.py
diff --git a/sorts/BitonicSort.py b/sorts/Bitonic_Sort.py
similarity index 100%
rename from sorts/BitonicSort.py
rename to sorts/Bitonic_Sort.py
diff --git a/sorts/external-sort.py b/sorts/external_sort.py
similarity index 100%
rename from sorts/external-sort.py
rename to sorts/external_sort.py
diff --git a/strings/naiveStringSearch.py b/strings/naive_String_Search.py
similarity index 100%
rename from strings/naiveStringSearch.py
rename to strings/naive_String_Search.py

From 974088d872df4cc697c5c816fa961fc75ace857b Mon Sep 17 00:00:00 2001
From: CHIANGTUNGHUA <bule8938@gmail.com>
Date: Mon, 27 May 2019 00:33:53 +0800
Subject: [PATCH 029/348] Update .gitignore (#841)

---
 .gitignore | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/.gitignore b/.gitignore
index 5f9132236c26..0c3f33058614 100644
--- a/.gitignore
+++ b/.gitignore
@@ -89,4 +89,5 @@ ENV/
 # Rope project settings
 .ropeproject
 .idea
-.DS_Store
\ No newline at end of file
+.DS_Store
+.try
\ No newline at end of file

From 7f4f565e6291e876f45bb100843fdd021177fbb0 Mon Sep 17 00:00:00 2001
From: Ambuj81 <dataaccess81@gmail.com>
Date: Sun, 26 May 2019 22:07:40 +0530
Subject: [PATCH 030/348] subset_generation (#326)

* subset_generation

generate all possible subset of size n of a given array of size r

* Rename subset_generation to subset_generation.py

* Update subset_generation.py

I made all changes I could  . What I mean is I removed all the empty space .......
There some comment extra if you feel removing those comments please do so yourself pls provide spacing as it should be

* Create morse_Code_implementation.py

* Any more changes pls let me know
---
 ciphers/morse_Code_implementation.py     | 82 ++++++++++++++++++++++++
 dynamic_programming/subset_generation.py | 39 +++++++++++
 2 files changed, 121 insertions(+)
 create mode 100644 ciphers/morse_Code_implementation.py
 create mode 100644 dynamic_programming/subset_generation.py

diff --git a/ciphers/morse_Code_implementation.py b/ciphers/morse_Code_implementation.py
new file mode 100644
index 000000000000..7b2d0a94b24b
--- /dev/null
+++ b/ciphers/morse_Code_implementation.py
@@ -0,0 +1,82 @@
+# Python program to implement Morse Code Translator
+
+
+# Dictionary representing the morse code chart
+MORSE_CODE_DICT = { 'A':'.-', 'B':'-...',
+                    'C':'-.-.', 'D':'-..', 'E':'.',
+                    'F':'..-.', 'G':'--.', 'H':'....',
+                    'I':'..', 'J':'.---', 'K':'-.-',
+                    'L':'.-..', 'M':'--', 'N':'-.',
+                    'O':'---', 'P':'.--.', 'Q':'--.-',
+                    'R':'.-.', 'S':'...', 'T':'-',
+                    'U':'..-', 'V':'...-', 'W':'.--',
+                    'X':'-..-', 'Y':'-.--', 'Z':'--..',
+                    '1':'.----', '2':'..---', '3':'...--',
+                    '4':'....-', '5':'.....', '6':'-....',
+                    '7':'--...', '8':'---..', '9':'----.',
+                    '0':'-----', ', ':'--..--', '.':'.-.-.-',
+                    '?':'..--..', '/':'-..-.', '-':'-....-',
+                    '(':'-.--.', ')':'-.--.-'}
+
+
+def encrypt(message):
+    cipher = ''
+    for letter in message:
+        if letter != ' ':
+
+
+            cipher += MORSE_CODE_DICT[letter] + ' '
+        else:
+
+            cipher += ' '
+
+    return cipher
+
+
+def decrypt(message):
+
+    message += ' '
+
+    decipher = ''
+    citext = ''
+    for letter in message:
+
+        if (letter != ' '):
+
+
+            i = 0
+
+
+            citext += letter
+
+        else:
+
+            i += 1
+
+
+            if i == 2 :
+
+
+                decipher += ' '
+            else:
+
+
+                decipher += list(MORSE_CODE_DICT.keys())[list(MORSE_CODE_DICT
+                .values()).index(citext)]
+                citext = ''
+
+    return decipher
+
+
+def main():
+    message = "Morse code here"
+    result = encrypt(message.upper())
+    print (result)
+
+    message = result
+    result = decrypt(message)
+    print (result)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/dynamic_programming/subset_generation.py b/dynamic_programming/subset_generation.py
new file mode 100644
index 000000000000..4b7a2bf87fd5
--- /dev/null
+++ b/dynamic_programming/subset_generation.py
@@ -0,0 +1,39 @@
+# python program to print all subset combination of n element in given set of r element .
+#arr[]  ---> Input Array
+#data[] ---> Temporary array to store current combination
+# start & end ---> Staring and Ending indexes in arr[]
+# index  ---> Current index in data[]
+#r ---> Size of a combination to be printed 
+def combinationUtil(arr,n,r,index,data,i):
+#Current combination is ready to be printed,
+# print it
+ if(index == r):
+  for j in range(r):
+   print(data[j],end =" ")
+  print(" ")
+  return
+#  When no more elements are there to put in data[]
+ if(i >= n):
+  return
+#current is included, put next at next
+# location 
+ data[index] = arr[i]
+ combinationUtil(arr,n,r,index+1,data,i+1)
+ # current is excluded, replace it with
+ # next (Note that i+1 is passed, but
+ # index is not changed)
+ combinationUtil(arr,n,r,index,data,i+1)
+ # The main function that prints all combinations
+ #of size r in arr[] of size n. This function 
+ #mainly uses combinationUtil()
+def printcombination(arr,n,r):
+# A temporary array to store all combination
+# one by one
+ data = [0]*r
+#Print all combination using temprary
+#array 'data[]'
+ combinationUtil(arr,n,r,0,data,0)
+# Driver function to check for above function
+arr = [10,20,30,40,50]
+printcombination(arr,len(arr),3)
+#This code is contributed by Ambuj sahu

From 5be32f4022135a10585cf094b6fb8118dd87a2f6 Mon Sep 17 00:00:00 2001
From: Shubhayu Das <43082352+sateslayer@users.noreply.github.com>
Date: Sun, 26 May 2019 22:10:04 +0530
Subject: [PATCH 031/348] Add files via upload (#396)

---
 ciphers/Atbash.py | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 ciphers/Atbash.py

diff --git a/ciphers/Atbash.py b/ciphers/Atbash.py
new file mode 100644
index 000000000000..67bd69425fdd
--- /dev/null
+++ b/ciphers/Atbash.py
@@ -0,0 +1,14 @@
+def Atbash():
+    inp=raw_input("Enter the sentence to be encrypted  ")
+    output=""
+    for i in inp:
+        extract=ord(i)
+        if extract>=65 and extract<=90:
+            output+=(unichr(155-extract))
+        elif extract>=97 and extract<=122:
+            output+=(unichr(219-extract))
+        else:
+            output+=i
+    print output
+
+Atbash()   ;
\ No newline at end of file

From 89f15bef0a32e8e2c1c26f773daebfbe4dd3564f Mon Sep 17 00:00:00 2001
From: Bruno Santos <7022432+dunderbruno@users.noreply.github.com>
Date: Sun, 26 May 2019 13:41:46 -0300
Subject: [PATCH 032/348] Create prim.py (#397)

---
 Graphs/prim.py | 82 ++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 82 insertions(+)
 create mode 100644 Graphs/prim.py

diff --git a/Graphs/prim.py b/Graphs/prim.py
new file mode 100644
index 000000000000..c9f91d4b0700
--- /dev/null
+++ b/Graphs/prim.py
@@ -0,0 +1,82 @@
+"""
+Prim's Algorithm.
+
+Determines the minimum spanning tree(MST) of a graph using the Prim's Algorithm
+
+Create a list to store x the vertices.
+G = [vertex(n) for n in range(x)]
+
+For each vertex in G, add the neighbors:
+G[x].addNeighbor(G[y])
+G[y].addNeighbor(G[x])
+
+For each vertex in G, add the edges:
+G[x].addEdge(G[y], w)
+G[y].addEdge(G[x], w)
+
+To solve run:
+MST = prim(G, G[0])
+"""
+
+import math
+
+
+class vertex():
+    """Class Vertex."""
+
+    def __init__(self, id):
+        """
+        Arguments:
+            id - input an id to identify the vertex
+
+        Attributes:
+            neighbors - a list of the vertices it is linked to
+            edges     - a dict to store the edges's weight
+        """
+        self.id = str(id)
+        self.key = None
+        self.pi = None
+        self.neighbors = []
+        self.edges = {}  # [vertex:distance]
+
+    def __lt__(self, other):
+        """Comparison rule to < operator."""
+        return (self.key < other.key)
+
+    def __repr__(self):
+        """Return the vertex id."""
+        return self.id
+
+    def addNeighbor(self, vertex):
+        """Add a pointer to a vertex at neighbor's list."""
+        self.neighbors.append(vertex)
+
+    def addEdge(self, vertex, weight):
+        """Destination vertex and weight."""
+        self.edges[vertex.id] = weight
+
+
+def prim(graph, root):
+    """
+    Prim's Algorithm.
+
+    Return a list with the edges of a Minimum Spanning Tree
+
+    prim(graph, graph[0])
+    """
+    A = []
+    for u in graph:
+        u.key = math.inf
+        u.pi = None
+    root.key = 0
+    Q = graph[:]
+    while Q:
+        u = min(Q)
+        Q.remove(u)
+        for v in u.neighbors:
+            if (v in Q) and (u.edges[v.id] < v.key):
+                v.pi = u
+                v.key = u.edges[v.id]
+    for i in range(1, len(graph)):
+        A.append([graph[i].id, graph[i].pi.id])
+    return(A)

From 559951c181d880140a7a11d57b6c54d50018d8aa Mon Sep 17 00:00:00 2001
From: victoni <32034171+victoni@users.noreply.github.com>
Date: Sun, 26 May 2019 18:42:55 +0200
Subject: [PATCH 033/348] Lucas series added (#399)

---
 Maths/lucasSeries.py | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 Maths/lucasSeries.py

diff --git a/Maths/lucasSeries.py b/Maths/lucasSeries.py
new file mode 100644
index 000000000000..91ea1ba72a56
--- /dev/null
+++ b/Maths/lucasSeries.py
@@ -0,0 +1,13 @@
+# Lucas Sequence Using Recursion
+
+def recur_luc(n):
+  if n == 1:
+    return n
+  if n == 0:
+    return 2
+  return (recur_luc(n-1) + recur_luc(n-2))
+    
+limit = int(input("How many terms to include in Lucas series:"))
+print("Lucas series:")
+for i in range(limit):
+  print(recur_luc(i))

From cb4be75941af8058c2efa132151cd64bf73f3101 Mon Sep 17 00:00:00 2001
From: Anup Kumar Panwar <1anuppanwar@gmail.com>
Date: Sun, 26 May 2019 22:21:22 +0530
Subject: [PATCH 034/348] Rename nqueens.py to n_queens.py

---
 other/{nqueens.py => n_queens.py} | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
 rename other/{nqueens.py => n_queens.py} (98%)

diff --git a/other/nqueens.py b/other/n_queens.py
similarity index 98%
rename from other/nqueens.py
rename to other/n_queens.py
index 1b1c75878ae6..0e80a0cff5e9 100644
--- a/other/nqueens.py
+++ b/other/n_queens.py
@@ -74,4 +74,4 @@ def print_board(board):
 	
 	board = nqueens(default_width)
 	print(board)
-	print_board(board)
\ No newline at end of file
+	print_board(board)

From f56dd7f8e3a35354f8bee34a43175139908cbe4b Mon Sep 17 00:00:00 2001
From: Anup Kumar Panwar <1anuppanwar@gmail.com>
Date: Sun, 26 May 2019 22:59:07 +0530
Subject: [PATCH 035/348] Update Atbash.py

---
 ciphers/Atbash.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/ciphers/Atbash.py b/ciphers/Atbash.py
index 67bd69425fdd..4920e3049756 100644
--- a/ciphers/Atbash.py
+++ b/ciphers/Atbash.py
@@ -9,6 +9,6 @@ def Atbash():
             output+=(unichr(219-extract))
         else:
             output+=i
-    print output
+    print (output)
 
-Atbash()   ;
\ No newline at end of file
+Atbash()   ;

From dd62f1b8023817ae5637812b3fa9acd815e4ef38 Mon Sep 17 00:00:00 2001
From: alpylmz <41516584+alpylmz@users.noreply.github.com>
Date: Sun, 26 May 2019 21:04:49 +0300
Subject: [PATCH 036/348] Create sol5.py (#425)

added a solve for the problem
---
 Project Euler/Problem 01/sol5.py | 8 ++++++++
 1 file changed, 8 insertions(+)
 create mode 100644 Project Euler/Problem 01/sol5.py

diff --git a/Project Euler/Problem 01/sol5.py b/Project Euler/Problem 01/sol5.py
new file mode 100644
index 000000000000..2cb67d2524e2
--- /dev/null
+++ b/Project Euler/Problem 01/sol5.py	
@@ -0,0 +1,8 @@
+a=3
+result=0
+while a=<1000:
+  if(a%3==0 and a%5==0):
+    result+=a
+  elif(a%15==0):
+    result-=a
+print(result)

From fc95e7a91a4407ea5a293dbe80dc7a76d4af0976 Mon Sep 17 00:00:00 2001
From: Erfan Alimohammadi <erfan.aa@gmail.com>
Date: Tue, 28 May 2019 17:21:48 +0430
Subject: [PATCH 037/348] Fermat's little theorem (#847)

* Fix typo

* Add fermat's little theorem

* Update fermat_little_theorem.py

* Fix comments

* Add Wikipedia reference
---
 maths/fermat_little_theorem.py | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 maths/fermat_little_theorem.py

diff --git a/maths/fermat_little_theorem.py b/maths/fermat_little_theorem.py
new file mode 100644
index 000000000000..93af98684894
--- /dev/null
+++ b/maths/fermat_little_theorem.py
@@ -0,0 +1,30 @@
+# Python program to show the usage of Fermat's little theorem in a division
+# According to Fermat's little theorem, (a / b) mod p always equals a * (b ^ (p - 2)) mod p
+# Here we assume that p is a prime number, b divides a, and p doesn't divide b
+# Wikipedia reference: https://en.wikipedia.org/wiki/Fermat%27s_little_theorem
+
+
+def binary_exponentiation(a, n, mod):
+    
+    if (n == 0):
+        return 1
+    
+    elif (n % 2 == 1):
+        return (binary_exponentiation(a, n - 1, mod) * a) % mod
+    
+    else:
+        b = binary_exponentiation(a, n / 2, mod)
+        return (b * b) % mod
+
+
+# a prime number
+p = 701
+
+a = 1000000000
+b = 10
+
+# using binary exponentiation function, O(log(p)):
+print((a / b) % p == (a * binary_exponentiation(b, p - 2, p)) % p)
+
+# using Python operators:
+print((a / b) % p == (a * b ** (p - 2)) % p)

From 9037abae110408e8c7cf45f613d84059be07993c Mon Sep 17 00:00:00 2001
From: cedricfarinazzo <cedric.farinazzo@gmail.com>
Date: Thu, 30 May 2019 02:47:00 +0200
Subject: [PATCH 038/348] Fix spelling in
 neural_network/convolution_neural_network.py (#849)

* Fix spelling in neural_network/convolution_neural_network.py

* fix import

Signed-off-by: cedric.farinazzo <cedric.farinazzo@epita.fr>
---
 neural_network/convolution_neural_network.py | 67 ++++++++++----------
 1 file changed, 33 insertions(+), 34 deletions(-)

diff --git a/neural_network/convolution_neural_network.py b/neural_network/convolution_neural_network.py
index 0dca2bc485d1..0e72f0c0dca2 100644
--- a/neural_network/convolution_neural_network.py
+++ b/neural_network/convolution_neural_network.py
@@ -14,15 +14,16 @@
     Github: 245885195@qq.com
     Date: 2017.9.20
     - - - - - -- - - - - - - - - - - - - - - - - - - - - - -
-          '''
+'''
 from __future__ import print_function
 
+import pickle
 import numpy as np
 import matplotlib.pyplot as plt
 
 class CNN():
 
-    def __init__(self,conv1_get,size_p1,bp_num1,bp_num2,bp_num3,rate_w=0.2,rate_t=0.2):
+    def __init__(self, conv1_get, size_p1, bp_num1, bp_num2, bp_num3, rate_w=0.2, rate_t=0.2):
         '''
         :param conv1_get: [a,c,d]，size, number, step of convolution kernel
         :param size_p1: pooling size
@@ -48,32 +49,30 @@ def __init__(self,conv1_get,size_p1,bp_num1,bp_num2,bp_num3,rate_w=0.2,rate_t=0.
         self.thre_bp3 = -2*np.random.rand(self.num_bp3)+1
 
 
-    def save_model(self,save_path):
+    def save_model(self, save_path):
         #save model dict with pickle
-        import pickle
         model_dic = {'num_bp1':self.num_bp1,
-                    'num_bp2':self.num_bp2,
-                    'num_bp3':self.num_bp3,
-                    'conv1':self.conv1,
-                    'step_conv1':self.step_conv1,
-                    'size_pooling1':self.size_pooling1,
-                    'rate_weight':self.rate_weight,
-                    'rate_thre':self.rate_thre,
-                    'w_conv1':self.w_conv1,
-                    'wkj':self.wkj,
-                    'vji':self.vji,
-                    'thre_conv1':self.thre_conv1,
-                    'thre_bp2':self.thre_bp2,
-                     'thre_bp3':self.thre_bp3}
+                'num_bp2':self.num_bp2,
+                'num_bp3':self.num_bp3,
+                'conv1':self.conv1,
+                'step_conv1':self.step_conv1,
+                'size_pooling1':self.size_pooling1,
+                'rate_weight':self.rate_weight,
+                'rate_thre':self.rate_thre,
+                'w_conv1':self.w_conv1,
+                'wkj':self.wkj,
+                'vji':self.vji,
+                'thre_conv1':self.thre_conv1,
+                'thre_bp2':self.thre_bp2,
+                'thre_bp3':self.thre_bp3}
         with open(save_path, 'wb') as f:
             pickle.dump(model_dic, f)
 
         print('Model saved： %s'% save_path)
 
     @classmethod
-    def ReadModel(cls,model_path):
+    def ReadModel(cls, model_path):
         #read saved model
-        import pickle
         with open(model_path, 'rb') as f:
             model_dic = pickle.load(f)
 
@@ -97,13 +96,13 @@ def ReadModel(cls,model_path):
         return conv_ins
 
 
-    def sig(self,x):
+    def sig(self, x):
         return 1 / (1 + np.exp(-1*x))
 
-    def do_round(self,x):
+    def do_round(self, x):
         return round(x, 3)
 
-    def convolute(self,data,convs,w_convs,thre_convs,conv_step):
+    def convolute(self, data, convs, w_convs, thre_convs, conv_step):
         #convolution process
         size_conv = convs[0]
         num_conv =convs[1]
@@ -132,7 +131,7 @@ def convolute(self,data,convs,w_convs,thre_convs,conv_step):
         focus_list = np.asarray(focus1_list)
         return focus_list,data_featuremap
 
-    def pooling(self,featuremaps,size_pooling,type='average_pool'):
+    def pooling(self, featuremaps, size_pooling, type='average_pool'):
         #pooling process
         size_map = len(featuremaps[0])
         size_pooled = int(size_map/size_pooling)
@@ -153,7 +152,7 @@ def pooling(self,featuremaps,size_pooling,type='average_pool'):
             featuremap_pooled.append(map_pooled)
         return featuremap_pooled
 
-    def _expand(self,datas):
+    def _expand(self, datas):
         #expanding three dimension data to one dimension list
         data_expanded = []
         for i in range(len(datas)):
@@ -164,14 +163,14 @@ def _expand(self,datas):
         data_expanded = np.asarray(data_expanded)
         return data_expanded
 
-    def _expand_mat(self,data_mat):
+    def _expand_mat(self, data_mat):
         #expanding matrix to one dimension list
         data_mat = np.asarray(data_mat)
         shapes = np.shape(data_mat)
         data_expanded = data_mat.reshape(1,shapes[0]*shapes[1])
         return data_expanded
 
-    def _calculate_gradient_from_pool(self,out_map,pd_pool,num_map,size_map,size_pooling):
+    def _calculate_gradient_from_pool(self, out_map, pd_pool,num_map, size_map, size_pooling):
         '''
         calcluate the gradient from the data slice of pool layer
         pd_pool: list of matrix
@@ -190,7 +189,7 @@ def _calculate_gradient_from_pool(self,out_map,pd_pool,num_map,size_map,size_poo
             pd_all.append(pd_conv2)
         return pd_all
 
-    def trian(self,patterns,datas_train, datas_teach, n_repeat, error_accuracy,draw_e = bool):
+    def train(self, patterns, datas_train, datas_teach, n_repeat, error_accuracy, draw_e = bool):
         #model traning
         print('----------------------Start Training-------------------------')
         print((' - - Shape: Train_Data  ',np.shape(datas_train)))
@@ -206,7 +205,7 @@ def trian(self,patterns,datas_train, datas_teach, n_repeat, error_accuracy,draw_
                 data_train = np.asmatrix(datas_train[p])
                 data_teach = np.asarray(datas_teach[p])
                 data_focus1,data_conved1 = self.convolute(data_train,self.conv1,self.w_conv1,
-                                           self.thre_conv1,conv_step=self.step_conv1)
+                        self.thre_conv1,conv_step=self.step_conv1)
                 data_pooled1 = self.pooling(data_conved1,self.size_pooling1)
                 shape_featuremap1 = np.shape(data_conved1)
                 '''
@@ -231,7 +230,7 @@ def trian(self,patterns,datas_train, datas_teach, n_repeat, error_accuracy,draw_
                 pd_conv1_pooled = pd_i_all / (self.size_pooling1*self.size_pooling1)
                 pd_conv1_pooled = pd_conv1_pooled.T.getA().tolist()
                 pd_conv1_all = self._calculate_gradient_from_pool(data_conved1,pd_conv1_pooled,shape_featuremap1[0],
-                                                    shape_featuremap1[1],self.size_pooling1)
+                        shape_featuremap1[1],self.size_pooling1)
                 #weight and threshold learning process---------
                 #convolution layer
                 for k_conv in range(self.conv1[1]):
@@ -268,7 +267,7 @@ def draw_error():
             draw_error()
         return mse
 
-    def predict(self,datas_test):
+    def predict(self, datas_test):
         #model predict
         produce_out = []
         print('-------------------Start Testing-------------------------')
@@ -276,7 +275,7 @@ def predict(self,datas_test):
         for p in range(len(datas_test)):
             data_test = np.asmatrix(datas_test[p])
             data_focus1, data_conved1 = self.convolute(data_test, self.conv1, self.w_conv1,
-                                                     self.thre_conv1, conv_step=self.step_conv1)
+                    self.thre_conv1, conv_step=self.step_conv1)
             data_pooled1 = self.pooling(data_conved1, self.size_pooling1)
             data_bp_input = self._expand(data_pooled1)
 
@@ -289,11 +288,11 @@ def predict(self,datas_test):
         res = [list(map(self.do_round,each)) for each in produce_out]
         return np.asarray(res)
 
-    def convolution(self,data):
+    def convolution(self, data):
         #return the data of image after convoluting process so we can check it out
         data_test = np.asmatrix(data)
         data_focus1, data_conved1 = self.convolute(data_test, self.conv1, self.w_conv1,
-                                                     self.thre_conv1, conv_step=self.step_conv1)
+                self.thre_conv1, conv_step=self.step_conv1)
         data_pooled1 = self.pooling(data_conved1, self.size_pooling1)
 
         return data_conved1,data_pooled1
@@ -303,4 +302,4 @@ def convolution(self,data):
     pass
     '''
     I will put the example on other file
-    '''
\ No newline at end of file
+'''

From aeab9f10685c93e043ad143bd583bc11e7bd8744 Mon Sep 17 00:00:00 2001
From: Sven Efftinge <sven@efftinge.de>
Date: Fri, 31 May 2019 10:02:56 +0200
Subject: [PATCH 039/348] Added gitpod info (#848)

---
 README.md | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index f8faf38736b6..f84dcaf90cff 100644
--- a/README.md
+++ b/README.md
@@ -1,5 +1,5 @@
 # The Algorithms - Python <!-- [![Build Status](https://travis-ci.org/TheAlgorithms/Python.svg)](https://travis-ci.org/TheAlgorithms/Python) -->
-[![Donate](https://img.shields.io/badge/Donate-PayPal-green.svg)](https://www.paypal.me/TheAlgorithms/100) &nbsp; 
+[![Donate](https://img.shields.io/badge/Donate-PayPal-green.svg)](https://www.paypal.me/TheAlgorithms/100) &nbsp;
 [![Gitter chat](https://badges.gitter.im/gitterHQ/gitter.png)](https://gitter.im/TheAlgorithms)
 
 
@@ -7,6 +7,10 @@
 
 These implementations are for learning purposes. They may be efficient than the implementations in the Python standard library.
 
+Run, edit and contribute using Gitpod.io a free online dev environment.
+
+[![Open in Gitpod](https://gitpod.io/button/open-in-gitpod.svg)](https://gitpod.io/#https://github.com/TheAlgorithms/Python)
+
 ## Contribution Guidelines
 
 * File name should be in camel case.

From 4d9a1611bda8124bf4ea21699c12c81c9fcdd1b4 Mon Sep 17 00:00:00 2001
From: Dave Kerr <davekerrcode@gmail.com>
Date: Fri, 31 May 2019 04:03:55 -0400
Subject: [PATCH 040/348] implementations may be *less* efficient than python
 standard libs (#854)

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index f84dcaf90cff..e2412d9b57dd 100644
--- a/README.md
+++ b/README.md
@@ -5,7 +5,7 @@
 
 ### All algorithms implemented in Python (for education)
 
-These implementations are for learning purposes. They may be efficient than the implementations in the Python standard library.
+These implementations are for learning purposes. They may be less efficient than the implementations in the Python standard library.
 
 Run, edit and contribute using Gitpod.io a free online dev environment.
 

From f386fce820fb60abfe1b18c141dfd8ce268c5f4f Mon Sep 17 00:00:00 2001
From: luanjerry <50862638+luanjerry@users.noreply.github.com>
Date: Fri, 31 May 2019 16:05:24 +0800
Subject: [PATCH 041/348] Update queue_on_list.py (#851)

* Fixed error in queue_on_list.py
---
 data_structures/queue/queue_on_list.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/data_structures/queue/queue_on_list.py b/data_structures/queue/queue_on_list.py
index c8d0b41de5d5..2ec9bac8398a 100644
--- a/data_structures/queue/queue_on_list.py
+++ b/data_structures/queue/queue_on_list.py
@@ -24,8 +24,9 @@ def put(self, item):
     def get(self):
         self.length = self.length - 1
         dequeued = self.entries[self.front]
-        self.front-=1
-        self.entries = self.entries[self.front:]
+        #self.front-=1
+        #self.entries = self.entries[self.front:]
+        self.entries = self.entries[1:]
         return dequeued
 
     """Rotates the queue {@code rotation} times

From c2552cdfcdc787b73bd07ee2fe5145c73827e8a3 Mon Sep 17 00:00:00 2001
From: John Law <johnlaw.po@gmail.com>
Date: Sun, 2 Jun 2019 12:14:18 +0800
Subject: [PATCH 042/348] Create CONTRIBUTING.md (#864)

* Create CONTRIBUTING.md

* Create a tailor-made contribution guide

Closes #802

* Update README.md

* Rename License to LICENSE.md
---
 CONTRIBUTING.md       | 124 ++++++++++++++++++++++++++++++++++++++++++
 License => LICENSE.md |   0
 README.md             |  15 ++---
 3 files changed, 128 insertions(+), 11 deletions(-)
 create mode 100644 CONTRIBUTING.md
 rename License => LICENSE.md (100%)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
new file mode 100644
index 000000000000..9b2ac0025dca
--- /dev/null
+++ b/CONTRIBUTING.md
@@ -0,0 +1,124 @@
+# Contributing guidelines
+
+## Before contributing
+
+Welcome to [TheAlgorithms/Python](https://github.com/TheAlgorithms/Python)! Before sending your pull requests, make sure that you **read the whole guidelines**. If you have any doubt on the contributing guide, please feel free to [state it clearly in an issue](https://github.com/TheAlgorithms/Python/issues/new) or ask the community in [Gitter](https://gitter.im/TheAlgorithms).
+
+## Contributing
+
+### Contributor
+
+We are very happy that you consider implementing algorithms and data structure for others! This repository is referenced and used by learners from all over the globe. Being one of our contributors, you agree and confirm that:
+
+- your did your work - no plagiarism allowed
+  - Any plagiarized work will not be merged.
+- your work will be distributed under [MIT License](License) once your pull request is merged
+- you submitted work fulfils or mostly fulfils our styles and standards
+
+**New implementation** is welcome! For example, new solutions for a problem, different representations for a graph data structure or algorithm designs with different complexity.
+
+**Improving comments** and **writing proper tests** are also highly welcome.
+
+### Contribution
+
+We appreciate any contribution, from fixing a grammar mistake in a comment to implementing complex algorithms. Please read this section if you are contributing your work.
+
+#### Coding Style
+
+We want your work to be readable by others; therefore, we encourage you to note the following:
+
+- Please write in Python 3.x.
+
+- If you know [PEP 8](https://www.python.org/dev/peps/pep-0008/) already, you will have no problem in coding style, though we do not follow it strictly. Read the remaining section and have fun coding!
+
+- Always use 4 spaces to indent.
+
+- Original code submission requires comments to describe your work.
+
+- More on comments and docstrings:
+
+  The following are considered to be bad and may be requested to be improved:
+
+  ```python
+  x = x + 2	# increased by 2
+  ```
+
+  This is too trivial. Comments are expected to be explanatory. For comments, you can write them above, on or below a line of code, as long as you are consistent within the same piece of code.
+
+  *Sometimes, docstrings are avoided.* This will happen if you are using some editors and not careful with indentation:
+
+  ```python
+      """
+  	This function sums a and b    
+  """
+  def sum(a, b):
+      return a + b
+  ```
+
+  However, if you insist to use docstrings, we encourage you to put docstrings inside functions. Also, please pay attention to indentation to docstrings. The following is acceptable in this case:
+
+  ```python
+  def sumab(a, b):
+      """
+  	This function sums two integers a and b
+  	Return: a + b
+  	"""
+      return a + b
+  ```
+
+- `lambda`, `map`, `filter`, `reduce` and complicated list comprehension are welcome and acceptable to demonstrate the power of Python, as long as they are simple enough to read.
+
+  - This is arguable: **write comments** and assign appropriate variable names, so that the code is easy to read!
+
+- Write tests to illustrate your work.
+
+  The following "testing" approaches are not encouraged:
+
+  ```python
+  input('Enter your input:') 
+  # Or even worse...
+  input = eval(raw_input("Enter your input: "))
+  ```
+
+  Please write down your test case, like the following:
+
+  ```python
+  def sumab(a, b):
+      return a + b
+  # Write tests this way:
+  print(sumab(1,2))	# 1+2 = 3
+  print(sumab(6,4))	# 6+4 = 10
+  # Or this way:
+  print("1 + 2 = ", sumab(1,2))	# 1+2 = 3
+  print("6 + 4 = ", sumab(6,4))	# 6+4 = 10
+  ```
+
+- Avoid importing external libraries for basic algorithms. Use those libraries for complicated algorithms.
+
+#### Other Standard While Submitting Your Work
+
+- File extension for code should be `.py`.
+
+- Please file your work to let others use it in the future. Here are the examples that are acceptable:
+
+  - Camel cases
+  - `-` Hyphenated names
+  - `_` Underscore-separated names
+
+  If possible, follow the standard *within* the folder you are submitting to.
+
+- If you have modified/added code work, make sure the code compiles before submitting.
+
+- If you have modified/added documentation work, make sure your language is concise and contains no grammar mistake.
+
+- Add a corresponding explanation to [Algorithms-Explanation](https://github.com/TheAlgorithms/Algorithms-Explanation) (Optional but recommended).
+
+- Most importantly,
+
+  - **be consistent with this guidelines while submitting.**
+  - **join** [Gitter](https://gitter.im/TheAlgorithms) **now!**
+  - Happy coding!
+
+
+
+Writer [@poyea](https://github.com/poyea), Jun 2019.
diff --git a/License b/LICENSE.md
similarity index 100%
rename from License
rename to LICENSE.md
diff --git a/README.md b/README.md
index e2412d9b57dd..527b80269fdc 100644
--- a/README.md
+++ b/README.md
@@ -1,24 +1,17 @@
 # The Algorithms - Python <!-- [![Build Status](https://travis-ci.org/TheAlgorithms/Python.svg)](https://travis-ci.org/TheAlgorithms/Python) -->
 [![Donate](https://img.shields.io/badge/Donate-PayPal-green.svg)](https://www.paypal.me/TheAlgorithms/100) &nbsp;
-[![Gitter chat](https://badges.gitter.im/gitterHQ/gitter.png)](https://gitter.im/TheAlgorithms)
-
+[![Gitter chat](https://badges.gitter.im/gitterHQ/gitter.png)](https://gitter.im/TheAlgorithms) &nbsp;
+[![Open in Gitpod](https://gitpod.io/button/open-in-gitpod.svg)](https://gitpod.io/#https://github.com/TheAlgorithms/Python)
 
 ### All algorithms implemented in Python (for education)
 
 These implementations are for learning purposes. They may be less efficient than the implementations in the Python standard library.
 
-Run, edit and contribute using Gitpod.io a free online dev environment.
-
-[![Open in Gitpod](https://gitpod.io/button/open-in-gitpod.svg)](https://gitpod.io/#https://github.com/TheAlgorithms/Python)
 
 ## Contribution Guidelines
 
-* File name should be in camel case.
-* Write proper documentation of the code.
-* Avoid input methods as far as possible. Assign values to the variables statically. This will make the code easy to understand and algorithm can be traced easily.
-* Add a corresponding explaination to [Algorithms-Explanation](https://github.com/TheAlgorithms/Algorithms-Explanation) (Optional but recommended).
-* Avoid importing external libraries for basic algorithms.
+Read our [Contribution Guidelines](CONTRIBUTING.md) before you contribute.
 
 ## Community Channel
 
-https://gitter.im/TheAlgorithms
+We're on [Gitter](https://gitter.im/TheAlgorithms)! Please join us.

From f9b8dbf9db6c5b6cdd4ec9b5e35fbc1d9939a45e Mon Sep 17 00:00:00 2001
From: Guo <msn4399@163.com>
Date: Tue, 4 Jun 2019 16:34:28 +0800
Subject: [PATCH 043/348] Correct the wrong iterative DFS implementation (#867)

* Update DFS.py

* Update DFS.py
---
 graphs/DFS.py | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/graphs/DFS.py b/graphs/DFS.py
index d3c34fabb7b3..c9843ca25382 100644
--- a/graphs/DFS.py
+++ b/graphs/DFS.py
@@ -18,10 +18,15 @@ def dfs(graph, start):
     explored, stack = set(), [start]
     explored.add(start)
     while stack:
-        v = stack.pop()  # the only difference from BFS is to pop last element here instead of first one
+        v = stack.pop()  # one difference from BFS is to pop last element here instead of first one
+        
+        if v in explored:
+            continue
+
+        explored.add(v)
+
         for w in graph[v]:
             if w not in explored:
-                explored.add(w)
                 stack.append(w)
     return explored
 

From 0f229e0870050478a6b3fa1ecf60d73b694b98da Mon Sep 17 00:00:00 2001
From: cclauss <cclauss@me.com>
Date: Wed, 5 Jun 2019 03:09:04 +0200
Subject: [PATCH 044/348] Atbash.py: Both raw_input() and unichr() were removed
 in Python 3 (#855)

* Atbash.py: Both raw_input() and unichr() were removed in Python 3

@sateslayer and @AnupKumarPanwar your reviews please.

* Remove any leading / trailing whitespace from user input
---
 ciphers/Atbash.py | 25 ++++++++++++++++---------
 1 file changed, 16 insertions(+), 9 deletions(-)

diff --git a/ciphers/Atbash.py b/ciphers/Atbash.py
index 4920e3049756..162614c727ee 100644
--- a/ciphers/Atbash.py
+++ b/ciphers/Atbash.py
@@ -1,14 +1,21 @@
+try:               # Python 2
+    raw_input
+    unichr
+except NameError:  # Python 3
+    raw_input = input
+    unichr = chr
+
+
 def Atbash():
-    inp=raw_input("Enter the sentence to be encrypted  ")
     output=""
-    for i in inp:
-        extract=ord(i)
-        if extract>=65 and extract<=90:
-            output+=(unichr(155-extract))
-        elif extract>=97 and extract<=122:
-            output+=(unichr(219-extract))
+    for i in raw_input("Enter the sentence to be encrypted ").strip():
+        extract = ord(i)
+        if 65 <= extract <= 90:
+            output += unichr(155-extract)
+        elif 97 <= extract <= 122:
+            output += unichr(219-extract)
         else:
             output+=i
-    print (output)
+    print(output)
 
-Atbash()   ;
+Atbash()

From ebe227c38646fc6720124eae5aedc68b61a4b664 Mon Sep 17 00:00:00 2001
From: Daniel Xu <niellxu@yahoo.ca>
Date: Tue, 4 Jun 2019 21:37:05 -0400
Subject: [PATCH 045/348] Removed Graphs and move prim.py to graphs (#872)

* Move prim.py from Graphs to graphs

* Removed prim.py from Graphs

* Update prim.py
---
 {Graphs => graphs}/prim.py | 3 ---
 1 file changed, 3 deletions(-)
 rename {Graphs => graphs}/prim.py (99%)

diff --git a/Graphs/prim.py b/graphs/prim.py
similarity index 99%
rename from Graphs/prim.py
rename to graphs/prim.py
index c9f91d4b0700..f7e08278966d 100644
--- a/Graphs/prim.py
+++ b/graphs/prim.py
@@ -28,7 +28,6 @@ def __init__(self, id):
         """
         Arguments:
             id - input an id to identify the vertex
-
         Attributes:
             neighbors - a list of the vertices it is linked to
             edges     - a dict to store the edges's weight
@@ -59,9 +58,7 @@ def addEdge(self, vertex, weight):
 def prim(graph, root):
     """
     Prim's Algorithm.
-
     Return a list with the edges of a Minimum Spanning Tree
-
     prim(graph, graph[0])
     """
     A = []

From 6e894ba3e8bab4e9e0515b91e685904ec828cf43 Mon Sep 17 00:00:00 2001
From: CharlesRitter <crritte@g.clemson.edu>
Date: Fri, 7 Jun 2019 11:38:43 -0400
Subject: [PATCH 046/348] Odd-Even Transposition Sort (#769)

* -Added a single-threaded implementation of odd-even transposition sort.

This is a modified bubble sort meant to work with multiple processors.
Since this is running on a single thread, it has the same running time
as bubble sort.

* -Added a parallel implementation of Odd-Even Transposition sort

This implementation uses multiprocessing to perform the swaps
at each step of the algorithm simultaneously.
---
 sorts/Odd-Even_transposition_parallel.py      | 127 ++++++++++++++++++
 .../Odd-Even_transposition_single-threaded.py |  32 +++++
 2 files changed, 159 insertions(+)
 create mode 100644 sorts/Odd-Even_transposition_parallel.py
 create mode 100644 sorts/Odd-Even_transposition_single-threaded.py

diff --git a/sorts/Odd-Even_transposition_parallel.py b/sorts/Odd-Even_transposition_parallel.py
new file mode 100644
index 000000000000..d7f983fc0469
--- /dev/null
+++ b/sorts/Odd-Even_transposition_parallel.py
@@ -0,0 +1,127 @@
+"""
+This is an implementation of odd-even transposition sort.
+
+It works by performing a series of parallel swaps between odd and even pairs of
+variables in the list.
+
+This implementation represents each variable in the list with a process and
+each process communicates with its neighboring processes in the list to perform
+comparisons.
+They are synchronized with locks and message passing but other forms of
+synchronization could be used.
+"""
+from multiprocessing import Process, Pipe, Lock
+
+#lock used to ensure that two processes do not access a pipe at the same time
+processLock = Lock()
+
+"""
+The function run by the processes that sorts the list
+
+position = the position in the list the prcoess represents, used to know which
+            neighbor we pass our value to
+value = the initial value at list[position]
+LSend, RSend = the pipes we use to send to our left and right neighbors
+LRcv, RRcv = the pipes we use to receive from our left and right neighbors
+resultPipe = the pipe used to send results back to main
+"""
+def oeProcess(position, value, LSend, RSend, LRcv, RRcv, resultPipe):
+    global processLock
+
+    #we perform n swaps since after n swaps we know we are sorted
+    #we *could* stop early if we are sorted already, but it takes as long to
+    #find out we are sorted as it does to sort the list with this algorithm
+    for i in range(0, 10):
+
+        if( (i + position) % 2 == 0 and RSend != None):
+            #send your value to your right neighbor
+            processLock.acquire()
+            RSend[1].send(value)
+            processLock.release()
+
+            #receive your right neighbor's value
+            processLock.acquire()
+            temp = RRcv[0].recv()
+            processLock.release()
+
+            #take the lower value since you are on the left
+            value = min(value, temp)
+        elif( (i + position) % 2 != 0 and LSend != None):
+            #send your value to your left neighbor
+            processLock.acquire()
+            LSend[1].send(value)
+            processLock.release()
+
+            #receive your left neighbor's value
+            processLock.acquire()
+            temp = LRcv[0].recv()
+            processLock.release()
+
+            #take the higher value since you are on the right
+            value = max(value, temp)
+    #after all swaps are performed, send the values back to main
+    resultPipe[1].send(value)
+
+"""
+the function which creates the processes that perform the parallel swaps
+
+arr = the list to be sorted
+"""
+def OddEvenTransposition(arr):
+
+    processArray = []
+    tempRrcv = None
+    tempLrcv = None
+
+    resultPipe = []
+
+    #initialize the list of pipes where the values will be retrieved
+    for a in arr:
+        resultPipe.append(Pipe())
+
+    #creates the processes
+    #the first and last process only have one neighbor so they are made outside
+    #of the loop
+    tempRs = Pipe()
+    tempRr = Pipe()
+    processArray.append(Process(target = oeProcess, args = (0, arr[0], None, tempRs, None, tempRr, resultPipe[0])))
+    tempLr = tempRs
+    tempLs = tempRr
+
+    for i in range(1, len(arr) - 1):
+        tempRs = Pipe()
+        tempRr = Pipe()
+        processArray.append(Process(target = oeProcess, args = (i, arr[i], tempLs, tempRs, tempLr, tempRr, resultPipe[i])))
+        tempLr = tempRs
+        tempLs = tempRr
+
+    processArray.append(Process(target = oeProcess, args = (len(arr) - 1, arr[len(arr) - 1], tempLs, None, tempLr, None, resultPipe[len(arr) - 1])))
+
+    #start the processes
+    for p in processArray:
+        p.start()
+
+    #wait for the processes to end and write their values to the list
+    for p in range(0, len(resultPipe)):
+        arr[p] = resultPipe[p][0].recv()
+        processArray[p].join()
+
+    return(arr)
+
+
+#creates a reverse sorted list and sorts it
+def main():
+    arr = []
+
+    for i in range(10, 0, -1):
+        arr.append(i)
+    print("Initial List")
+    print(*arr)
+
+    list = OddEvenTransposition(arr)
+
+    print("Sorted List\n")
+    print(*arr)
+
+if __name__ == "__main__":
+    main()
diff --git a/sorts/Odd-Even_transposition_single-threaded.py b/sorts/Odd-Even_transposition_single-threaded.py
new file mode 100644
index 000000000000..ec5f3cf14e55
--- /dev/null
+++ b/sorts/Odd-Even_transposition_single-threaded.py
@@ -0,0 +1,32 @@
+"""
+This is a non-parallelized implementation of odd-even transpostiion sort.
+
+Normally the swaps in each set happen simultaneously, without that the algorithm
+is no better than bubble sort.
+"""
+
+def OddEvenTransposition(arr):
+    for i in range(0, len(arr)):
+        for i in range(i % 2, len(arr) - 1, 2):
+            if arr[i + 1] < arr[i]:
+                arr[i], arr[i + 1] = arr[i + 1], arr[i]
+        print(*arr)
+
+    return arr
+
+#creates a list and sorts it
+def main():
+    list = []
+
+    for i in range(10, 0, -1):
+        list.append(i)
+    print("Initial List")
+    print(*list)
+
+    list = OddEvenTransposition(list)
+
+    print("Sorted List\n")
+    print(*list)
+
+if __name__ == "__main__":
+    main()

From 9b945cb2b4ad77418e6576b7960fda8228214de9 Mon Sep 17 00:00:00 2001
From: StephenGemin <45926479+StephenGemin@users.noreply.github.com>
Date: Sat, 8 Jun 2019 08:25:34 -0400
Subject: [PATCH 047/348] Iterative fibonacci with unittests from slash (#882)

* iterative and formula fibonacci methods

Added two ways to calculate the fibonacci sequence:  (1) iterative  (2) formula.

I've also added a timer decorator so someone can see the difference in computation time between these two methods.

Added two unittests using the slash framework.

* Update test_fibonacci.py

* remove inline comments per Contributing Guidelines

* Update sol5.py

* Create placeholder.py

* Update and rename maths/test_fibonacci.py to maths/tests/test_fibonacci.py

* Delete placeholder.py

* Create __init__.py

* Update test_fibonacci.py

* Rename Maths/lucasSeries.py to maths/lucasSeries.py

* Update and rename Project Euler/Problem 01/sol5.py to project_euler/problem_01/sol6.py
---
 Project Euler/Problem 01/sol5.py |   8 ---
 maths/fibonacci.py               | 120 +++++++++++++++++++++++++++++++
 {Maths => maths}/lucasSeries.py  |   0
 maths/tests/__init__.py          |   1 +
 maths/tests/test_fibonacci.py    |  34 +++++++++
 project_euler/problem_01/sol6.py |   9 +++
 6 files changed, 164 insertions(+), 8 deletions(-)
 delete mode 100644 Project Euler/Problem 01/sol5.py
 create mode 100644 maths/fibonacci.py
 rename {Maths => maths}/lucasSeries.py (100%)
 create mode 100644 maths/tests/__init__.py
 create mode 100644 maths/tests/test_fibonacci.py
 create mode 100644 project_euler/problem_01/sol6.py

diff --git a/Project Euler/Problem 01/sol5.py b/Project Euler/Problem 01/sol5.py
deleted file mode 100644
index 2cb67d2524e2..000000000000
--- a/Project Euler/Problem 01/sol5.py	
+++ /dev/null
@@ -1,8 +0,0 @@
-a=3
-result=0
-while a=<1000:
-  if(a%3==0 and a%5==0):
-    result+=a
-  elif(a%15==0):
-    result-=a
-print(result)
diff --git a/maths/fibonacci.py b/maths/fibonacci.py
new file mode 100644
index 000000000000..0a0611f21379
--- /dev/null
+++ b/maths/fibonacci.py
@@ -0,0 +1,120 @@
+# fibonacci.py
+"""
+1. Calculates the iterative fibonacci sequence
+
+2. Calculates the fibonacci sequence with a formula
+    an = [ Phin - (phi)n ]/Sqrt[5]
+    reference-->Su, Francis E., et al. "Fibonacci Number Formula." Math Fun Facts. <http://www.math.hmc.edu/funfacts>
+"""
+import math
+import functools
+import time
+from decimal import getcontext, Decimal
+
+getcontext().prec = 100
+
+
+def timer_decorator(func):
+    @functools.wraps(func)
+    def timer_wrapper(*args, **kwargs):
+        start = time.time()
+        func(*args, **kwargs)
+        end = time.time()
+        if int(end - start) > 0:
+            print(f'Run time for {func.__name__}: {(end - start):0.2f}s')
+        else:
+            print(f'Run time for {func.__name__}: {(end - start)*1000:0.2f}ms')
+        return func(*args, **kwargs)
+    return timer_wrapper
+
+
+# define Python user-defined exceptions
+class Error(Exception):
+    """Base class for other exceptions"""
+
+
+class ValueTooLargeError(Error):
+    """Raised when the input value is too large"""
+
+
+class ValueTooSmallError(Error):
+    """Raised when the input value is not greater than one"""
+
+
+class ValueLessThanZero(Error):
+    """Raised when the input value is less than zero"""
+
+
+def _check_number_input(n, min_thresh, max_thresh=None):
+    """
+    :param n: single integer
+    :type n: int
+    :param min_thresh: min threshold, single integer
+    :type min_thresh: int
+    :param max_thresh: max threshold, single integer
+    :type max_thresh: int
+    :return: boolean
+    """
+    try:
+        if n >= min_thresh and max_thresh is None:
+            return True
+        elif min_thresh <= n <= max_thresh:
+            return True
+        elif n < 0:
+            raise ValueLessThanZero
+        elif n < min_thresh:
+            raise ValueTooSmallError
+        elif n > max_thresh:
+            raise ValueTooLargeError
+    except ValueLessThanZero:
+        print("Incorrect Input: number must not be less than 0")
+    except ValueTooSmallError:
+        print(f'Incorrect Input: input number must be > {min_thresh} for the recursive calculation')
+    except ValueTooLargeError:
+        print(f'Incorrect Input: input number must be < {max_thresh} for the recursive calculation')
+    return False
+
+
+@timer_decorator
+def fib_iterative(n):
+    """
+    :param n: calculate Fibonacci to the nth integer
+    :type n:int
+    :return: Fibonacci sequence as a list
+    """
+    n = int(n)
+    if _check_number_input(n, 2):
+        seq_out = [0, 1]
+        a, b = 0, 1
+        for _ in range(n-len(seq_out)):
+            a, b = b, a+b
+            seq_out.append(b)
+        return seq_out
+
+
+@timer_decorator
+def fib_formula(n):
+    """
+    :param n: calculate Fibonacci to the nth integer
+    :type n:int
+    :return: Fibonacci sequence as a list
+    """
+    seq_out = [0, 1]
+    n = int(n)
+    if _check_number_input(n, 2, 1000000):
+        sqrt = Decimal(math.sqrt(5))
+        phi_1 = Decimal(1 + sqrt) / Decimal(2)
+        phi_2 = Decimal(1 - sqrt) / Decimal(2)
+        for i in range(2, n):
+            temp_out = ((phi_1**Decimal(i)) - (phi_2**Decimal(i))) * (Decimal(sqrt) ** Decimal(-1))
+            seq_out.append(int(temp_out))
+        return seq_out
+
+
+if __name__ == '__main__':
+    num = 20
+    # print(f'{fib_recursive(num)}\n')
+    # print(f'{fib_iterative(num)}\n')
+    # print(f'{fib_formula(num)}\n')
+    fib_iterative(num)
+    fib_formula(num)
diff --git a/Maths/lucasSeries.py b/maths/lucasSeries.py
similarity index 100%
rename from Maths/lucasSeries.py
rename to maths/lucasSeries.py
diff --git a/maths/tests/__init__.py b/maths/tests/__init__.py
new file mode 100644
index 000000000000..2c4a6048556c
--- /dev/null
+++ b/maths/tests/__init__.py
@@ -0,0 +1 @@
+from .. import fibonacci
diff --git a/maths/tests/test_fibonacci.py b/maths/tests/test_fibonacci.py
new file mode 100644
index 000000000000..7d36c755e346
--- /dev/null
+++ b/maths/tests/test_fibonacci.py
@@ -0,0 +1,34 @@
+"""
+To run with slash:
+1. run pip install slash (may need to install C++ builds from Visual Studio website)
+2. In the command prompt navigate to your project folder
+3. then type--> slash run -vv -k tags:fibonacci ..
+    -vv indicates the level of verbosity (how much stuff you want the test to spit out after running)
+    -k is a way to select the tests you want to run.  This becomes much more important in large scale projects.
+"""
+
+import slash
+from .. import fibonacci
+
+default_fib = [0, 1, 1, 2, 3, 5, 8]
+
+
+@slash.tag('fibonacci')
+@slash.parametrize(('n', 'seq'), [(2, [0, 1]), (3, [0, 1, 1]), (9, [0, 1, 1, 2, 3, 5, 8, 13, 21])])
+def test_different_sequence_lengths(n, seq):
+    """Test output of varying fibonacci sequence lengths"""
+    iterative = fibonacci.fib_iterative(n)
+    formula = fibonacci.fib_formula(n)
+    assert iterative == seq
+    assert formula == seq
+
+
+@slash.tag('fibonacci')
+@slash.parametrize('n', [7.3, 7.8, 7.0])
+def test_float_input_iterative(n):
+    """Test when user enters a float value"""
+    iterative = fibonacci.fib_iterative(n)
+    formula = fibonacci.fib_formula(n)
+    assert iterative == default_fib
+    assert formula == default_fib
+
diff --git a/project_euler/problem_01/sol6.py b/project_euler/problem_01/sol6.py
new file mode 100644
index 000000000000..54c3073f3897
--- /dev/null
+++ b/project_euler/problem_01/sol6.py
@@ -0,0 +1,9 @@
+a = 3
+result = 0
+while a < 1000:
+    if(a % 3 == 0 or a % 5 == 0):
+        result += a
+    elif(a % 15 == 0):
+        result -= a
+    a += 1
+print(result)

From 066f37402d87e31b35a7d9439b394445a1404461 Mon Sep 17 00:00:00 2001
From: guij15 <43374716+guij15@users.noreply.github.com>
Date: Mon, 10 Jun 2019 14:46:36 +0800
Subject: [PATCH 048/348] Update newton_raphson.py (#891)

---
 maths/newton_raphson.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/maths/newton_raphson.py b/maths/newton_raphson.py
index c08bcedc9a4d..cc6c92734fd4 100644
--- a/maths/newton_raphson.py
+++ b/maths/newton_raphson.py
@@ -33,7 +33,7 @@ def newton_raphson(f, x0=0, maxiter=100, step=0.0001, maxerror=1e-6,logsteps=Fal
         if error < maxerror:
             break
     else:
-        raise ValueError("Itheration limit reached, no converging solution found")
+        raise ValueError("Iteration limit reached, no converging solution found")
     if logsteps:
         #If logstep is true, then log intermediate steps
         return a, error, steps
@@ -47,4 +47,4 @@ def newton_raphson(f, x0=0, maxiter=100, step=0.0001, maxerror=1e-6,logsteps=Fal
     plt.xlabel("step")
     plt.ylabel("error")
     plt.show()
-    print("solution = {%f}, error = {%f}" % (solution, error))
\ No newline at end of file
+    print("solution = {%f}, error = {%f}" % (solution, error))

From 05e5172093dbd0633ce83044603073dd2be675c4 Mon Sep 17 00:00:00 2001
From: Hector S <hfsam88@gmail.com>
Date: Tue, 11 Jun 2019 07:24:53 -0400
Subject: [PATCH 049/348] .vs/ directory, matrix_multiplication_addition file
 and binary tree directory (#894)

* Added print function into matrix_multiplication_addition.py and removed blank space in data_structures/binary tree directory

* Removed .vs/ folder per #893

* Rename matrix_multiplication_addition.py to matrix_operation.py
---
 .vs/Python/v15/.suo                            | Bin 16896 -> 0 bytes
 .vs/slnx.sqlite                                | Bin 176128 -> 0 bytes
 .../{binary tree => binary_tree}/AVL_tree.py   |   0
 .../binary_search_tree.py                      |   0
 .../fenwick_tree.py                            |   0
 .../lazy_segment_tree.py                       |   0
 .../segment_tree.py                            |   0
 .../{binary tree => binary_tree}/treap.py      |   0
 ...ication_addition.py => matrix_operation.py} |  15 ++++++++-------
 9 files changed, 8 insertions(+), 7 deletions(-)
 delete mode 100644 .vs/Python/v15/.suo
 delete mode 100644 .vs/slnx.sqlite
 rename data_structures/{binary tree => binary_tree}/AVL_tree.py (100%)
 rename data_structures/{binary tree => binary_tree}/binary_search_tree.py (100%)
 rename data_structures/{binary tree => binary_tree}/fenwick_tree.py (100%)
 rename data_structures/{binary tree => binary_tree}/lazy_segment_tree.py (100%)
 rename data_structures/{binary tree => binary_tree}/segment_tree.py (100%)
 rename data_structures/{binary tree => binary_tree}/treap.py (100%)
 rename matrix/{matrix_multiplication_addition.py => matrix_operation.py} (80%)

diff --git a/.vs/Python/v15/.suo b/.vs/Python/v15/.suo
deleted file mode 100644
index 0e3f4807567d1e684e2302bf9cfb6cc11e1c136d..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 16896
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

diff --git a/.vs/slnx.sqlite b/.vs/slnx.sqlite
deleted file mode 100644
index 2fe4a449f121e419a91e4b74caa326bd9c11d003..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 176128
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

diff --git a/data_structures/binary tree/AVL_tree.py b/data_structures/binary_tree/AVL_tree.py
similarity index 100%
rename from data_structures/binary tree/AVL_tree.py
rename to data_structures/binary_tree/AVL_tree.py
diff --git a/data_structures/binary tree/binary_search_tree.py b/data_structures/binary_tree/binary_search_tree.py
similarity index 100%
rename from data_structures/binary tree/binary_search_tree.py
rename to data_structures/binary_tree/binary_search_tree.py
diff --git a/data_structures/binary tree/fenwick_tree.py b/data_structures/binary_tree/fenwick_tree.py
similarity index 100%
rename from data_structures/binary tree/fenwick_tree.py
rename to data_structures/binary_tree/fenwick_tree.py
diff --git a/data_structures/binary tree/lazy_segment_tree.py b/data_structures/binary_tree/lazy_segment_tree.py
similarity index 100%
rename from data_structures/binary tree/lazy_segment_tree.py
rename to data_structures/binary_tree/lazy_segment_tree.py
diff --git a/data_structures/binary tree/segment_tree.py b/data_structures/binary_tree/segment_tree.py
similarity index 100%
rename from data_structures/binary tree/segment_tree.py
rename to data_structures/binary_tree/segment_tree.py
diff --git a/data_structures/binary tree/treap.py b/data_structures/binary_tree/treap.py
similarity index 100%
rename from data_structures/binary tree/treap.py
rename to data_structures/binary_tree/treap.py
diff --git a/matrix/matrix_multiplication_addition.py b/matrix/matrix_operation.py
similarity index 80%
rename from matrix/matrix_multiplication_addition.py
rename to matrix/matrix_operation.py
index dd50db729e43..dd7c01582681 100644
--- a/matrix/matrix_multiplication_addition.py
+++ b/matrix/matrix_operation.py
@@ -1,3 +1,5 @@
+from __future__ import print_function
+
 def add(matrix_a, matrix_b):
     rows = len(matrix_a)
     columns = len(matrix_a[0])
@@ -63,13 +65,12 @@ def main():
     matrix_b = [[3, 4], [7, 4]]
     matrix_c = [[11, 12, 13, 14], [21, 22, 23, 24], [31, 32, 33, 34], [41, 42, 43, 44]]
     matrix_d = [[3, 0, 2], [2, 0, -2], [0, 1, 1]]
-
-    print(add(matrix_a, matrix_b))
-    print(multiply(matrix_a, matrix_b))
-    print(identity(5))
-    print(minor(matrix_c , 1 , 2))
-    print(determinant(matrix_b))
-    print(inverse(matrix_d))
+    print('Add Operation, %s + %s = %s \n' %(matrix_a, matrix_b, (add(matrix_a, matrix_b))))
+    print('Multiply Operation, %s * %s = %s \n' %(matrix_a, matrix_b, multiply(matrix_a, matrix_b)))
+    print('Identity:  %s \n' %identity(5))
+    print('Minor of %s = %s \n' %(matrix_c, minor(matrix_c , 1 , 2)))
+    print('Determinant of %s = %s \n' %(matrix_b, determinant(matrix_b)))
+    print('Inverse of %s = %s\n'%(matrix_d, inverse(matrix_d)))
 
 if __name__ == '__main__':
     main()

From af1925bcd9926c36a418acb5f5269455cc6c6f34 Mon Sep 17 00:00:00 2001
From: StephenGemin <45926479+StephenGemin@users.noreply.github.com>
Date: Wed, 12 Jun 2019 10:54:30 -0400
Subject: [PATCH 050/348] Remove empty folder in analysis/compression_analysis
 (#897)

* Add compression_analysis

removing analysis/compression_analysis to just compression_analysis

* Delete PSNR-example-base.png

* Delete PSNR-example-comp-10.jpg

* Delete compressed_image.png

* Delete example_image.jpg

* Delete example_wikipedia_image.jpg

* Delete original_image.png

* Delete psnr.py
---
 .../PSNR-example-base.png                           | Bin
 .../PSNR-example-comp-10.jpg                        | Bin
 .../compressed_image.png                            | Bin
 .../example_image.jpg                               | Bin
 .../example_wikipedia_image.jpg                     | Bin
 .../original_image.png                              | Bin
 .../psnr.py                                         |   0
 7 files changed, 0 insertions(+), 0 deletions(-)
 rename {analysis/compression_analysis => compression_analysis}/PSNR-example-base.png (100%)
 rename {analysis/compression_analysis => compression_analysis}/PSNR-example-comp-10.jpg (100%)
 rename {analysis/compression_analysis => compression_analysis}/compressed_image.png (100%)
 rename {analysis/compression_analysis => compression_analysis}/example_image.jpg (100%)
 rename {analysis/compression_analysis => compression_analysis}/example_wikipedia_image.jpg (100%)
 rename {analysis/compression_analysis => compression_analysis}/original_image.png (100%)
 rename {analysis/compression_analysis => compression_analysis}/psnr.py (100%)

diff --git a/analysis/compression_analysis/PSNR-example-base.png b/compression_analysis/PSNR-example-base.png
similarity index 100%
rename from analysis/compression_analysis/PSNR-example-base.png
rename to compression_analysis/PSNR-example-base.png
diff --git a/analysis/compression_analysis/PSNR-example-comp-10.jpg b/compression_analysis/PSNR-example-comp-10.jpg
similarity index 100%
rename from analysis/compression_analysis/PSNR-example-comp-10.jpg
rename to compression_analysis/PSNR-example-comp-10.jpg
diff --git a/analysis/compression_analysis/compressed_image.png b/compression_analysis/compressed_image.png
similarity index 100%
rename from analysis/compression_analysis/compressed_image.png
rename to compression_analysis/compressed_image.png
diff --git a/analysis/compression_analysis/example_image.jpg b/compression_analysis/example_image.jpg
similarity index 100%
rename from analysis/compression_analysis/example_image.jpg
rename to compression_analysis/example_image.jpg
diff --git a/analysis/compression_analysis/example_wikipedia_image.jpg b/compression_analysis/example_wikipedia_image.jpg
similarity index 100%
rename from analysis/compression_analysis/example_wikipedia_image.jpg
rename to compression_analysis/example_wikipedia_image.jpg
diff --git a/analysis/compression_analysis/original_image.png b/compression_analysis/original_image.png
similarity index 100%
rename from analysis/compression_analysis/original_image.png
rename to compression_analysis/original_image.png
diff --git a/analysis/compression_analysis/psnr.py b/compression_analysis/psnr.py
similarity index 100%
rename from analysis/compression_analysis/psnr.py
rename to compression_analysis/psnr.py

From 1b3affc2eddc8288f8bb4a73167d99b3eb2c4fc8 Mon Sep 17 00:00:00 2001
From: Erfan Alimohammadi <erfan.aa@gmail.com>
Date: Sun, 16 Jun 2019 01:07:23 +0430
Subject: [PATCH 051/348] fix typo (#902)

---
 machine_learning/linear_regression.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/machine_learning/linear_regression.py b/machine_learning/linear_regression.py
index 8c23f1f77908..03f16629e451 100644
--- a/machine_learning/linear_regression.py
+++ b/machine_learning/linear_regression.py
@@ -1,6 +1,6 @@
 """
 Linear regression is the most basic type of regression commonly used for
-predictive analysis. The idea is preety simple, we have a dataset and we have
+predictive analysis. The idea is pretty simple, we have a dataset and we have
 a feature's associated with it. The Features should be choose very cautiously
 as they determine, how much our model will be able to make future predictions.
 We try to set these Feature weights, over many iterations, so that they best

From 6e2fb22f5e9a821f226d87298b08d8da4b3b3efd Mon Sep 17 00:00:00 2001
From: archithadge <45902236+archithadge@users.noreply.github.com>
Date: Sun, 16 Jun 2019 18:49:20 +0530
Subject: [PATCH 052/348] Problem 234 project Euler (#883)

* Problem 234 project Euler

* Update project_euler/problem_234

Co-Authored-By: Emmanuel Arias <emmanuelarias30@gmail.com>

* Update project_euler/problem_234

Co-Authored-By: Emmanuel Arias <emmanuelarias30@gmail.com>

* Update project_euler/problem_234

Co-Authored-By: Emmanuel Arias <emmanuelarias30@gmail.com>

* Update project_euler/problem_234

Co-Authored-By: Emmanuel Arias <emmanuelarias30@gmail.com>

* Update project_euler/problem_234

Co-Authored-By: Emmanuel Arias <emmanuelarias30@gmail.com>

* Update project_euler/problem_234

Co-Authored-By: Emmanuel Arias <emmanuelarias30@gmail.com>

* Update and rename problem_234 to problem_234.py

* Made suggested changes

else was not required
temp declared afterwards
suggested changes are correct.Thank u!

* Rename project_euler/problem_234.py to project_euler/problem_234/sol1.py
---
 project_euler/problem_234/sol1.py | 32 +++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 project_euler/problem_234/sol1.py

diff --git a/project_euler/problem_234/sol1.py b/project_euler/problem_234/sol1.py
new file mode 100644
index 000000000000..c7a6bd97d66b
--- /dev/null
+++ b/project_euler/problem_234/sol1.py
@@ -0,0 +1,32 @@
+# https://projecteuler.net/problem=234
+def fib(a, b, n):
+    
+    if n==1:
+        return a
+    elif n==2:
+        return b
+    elif n==3:
+        return str(a)+str(b)
+    
+    temp = 0
+    for x in range(2,n):
+        c=str(a) + str(b)
+        temp = b
+        b = c
+        a = temp
+    return c
+
+
+q=int(input())
+for x in range(q):
+    l=[i for i in input().split()]
+    c1=0
+    c2=1
+    while(1):
+        
+        if len(fib(l[0],l[1],c2))<int(l[2]):
+            c2+=1
+        else:
+            break
+    print(fib(l[0],l[1],c2+1)[int(l[2])-1])
+ 

From 55e0b0f00a2dbfd46f47d06cd7bd564720738d16 Mon Sep 17 00:00:00 2001
From: zachzhu2016 <48337051+zachzhu2016@users.noreply.github.com>
Date: Mon, 17 Jun 2019 03:13:36 -0700
Subject: [PATCH 053/348] Corrected wrong DFS implementation (#903)

---
 graphs/DFS.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/graphs/DFS.py b/graphs/DFS.py
index c9843ca25382..68bf60e3c298 100644
--- a/graphs/DFS.py
+++ b/graphs/DFS.py
@@ -16,7 +16,6 @@ def dfs(graph, start):
       to the node's children onto the iterator stack. When the iterator at the top of the stack terminates, we'll pop
        it off the stack."""
     explored, stack = set(), [start]
-    explored.add(start)
     while stack:
         v = stack.pop()  # one difference from BFS is to pop last element here instead of first one
         

From ef147484ab456b6c55128d809bee05c1bf4638cf Mon Sep 17 00:00:00 2001
From: Daniel Xu <niellxu@yahoo.ca>
Date: Mon, 17 Jun 2019 06:17:53 -0400
Subject: [PATCH 054/348] Added script for automatically generating
 DIRECTORY.md (#889)

* Added script for automatically generating DIRECTORY.md

* Sort and list files by alphabetical order

* Rename script.py to ~script.py
---
 DIRECTORY.md | 374 +++++++++++++++++++++++++++++++++++++++++++++++++++
 ~script.py   |  70 ++++++++++
 2 files changed, 444 insertions(+)
 create mode 100644 DIRECTORY.md
 create mode 100644 ~script.py

diff --git a/DIRECTORY.md b/DIRECTORY.md
new file mode 100644
index 000000000000..ad25772b56b6
--- /dev/null
+++ b/DIRECTORY.md
@@ -0,0 +1,374 @@
+## Analysis
+  * Compression Analysis
+    * [psnr](https://github.com/TheAlgorithms/Python/blob/master/analysis/compression_analysis/psnr.py)
+## Arithmetic Analysis
+  * [bisection](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/bisection.py)
+  * [intersection](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/intersection.py)
+  * [lu decomposition](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/lu_decomposition.py)
+  * [newton method](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/newton_method.py)
+  * [newton raphson method](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/newton_raphson_method.py)
+## Binary Tree
+  * [basic binary tree](https://github.com/TheAlgorithms/Python/blob/master/binary_tree/basic_binary_tree.py)
+## Boolean Algebra
+  * [quine mc cluskey](https://github.com/TheAlgorithms/Python/blob/master/boolean_algebra/quine_mc_cluskey.py)
+## Ciphers
+  * [affine cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/affine_cipher.py)
+  * [Atbash](https://github.com/TheAlgorithms/Python/blob/master/ciphers/Atbash.py)
+  * [base16](https://github.com/TheAlgorithms/Python/blob/master/ciphers/base16.py)
+  * [base32](https://github.com/TheAlgorithms/Python/blob/master/ciphers/base32.py)
+  * [base64 cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/base64_cipher.py)
+  * [base85](https://github.com/TheAlgorithms/Python/blob/master/ciphers/base85.py)
+  * [brute force caesar cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/brute_force_caesar_cipher.py)
+  * [caesar cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/caesar_cipher.py)
+  * [cryptomath module](https://github.com/TheAlgorithms/Python/blob/master/ciphers/cryptomath_module.py)
+  * [elgamal key generator](https://github.com/TheAlgorithms/Python/blob/master/ciphers/elgamal_key_generator.py)
+  * [hill cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/hill_cipher.py)
+  * [morse Code implementation](https://github.com/TheAlgorithms/Python/blob/master/ciphers/morse_Code_implementation.py)
+  * [onepad cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/onepad_cipher.py)
+  * [playfair cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/playfair_cipher.py)
+  * [prehistoric men](https://github.com/TheAlgorithms/Python/blob/master/ciphers/prehistoric_men.txt)
+  * [rabin miller](https://github.com/TheAlgorithms/Python/blob/master/ciphers/rabin_miller.py)
+  * [rot13](https://github.com/TheAlgorithms/Python/blob/master/ciphers/rot13.py)
+  * [rsa cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/rsa_cipher.py)
+  * [rsa key generator](https://github.com/TheAlgorithms/Python/blob/master/ciphers/rsa_key_generator.py)
+  * [simple substitution cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/simple_substitution_cipher.py)
+  * [trafid cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/trafid_cipher.py)
+  * [transposition cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/transposition_cipher.py)
+  * [transposition cipher encrypt decrypt file](https://github.com/TheAlgorithms/Python/blob/master/ciphers/transposition_cipher_encrypt_decrypt_file.py)
+  * [vigenere cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/vigenere_cipher.py)
+  * [xor cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/xor_cipher.py)
+## Compression
+  * [huffman](https://github.com/TheAlgorithms/Python/blob/master/compression/huffman.py)
+## Data Structures
+  * [arrays](https://github.com/TheAlgorithms/Python/blob/master/data_structures/arrays.py)
+  * [avl](https://github.com/TheAlgorithms/Python/blob/master/data_structures/avl.py)
+  * [LCA](https://github.com/TheAlgorithms/Python/blob/master/data_structures/LCA.py)
+  * Binary Tree
+    * [AVL tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary%20tree/AVL_tree.py)
+    * [binary search tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary%20tree/binary_search_tree.py)
+    * [fenwick tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary%20tree/fenwick_tree.py)
+    * [lazy segment tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary%20tree/lazy_segment_tree.py)
+    * [segment tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary%20tree/segment_tree.py)
+    * [treap](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary%20tree/treap.py)
+  * Hashing
+    * [double hash](https://github.com/TheAlgorithms/Python/blob/master/data_structures/hashing/double_hash.py)
+    * [hash table](https://github.com/TheAlgorithms/Python/blob/master/data_structures/hashing/hash_table.py)
+    * [hash table with linked list](https://github.com/TheAlgorithms/Python/blob/master/data_structures/hashing/hash_table_with_linked_list.py)
+    * [quadratic probing](https://github.com/TheAlgorithms/Python/blob/master/data_structures/hashing/quadratic_probing.py)
+    * Number Theory
+      * [prime numbers](https://github.com/TheAlgorithms/Python/blob/master/data_structures/hashing/number_theory/prime_numbers.py)
+  * Heap
+    * [heap](https://github.com/TheAlgorithms/Python/blob/master/data_structures/heap/heap.py)
+  * Linked List
+    * [doubly linked list](https://github.com/TheAlgorithms/Python/blob/master/data_structures/linked_list/doubly_linked_list.py)
+    * [is Palindrome](https://github.com/TheAlgorithms/Python/blob/master/data_structures/linked_list/is_Palindrome.py)
+    * [singly linked list](https://github.com/TheAlgorithms/Python/blob/master/data_structures/linked_list/singly_linked_list.py)
+    * [swapNodes](https://github.com/TheAlgorithms/Python/blob/master/data_structures/linked_list/swapNodes.py)
+  * Queue
+    * [double ended queue](https://github.com/TheAlgorithms/Python/blob/master/data_structures/queue/double_ended_queue.py)
+    * [queue on list](https://github.com/TheAlgorithms/Python/blob/master/data_structures/queue/queue_on_list.py)
+    * [queue on pseudo stack](https://github.com/TheAlgorithms/Python/blob/master/data_structures/queue/queue_on_pseudo_stack.py)
+  * Stacks
+    * [balanced parentheses](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stacks/balanced_parentheses.py)
+    * [infix to postfix conversion](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stacks/infix_to_postfix_conversion.py)
+    * [infix to prefix conversion](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stacks/infix_to_prefix_conversion.py)
+    * [next](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stacks/next.py)
+    * [postfix evaluation](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stacks/postfix_evaluation.py)
+    * [stack](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stacks/stack.py)
+    * [stock span problem](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stacks/stock_span_problem.py)
+  * Trie
+    * [trie](https://github.com/TheAlgorithms/Python/blob/master/data_structures/trie/trie.py)
+  * Union Find
+    * [tests union find](https://github.com/TheAlgorithms/Python/blob/master/data_structures/union_find/tests_union_find.py)
+    * [union find](https://github.com/TheAlgorithms/Python/blob/master/data_structures/union_find/union_find.py)
+## Digital Image Processing
+  * Filters
+    * [median filter](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/filters/median_filter.py)
+## Dynamic Programming
+  * [abbreviation](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/abbreviation.py)
+  * [bitmask](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/bitmask.py)
+  * [coin change](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/coin_change.py)
+  * [edit distance](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/edit_distance.py)
+  * [fast fibonacci](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/fast_fibonacci.py)
+  * [fibonacci](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/fibonacci.py)
+  * [floyd warshall](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/floyd_warshall.py)
+  * [Fractional Knapsack](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/Fractional_Knapsack.py)
+  * [integer partition](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/integer_partition.py)
+  * [k means clustering tensorflow](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/k_means_clustering_tensorflow.py)
+  * [knapsack](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/knapsack.py)
+  * [longest common subsequence](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/longest_common_subsequence.py)
+  * [longest increasing subsequence](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/longest_increasing_subsequence.py)
+  * [longest increasing subsequence O(nlogn)](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/longest_increasing_subsequence_O(nlogn).py)
+  * [longest sub array](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/longest_sub_array.py)
+  * [matrix chain order](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/matrix_chain_order.py)
+  * [max sub array](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/max_sub_array.py)
+  * [minimum partition](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/minimum_partition.py)
+  * [rod cutting](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/rod_cutting.py)
+  * [subset generation](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/subset_generation.py)
+## File Transfer Protocol
+  * [ftp client server](https://github.com/TheAlgorithms/Python/blob/master/file_transfer_protocol/ftp_client_server.py)
+  * [ftp send receive](https://github.com/TheAlgorithms/Python/blob/master/file_transfer_protocol/ftp_send_receive.py)
+## Graphs
+  * [a star](https://github.com/TheAlgorithms/Python/blob/master/graphs/a_star.py)
+  * [articulation points](https://github.com/TheAlgorithms/Python/blob/master/graphs/articulation_points.py)
+  * [basic graphs](https://github.com/TheAlgorithms/Python/blob/master/graphs/basic_graphs.py)
+  * [bellman ford](https://github.com/TheAlgorithms/Python/blob/master/graphs/bellman_ford.py)
+  * [BFS](https://github.com/TheAlgorithms/Python/blob/master/graphs/BFS.py)
+  * [bfs shortest path](https://github.com/TheAlgorithms/Python/blob/master/graphs/bfs_shortest_path.py)
+  * [breadth first search](https://github.com/TheAlgorithms/Python/blob/master/graphs/breadth_first_search.py)
+  * [check bipartite graph bfs](https://github.com/TheAlgorithms/Python/blob/master/graphs/check_bipartite_graph_bfs.py)
+  * [check bipartite graph dfs](https://github.com/TheAlgorithms/Python/blob/master/graphs/check_bipartite_graph_dfs.py)
+  * [depth first search](https://github.com/TheAlgorithms/Python/blob/master/graphs/depth_first_search.py)
+  * [DFS](https://github.com/TheAlgorithms/Python/blob/master/graphs/DFS.py)
+  * [dijkstra](https://github.com/TheAlgorithms/Python/blob/master/graphs/dijkstra.py)
+  * [dijkstra 2](https://github.com/TheAlgorithms/Python/blob/master/graphs/dijkstra_2.py)
+  * [dijkstra algorithm](https://github.com/TheAlgorithms/Python/blob/master/graphs/dijkstra_algorithm.py)
+  * [Directed and Undirected (Weighted) Graph](https://github.com/TheAlgorithms/Python/blob/master/graphs/Directed_and_Undirected_(Weighted)_Graph.py)
+  * [edmonds karp multiple source and sink](https://github.com/TheAlgorithms/Python/blob/master/graphs/edmonds_karp_multiple_source_and_sink.py)
+  * [Eulerian path and circuit for undirected graph](https://github.com/TheAlgorithms/Python/blob/master/graphs/Eulerian_path_and_circuit_for_undirected_graph.py)
+  * [even tree](https://github.com/TheAlgorithms/Python/blob/master/graphs/even_tree.py)
+  * [finding bridges](https://github.com/TheAlgorithms/Python/blob/master/graphs/finding_bridges.py)
+  * [floyd warshall](https://github.com/TheAlgorithms/Python/blob/master/graphs/floyd_warshall.py)
+  * [graph list](https://github.com/TheAlgorithms/Python/blob/master/graphs/graph_list.py)
+  * [graph matrix](https://github.com/TheAlgorithms/Python/blob/master/graphs/graph_matrix.py)
+  * [kahns algorithm long](https://github.com/TheAlgorithms/Python/blob/master/graphs/kahns_algorithm_long.py)
+  * [kahns algorithm topo](https://github.com/TheAlgorithms/Python/blob/master/graphs/kahns_algorithm_topo.py)
+  * [minimum spanning tree kruskal](https://github.com/TheAlgorithms/Python/blob/master/graphs/minimum_spanning_tree_kruskal.py)
+  * [minimum spanning tree prims](https://github.com/TheAlgorithms/Python/blob/master/graphs/minimum_spanning_tree_prims.py)
+  * [multi hueristic astar](https://github.com/TheAlgorithms/Python/blob/master/graphs/multi_hueristic_astar.py)
+  * [page rank](https://github.com/TheAlgorithms/Python/blob/master/graphs/page_rank.py)
+  * [prim](https://github.com/TheAlgorithms/Python/blob/master/graphs/prim.py)
+  * [scc kosaraju](https://github.com/TheAlgorithms/Python/blob/master/graphs/scc_kosaraju.py)
+  * [tarjans scc](https://github.com/TheAlgorithms/Python/blob/master/graphs/tarjans_scc.py)
+## Hashes
+  * [chaos machine](https://github.com/TheAlgorithms/Python/blob/master/hashes/chaos_machine.py)
+  * [md5](https://github.com/TheAlgorithms/Python/blob/master/hashes/md5.py)
+  * [sha1](https://github.com/TheAlgorithms/Python/blob/master/hashes/sha1.py)
+## Linear Algebra Python
+  * Src
+    * [lib](https://github.com/TheAlgorithms/Python/blob/master/linear_algebra_python/src/lib.py)
+    * [tests](https://github.com/TheAlgorithms/Python/blob/master/linear_algebra_python/src/tests.py)
+## Machine Learning
+  * [decision tree](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/decision_tree.py)
+  * [gradient descent](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/gradient_descent.py)
+  * [k means clust](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/k_means_clust.py)
+  * [linear regression](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/linear_regression.py)
+  * [logistic regression](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/logistic_regression.py)
+  * [perceptron](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/perceptron.py)
+  * [scoring functions](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/scoring_functions.py)
+  * Random Forest Classification
+    * [random forest classification](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/Random%20Forest%20Classification/random_forest_classification.py)
+    * [Social Network Ads](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/Random%20Forest%20Classification/Social_Network_Ads.csv)
+  * Random Forest Regression
+    * [Position Salaries](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/Random%20Forest%20Regression/Position_Salaries.csv)
+    * [random forest regression](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/Random%20Forest%20Regression/random_forest_regression.py)
+## Maths
+  * [3n+1](https://github.com/TheAlgorithms/Python/blob/master/maths/3n+1.py)
+  * [abs](https://github.com/TheAlgorithms/Python/blob/master/maths/abs.py)
+  * [abs Max](https://github.com/TheAlgorithms/Python/blob/master/maths/abs_Max.py)
+  * [abs Min](https://github.com/TheAlgorithms/Python/blob/master/maths/abs_Min.py)
+  * [average](https://github.com/TheAlgorithms/Python/blob/master/maths/average.py)
+  * [basic maths](https://github.com/TheAlgorithms/Python/blob/master/maths/basic_maths.py)
+  * [Binary Exponentiation](https://github.com/TheAlgorithms/Python/blob/master/maths/Binary_Exponentiation.py)
+  * [extended euclidean algorithm](https://github.com/TheAlgorithms/Python/blob/master/maths/extended_euclidean_algorithm.py)
+  * [factorial python](https://github.com/TheAlgorithms/Python/blob/master/maths/factorial_python.py)
+  * [factorial recursive](https://github.com/TheAlgorithms/Python/blob/master/maths/factorial_recursive.py)
+  * [fermat little theorem](https://github.com/TheAlgorithms/Python/blob/master/maths/fermat_little_theorem.py)
+  * [fibonacci](https://github.com/TheAlgorithms/Python/blob/master/maths/fibonacci.py)
+  * [fibonacci sequence recursion](https://github.com/TheAlgorithms/Python/blob/master/maths/fibonacci_sequence_recursion.py)
+  * [find lcm](https://github.com/TheAlgorithms/Python/blob/master/maths/find_lcm.py)
+  * [Find Max](https://github.com/TheAlgorithms/Python/blob/master/maths/Find_Max.py)
+  * [Find Min](https://github.com/TheAlgorithms/Python/blob/master/maths/Find_Min.py)
+  * [greater common divisor](https://github.com/TheAlgorithms/Python/blob/master/maths/greater_common_divisor.py)
+  * [Hanoi](https://github.com/TheAlgorithms/Python/blob/master/maths/Hanoi.py)
+  * [lucasSeries](https://github.com/TheAlgorithms/Python/blob/master/maths/lucasSeries.py)
+  * [modular exponential](https://github.com/TheAlgorithms/Python/blob/master/maths/modular_exponential.py)
+  * [newton raphson](https://github.com/TheAlgorithms/Python/blob/master/maths/newton_raphson.py)
+  * [Prime Check](https://github.com/TheAlgorithms/Python/blob/master/maths/Prime_Check.py)
+  * [segmented sieve](https://github.com/TheAlgorithms/Python/blob/master/maths/segmented_sieve.py)
+  * [sieve of eratosthenes](https://github.com/TheAlgorithms/Python/blob/master/maths/sieve_of_eratosthenes.py)
+  * [simpson rule](https://github.com/TheAlgorithms/Python/blob/master/maths/simpson_rule.py)
+  * [trapezoidal rule](https://github.com/TheAlgorithms/Python/blob/master/maths/trapezoidal_rule.py)
+  * Tests
+    * [test fibonacci](https://github.com/TheAlgorithms/Python/blob/master/maths/tests/test_fibonacci.py)
+## Matrix
+  * [matrix multiplication addition](https://github.com/TheAlgorithms/Python/blob/master/matrix/matrix_multiplication_addition.py)
+  * [searching in sorted matrix](https://github.com/TheAlgorithms/Python/blob/master/matrix/searching_in_sorted_matrix.py)
+## Networking Flow
+  * [ford fulkerson](https://github.com/TheAlgorithms/Python/blob/master/networking_flow/ford_fulkerson.py)
+  * [minimum cut](https://github.com/TheAlgorithms/Python/blob/master/networking_flow/minimum_cut.py)
+## Neural Network
+  * [bpnn](https://github.com/TheAlgorithms/Python/blob/master/neural_network/bpnn.py)
+  * [convolution neural network](https://github.com/TheAlgorithms/Python/blob/master/neural_network/convolution_neural_network.py)
+  * [perceptron](https://github.com/TheAlgorithms/Python/blob/master/neural_network/perceptron.py)
+## Other
+  * [anagrams](https://github.com/TheAlgorithms/Python/blob/master/other/anagrams.py)
+  * [binary exponentiation](https://github.com/TheAlgorithms/Python/blob/master/other/binary_exponentiation.py)
+  * [binary exponentiation 2](https://github.com/TheAlgorithms/Python/blob/master/other/binary_exponentiation_2.py)
+  * [detecting english programmatically](https://github.com/TheAlgorithms/Python/blob/master/other/detecting_english_programmatically.py)
+  * [dictionary](https://github.com/TheAlgorithms/Python/blob/master/other/dictionary.txt)
+  * [euclidean gcd](https://github.com/TheAlgorithms/Python/blob/master/other/euclidean_gcd.py)
+  * [finding Primes](https://github.com/TheAlgorithms/Python/blob/master/other/finding_Primes.py)
+  * [fischer yates shuffle](https://github.com/TheAlgorithms/Python/blob/master/other/fischer_yates_shuffle.py)
+  * [frequency finder](https://github.com/TheAlgorithms/Python/blob/master/other/frequency_finder.py)
+  * [linear congruential generator](https://github.com/TheAlgorithms/Python/blob/master/other/linear_congruential_generator.py)
+  * [n queens](https://github.com/TheAlgorithms/Python/blob/master/other/n_queens.py)
+  * [nested brackets](https://github.com/TheAlgorithms/Python/blob/master/other/nested_brackets.py)
+  * [palindrome](https://github.com/TheAlgorithms/Python/blob/master/other/palindrome.py)
+  * [password generator](https://github.com/TheAlgorithms/Python/blob/master/other/password_generator.py)
+  * [primelib](https://github.com/TheAlgorithms/Python/blob/master/other/primelib.py)
+  * [sierpinski triangle](https://github.com/TheAlgorithms/Python/blob/master/other/sierpinski_triangle.py)
+  * [tower of hanoi](https://github.com/TheAlgorithms/Python/blob/master/other/tower_of_hanoi.py)
+  * [two sum](https://github.com/TheAlgorithms/Python/blob/master/other/two_sum.py)
+  * [word patterns](https://github.com/TheAlgorithms/Python/blob/master/other/word_patterns.py)
+  * [words](https://github.com/TheAlgorithms/Python/blob/master/other/words)
+  * Game Of Life
+    * [game o life](https://github.com/TheAlgorithms/Python/blob/master/other/game_of_life/game_o_life.py)
+    * [sample](https://github.com/TheAlgorithms/Python/blob/master/other/game_of_life/sample.gif)
+## Project Euler
+  * Problem 01
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_01/sol1.py)
+    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_01/sol2.py)
+    * [sol3](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_01/sol3.py)
+    * [sol4](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_01/sol4.py)
+    * [sol5](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_01/sol5.py)
+    * [sol6](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_01/sol6.py)
+  * Problem 02
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_02/sol1.py)
+    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_02/sol2.py)
+    * [sol3](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_02/sol3.py)
+    * [sol4](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_02/sol4.py)
+  * Problem 03
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_03/sol1.py)
+    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_03/sol2.py)
+  * Problem 04
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_04/sol1.py)
+    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_04/sol2.py)
+  * Problem 05
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_05/sol1.py)
+    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_05/sol2.py)
+  * Problem 06
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_06/sol1.py)
+    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_06/sol2.py)
+    * [sol3](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_06/sol3.py)
+  * Problem 07
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_07/sol1.py)
+    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_07/sol2.py)
+    * [sol3](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_07/sol3.py)
+  * Problem 08
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_08/sol1.py)
+    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_08/sol2.py)
+  * Problem 09
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_09/sol1.py)
+    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_09/sol2.py)
+    * [sol3](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_09/sol3.py)
+  * Problem 10
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_10/sol1.py)
+    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_10/sol2.py)
+  * Problem 11
+    * [grid](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_11/grid.txt)
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_11/sol1.py)
+    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_11/sol2.py)
+  * Problem 12
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_12/sol1.py)
+    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_12/sol2.py)
+  * Problem 13
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_13/sol1.py)
+  * Problem 14
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_14/sol1.py)
+    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_14/sol2.py)
+  * Problem 15
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_15/sol1.py)
+  * Problem 16
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_16/sol1.py)
+  * Problem 17
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_17/sol1.py)
+  * Problem 19
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_19/sol1.py)
+  * Problem 20
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_20/sol1.py)
+    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_20/sol2.py)
+  * Problem 21
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_21/sol1.py)
+  * Problem 22
+    * [p022 names](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_22/p022_names.txt)
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_22/sol1.py)
+    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_22/sol2.py)
+  * Problem 24
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_24/sol1.py)
+  * Problem 25
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_25/sol1.py)
+    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_25/sol2.py)
+  * Problem 28
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_28/sol1.py)
+  * Problem 29
+    * [solution](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_29/solution.py)
+  * Problem 31
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_31/sol1.py)
+  * Problem 36
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_36/sol1.py)
+  * Problem 40
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_40/sol1.py)
+  * Problem 48
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_48/sol1.py)
+  * Problem 52
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_52/sol1.py)
+  * Problem 53
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_53/sol1.py)
+  * Problem 76
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_76/sol1.py)
+## Searches
+  * [binary search](https://github.com/TheAlgorithms/Python/blob/master/searches/binary_search.py)
+  * [interpolation search](https://github.com/TheAlgorithms/Python/blob/master/searches/interpolation_search.py)
+  * [jump search](https://github.com/TheAlgorithms/Python/blob/master/searches/jump_search.py)
+  * [linear search](https://github.com/TheAlgorithms/Python/blob/master/searches/linear_search.py)
+  * [quick select](https://github.com/TheAlgorithms/Python/blob/master/searches/quick_select.py)
+  * [sentinel linear search](https://github.com/TheAlgorithms/Python/blob/master/searches/sentinel_linear_search.py)
+  * [tabu search](https://github.com/TheAlgorithms/Python/blob/master/searches/tabu_search.py)
+  * [tabu test data](https://github.com/TheAlgorithms/Python/blob/master/searches/tabu_test_data.txt)
+  * [ternary search](https://github.com/TheAlgorithms/Python/blob/master/searches/ternary_search.py)
+  * [test interpolation search](https://github.com/TheAlgorithms/Python/blob/master/searches/test_interpolation_search.py)
+  * [test tabu search](https://github.com/TheAlgorithms/Python/blob/master/searches/test_tabu_search.py)
+## Simple Client
+  * [client](https://github.com/TheAlgorithms/Python/blob/master/simple_client/client.py)
+  * [server](https://github.com/TheAlgorithms/Python/blob/master/simple_client/server.py)
+## Sorts
+  * [Bitonic Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/Bitonic_Sort.py)
+  * [bogo sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/bogo_sort.py)
+  * [bubble sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/bubble_sort.py)
+  * [bucket sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/bucket_sort.py)
+  * [cocktail shaker sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/cocktail_shaker_sort.py)
+  * [comb sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/comb_sort.py)
+  * [counting sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/counting_sort.py)
+  * [cycle sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/cycle_sort.py)
+  * [external sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/external_sort.py)
+  * [gnome sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/gnome_sort.py)
+  * [heap sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/heap_sort.py)
+  * [insertion sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/insertion_sort.py)
+  * [merge sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/merge_sort.py)
+  * [merge sort fastest](https://github.com/TheAlgorithms/Python/blob/master/sorts/merge_sort_fastest.py)
+  * [Odd-Even transposition parallel](https://github.com/TheAlgorithms/Python/blob/master/sorts/Odd-Even_transposition_parallel.py)
+  * [Odd-Even transposition single-threaded](https://github.com/TheAlgorithms/Python/blob/master/sorts/Odd-Even_transposition_single-threaded.py)
+  * [pancake sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/pancake_sort.py)
+  * [pigeon sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/pigeon_sort.py)
+  * [quick sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/quick_sort.py)
+  * [quick sort 3 partition](https://github.com/TheAlgorithms/Python/blob/master/sorts/quick_sort_3_partition.py)
+  * [radix sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/radix_sort.py)
+  * [random normal distribution quicksort](https://github.com/TheAlgorithms/Python/blob/master/sorts/random_normal_distribution_quicksort.py)
+  * [random pivot quick sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/random_pivot_quick_sort.py)
+  * [selection sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/selection_sort.py)
+  * [shell sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/shell_sort.py)
+  * [tests](https://github.com/TheAlgorithms/Python/blob/master/sorts/tests.py)
+  * [tim sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/tim_sort.py)
+  * [topological sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/topological_sort.py)
+  * [tree sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/tree_sort.py)
+  * [wiggle sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/wiggle_sort.py)
+## Strings
+  * [knuth morris pratt](https://github.com/TheAlgorithms/Python/blob/master/strings/knuth_morris_pratt.py)
+  * [levenshtein distance](https://github.com/TheAlgorithms/Python/blob/master/strings/levenshtein_distance.py)
+  * [manacher](https://github.com/TheAlgorithms/Python/blob/master/strings/manacher.py)
+  * [min cost string conversion](https://github.com/TheAlgorithms/Python/blob/master/strings/min_cost_string_conversion.py)
+  * [naive String Search](https://github.com/TheAlgorithms/Python/blob/master/strings/naive_String_Search.py)
+  * [rabin karp](https://github.com/TheAlgorithms/Python/blob/master/strings/rabin_karp.py)
+## Traversals
+  * [binary tree traversals](https://github.com/TheAlgorithms/Python/blob/master/traversals/binary_tree_traversals.py)
diff --git a/~script.py b/~script.py
new file mode 100644
index 000000000000..4a2c61c83563
--- /dev/null
+++ b/~script.py
@@ -0,0 +1,70 @@
+"""
+This is a simple script that will scan through the current directory
+and generate the corresponding DIRECTORY.md file, can also specify
+files or folders to be ignored.
+"""
+import os
+
+
+# Target URL (master)
+URL = "https://github.com/TheAlgorithms/Python/blob/master/"
+
+
+def tree(d, ignores, ignores_ext):
+    return _markdown(d, ignores, ignores_ext, 0)
+    
+
+def _markdown(parent, ignores, ignores_ext, depth):
+    out = ""
+    dirs, files = [], []
+    for i in os.listdir(parent):
+        full = os.path.join(parent, i)
+        name, ext = os.path.splitext(i)
+        if i in ignores or ext in ignores_ext:
+            continue
+        if os.path.isfile(full):
+            # generate list
+            pre = parent.replace("./", "").replace(" ", "%20")
+            # replace all spaces to safe URL
+            child = i.replace(" ", "%20")
+            files.append((pre, child, name))
+        else:
+            dirs.append(i)
+    # Sort files
+    files.sort(key=lambda e: e[2].lower())
+    for f in files:
+        pre, child, name = f
+        out += "  " * depth + "* [" + name.replace("_", " ") + "](" + URL + pre + "/" + child + ")\n"
+    # Sort directories
+    dirs.sort()
+    for i in dirs:
+        full = os.path.join(parent, i)
+        i = i.replace("_", " ").title()
+        if depth == 0:
+            out += "## " + i + "\n"
+        else:
+            out += "  " * depth + "* " + i + "\n"
+        out += _markdown(full, ignores, ignores_ext, depth+1)
+    return out
+
+
+# Specific files or folders with the given names will be ignored
+ignores = [".vs",
+    ".gitignore",
+    ".git",
+    "script.py",
+    "__init__.py",
+]
+# Files with given entensions will be ignored
+ignores_ext = [
+    ".md",
+    ".ipynb",
+    ".png",
+    ".jpg",
+    ".yml"
+]
+
+
+if __name__ == "__main__":
+    with open("DIRECTORY.md", "w+") as f:
+        f.write(tree(".", ignores, ignores_ext))

From b8937364dc18a8ba59ef5a3cdbc0ffc85b604c86 Mon Sep 17 00:00:00 2001
From: Hector S <hfsam88@gmail.com>
Date: Tue, 18 Jun 2019 06:27:08 -0400
Subject: [PATCH 055/348] Fixed typo and capitalized some words (#900)

File looks more elegant now ;-)
---
 CONTRIBUTING.md | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 9b2ac0025dca..19b928c187f9 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -10,10 +10,10 @@ Welcome to [TheAlgorithms/Python](https://github.com/TheAlgorithms/Python)! Befo
 
 We are very happy that you consider implementing algorithms and data structure for others! This repository is referenced and used by learners from all over the globe. Being one of our contributors, you agree and confirm that:
 
-- your did your work - no plagiarism allowed
+- You did your work - no plagiarism allowed
   - Any plagiarized work will not be merged.
-- your work will be distributed under [MIT License](License) once your pull request is merged
-- you submitted work fulfils or mostly fulfils our styles and standards
+- Your work will be distributed under [MIT License](License) once your pull request is merged
+- You submitted work fulfils or mostly fulfils our styles and standards
 
 **New implementation** is welcome! For example, new solutions for a problem, different representations for a graph data structure or algorithm designs with different complexity.
 
@@ -115,8 +115,8 @@ We want your work to be readable by others; therefore, we encourage you to note
 
 - Most importantly,
 
-  - **be consistent with this guidelines while submitting.**
-  - **join** [Gitter](https://gitter.im/TheAlgorithms) **now!**
+  - **Be consistent with this guidelines while submitting.**
+  - **Join** [Gitter](https://gitter.im/TheAlgorithms) **now!**
   - Happy coding!
 
 

From a99acae32da09285b1a87c9e3dc9bf956c9077f6 Mon Sep 17 00:00:00 2001
From: StephenGemin <45926479+StephenGemin@users.noreply.github.com>
Date: Tue, 18 Jun 2019 06:28:01 -0400
Subject: [PATCH 056/348] Add docstring and comments per Issue #727 (#895)

I've added comments to make understanding this method a little easier for those that are not familiar.  This should close out #727 .

Other changes:
1. added if __name__ == '__main__' rather than the "# MAIN" comment
2. put in return for distances and vertices.  Previously everything was just printed out, but someone may find it useful to have the algorithm return something.
3. Other PEP8 changes
4.  Added example input and expected output as a check to make sure any future changes will give the same output.
---
 graphs/floyd_warshall.py | 102 ++++++++++++++++++++++++++++++---------
 1 file changed, 78 insertions(+), 24 deletions(-)

diff --git a/graphs/floyd_warshall.py b/graphs/floyd_warshall.py
index fae8b19b351a..a1d12aac02b4 100644
--- a/graphs/floyd_warshall.py
+++ b/graphs/floyd_warshall.py
@@ -1,9 +1,16 @@
+# floyd_warshall.py
+"""
+    The problem is to find the shortest distance between all pairs of vertices in a weighted directed graph that can
+    have negative edge weights.
+"""
+
 from __future__ import print_function
 
-def printDist(dist, V):
+
+def _print_dist(dist, v):
 	print("\nThe shortest path matrix using Floyd Warshall algorithm\n")
-	for i in range(V):
-		for j in range(V):
+	for i in range(v):
+		for j in range(v):
 			if dist[i][j] != float('inf') :
 				print(int(dist[i][j]),end = "\t")
 			else:
@@ -12,37 +19,84 @@ def printDist(dist, V):
 
 
 
-def FloydWarshall(graph, V):
-	dist=[[float('inf') for i in range(V)] for j in range(V)]
+def floyd_warshall(graph, v):
+	"""
+    :param graph: 2D array calculated from weight[edge[i, j]]
+    :type graph: List[List[float]]
+    :param v: number of vertices
+    :type v: int
+    :return: shortest distance between all vertex pairs
+    distance[u][v] will contain the shortest distance from vertex u to v.
+
+    1. For all edges from v to n, distance[i][j] = weight(edge(i, j)).
+    3. The algorithm then performs distance[i][j] = min(distance[i][j], distance[i][k] + distance[k][j]) for each
+    possible pair i, j of vertices.
+    4. The above is repeated for each vertex k in the graph.
+    5. Whenever distance[i][j] is given a new minimum value, next vertex[i][j] is updated to the next vertex[i][k].
+    """
+		
+	dist=[[float('inf') for _ in range(v)] for _ in range(v)]
 	
-	for i in range(V):
-		for j in range(V):
+	for i in range(v):
+		for j in range(v):
 			dist[i][j] = graph[i][j]
 
-	for k in range(V):
-		for i in range(V):
-			for j in range(V):
+    # check vertex k against all other vertices (i, j)
+	for k in range(v):
+		# looping through rows of graph array
+		for i in range(v):
+			# looping through columns of graph array
+			for j in range(v):
 				if dist[i][k]!=float('inf') and dist[k][j]!=float('inf') and dist[i][k]+dist[k][j] < dist[i][j]:
 					dist[i][j] = dist[i][k] + dist[k][j]
 
-	printDist(dist, V)	
+	_print_dist(dist, v)
+	return dist, v
 
 			
 
-#MAIN
-V = int(input("Enter number of vertices: "))
-E = int(input("Enter number of edges: "))
+if __name__== '__main__':
+	v = int(input("Enter number of vertices: "))
+	e = int(input("Enter number of edges: "))
+
+	graph = [[float('inf') for i in range(v)] for j in range(v)]
+
+	for i in range(v):
+		graph[i][i] = 0.0
+
+    # src and dst are indices that must be within the array size graph[e][v]
+    # failure to follow this will result in an error
+	for i in range(e):
+		print("\nEdge ",i+1)
+		src = int(input("Enter source:"))
+		dst = int(input("Enter destination:"))
+		weight = float(input("Enter weight:"))
+		graph[src][dst] = weight
+
+	floyd_warshall(graph, v)
+
+
+	# Example Input
+	# Enter number of vertices: 3
+	# Enter number of edges: 2
 
-graph = [[float('inf') for i in range(V)] for j in range(V)]
+	# # generated graph from vertex and edge inputs
+	# [[inf, inf, inf], [inf, inf, inf], [inf, inf, inf]]
+	# [[0.0, inf, inf], [inf, 0.0, inf], [inf, inf, 0.0]]
 
-for i in range(V):
-	graph[i][i] = 0.0
+	# specify source, destination and weight for edge #1
+	# Edge  1
+	# Enter source:1
+	# Enter destination:2
+	# Enter weight:2
 
-for i in range(E):
-	print("\nEdge ",i+1)
-	src = int(input("Enter source:"))
-	dst = int(input("Enter destination:"))
-	weight = float(input("Enter weight:"))
-	graph[src][dst] = weight
+	# specify source, destination and weight for edge #2
+	# Edge  2
+	# Enter source:2
+	# Enter destination:1
+	# Enter weight:1
 
-FloydWarshall(graph, V)
+	# # Expected Output from the vertice, edge and src, dst, weight inputs!!
+	# 0		INF	INF
+	# INF	0	2
+	# INF	1	0

From 12a16d63b7bdc1da0e0b215dfd5d8b938234f4ed Mon Sep 17 00:00:00 2001
From: Adeoti Ayodeji <33290249+Lord-sarcastic@users.noreply.github.com>
Date: Sat, 22 Jun 2019 05:42:28 +0100
Subject: [PATCH 057/348] Update average.py (#908)

Reduced lines of code and extra processing on the line: n += 1
---
 maths/average.py | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/maths/average.py b/maths/average.py
index dc70836b5e83..d15601dd64ca 100644
--- a/maths/average.py
+++ b/maths/average.py
@@ -1,11 +1,10 @@
 def average(nums):
     sum = 0
-    n = 0
     for x in nums:
       sum += x
-      n += 1
-    avg = sum / n
+    avg = sum / len(nums)
     print(avg)
+    return avg
 
 def main():
   average([2, 4, 6, 8, 20, 50, 70])

From a212efee5b44312c8b4b626ae412bacc5f4117fd Mon Sep 17 00:00:00 2001
From: zachzhu2016 <48337051+zachzhu2016@users.noreply.github.com>
Date: Sun, 23 Jun 2019 08:32:12 -0700
Subject: [PATCH 058/348] Corrected wrong Dijkstra priority queue
 implementation  (#909)

* Corrected wrong DFS implementation

* changed list into hash set for dijkstra priority queue implementation.
---
 graphs/dijkstra.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/graphs/dijkstra.py b/graphs/dijkstra.py
index 6b08b28fcfd3..4b6bc347b061 100644
--- a/graphs/dijkstra.py
+++ b/graphs/dijkstra.py
@@ -20,12 +20,12 @@
 
 def dijkstra(graph, start, end):
     heap = [(0, start)]  # cost from start node,end node
-    visited = []
+    visited = set()
     while heap:
         (cost, u) = heapq.heappop(heap)
         if u in visited:
             continue
-        visited.append(u)
+        visited.add(u)
         if u == end:
             return cost
         for v, c in G[u]:

From b7cff04574f5288c0483040c11be3bcc2b396a32 Mon Sep 17 00:00:00 2001
From: wuminbin <wuminbin@yeah.net>
Date: Mon, 24 Jun 2019 18:11:07 +0800
Subject: [PATCH 059/348] better implementation for midpoint (#914)

---
 arithmetic_analysis/bisection.py | 4 ++--
 searches/binary_search.py        | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/arithmetic_analysis/bisection.py b/arithmetic_analysis/bisection.py
index c81fa84f81e1..8bf3f09782a3 100644
--- a/arithmetic_analysis/bisection.py
+++ b/arithmetic_analysis/bisection.py
@@ -14,7 +14,7 @@ def bisection(function, a, b):  # finds where the function becomes 0 in [a,b] us
         print("couldn't find root in [a,b]")
         return
     else:
-        mid = (start + end) / 2
+        mid = start + (end - start) / 2.0
         while abs(start - mid) > 10**-7:  # until we achieve precise equals to 10^-7
             if function(mid) == 0:
                 return mid
@@ -22,7 +22,7 @@ def bisection(function, a, b):  # finds where the function becomes 0 in [a,b] us
                 end = mid
             else:
                 start = mid
-            mid = (start + end) / 2
+            mid = start + (end - start) / 2.0
         return mid
 
 
diff --git a/searches/binary_search.py b/searches/binary_search.py
index 1d5da96586cd..e658dac2a3ef 100644
--- a/searches/binary_search.py
+++ b/searches/binary_search.py
@@ -45,7 +45,7 @@ def binary_search(sorted_collection, item):
     right = len(sorted_collection) - 1
 
     while left <= right:
-        midpoint = (left + right) // 2
+        midpoint = left + (right - left) // 2
         current_item = sorted_collection[midpoint]
         if current_item == item:
             return midpoint

From be4150c720187391488786053ac7a13eeb965446 Mon Sep 17 00:00:00 2001
From: brajesh-rit <brajesh_rit@yahoo.co.in>
Date: Wed, 26 Jun 2019 10:57:08 -0500
Subject: [PATCH 060/348] Create spiralPrint.py (#844)

* Create spiralPrint.py

* Update spiralPrint.py
---
 matrix/spiralPrint.py | 66 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 66 insertions(+)
 create mode 100644 matrix/spiralPrint.py

diff --git a/matrix/spiralPrint.py b/matrix/spiralPrint.py
new file mode 100644
index 000000000000..447881e508e7
--- /dev/null
+++ b/matrix/spiralPrint.py
@@ -0,0 +1,66 @@
+"""
+This program print the matix in spiral form.
+This problem has been solved through recursive way.
+
+      Matrix must satisfy below conditions
+        i) matrix should be only one or two dimensional
+        ii)column of all the row should be equal
+"""
+def checkMatrix(a):
+    # must be
+    if type(a) == list and len(a) > 0:
+        if type(a[0]) == list:
+            prevLen = 0
+            for i in a:
+                if prevLen == 0:
+                    prevLen = len(i)
+                    result = True
+                elif prevLen == len(i):
+                    result = True
+                else:
+                    result = False
+        else:
+            result = True
+    else:
+        result = False
+    return result
+
+
+def spiralPrint(a):
+
+    if checkMatrix(a) and len(a) > 0:
+
+        matRow = len(a)
+        if type(a[0]) == list:
+            matCol = len(a[0])
+        else:
+            for dat in a:
+                print(dat),
+            return
+
+        # horizotal printing increasing
+        for i in range(0, matCol):
+            print(a[0][i]),
+        # vertical printing down
+        for i in range(1, matRow):
+            print(a[i][matCol - 1]),
+        # horizotal printing decreasing
+        if matRow > 1:
+            for i in range(matCol - 2, -1, -1):
+                print(a[matRow - 1][i]),
+        # vertical printing up
+        for i in range(matRow - 2, 0, -1):
+            print(a[i][0]),
+        remainMat = [row[1:matCol - 1] for row in a[1:matRow - 1]]
+        if len(remainMat) > 0:
+            spiralPrint(remainMat)
+        else:
+            return
+    else:
+        print("Not a valid matrix")
+        return
+
+
+# driver code
+a = [[1 , 2, 3, 4],[5, 6, 7, 8],[9, 10, 11, 12]]
+spiralPrint(a)

From 34889fc6d8d3ac1cf5af11039cc1ec40185f778e Mon Sep 17 00:00:00 2001
From: BruceLee569 <49506152+BruceLee569@users.noreply.github.com>
Date: Fri, 28 Jun 2019 23:55:31 +0800
Subject: [PATCH 061/348] Update quick_sort.py (#928)

Use the last element as the first pivot, for it's easy to pop, this saves one element space.
Iterating with the original list saves half the space, instead of generate a new shallow copy list by slice method.
---
 sorts/quick_sort.py | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/sorts/quick_sort.py b/sorts/quick_sort.py
index 223c26fde1fe..7e8c868ebb06 100644
--- a/sorts/quick_sort.py
+++ b/sorts/quick_sort.py
@@ -33,17 +33,16 @@ def quick_sort(collection):
     if length <= 1:
         return collection
     else:
-        pivot = collection[0]
-        # Modify the list comprehensions to reduce the number of judgments, the speed has increased by more than 50%.
-        greater = []
-        lesser = []
-        for element in collection[1:]:
+        # Use the last element as the first pivot
+        pivot = collection.pop()
+        # Put elements greater than pivot in greater list
+        # Put elements lesser than pivot in lesser list
+        greater, lesser = [], []
+        for element in collection:
             if element > pivot:
                 greater.append(element)
             else:
                 lesser.append(element)
-        # greater = [element for element in collection[1:] if element > pivot]
-        # lesser = [element for element in collection[1:] if element <= pivot]
         return quick_sort(lesser) + [pivot] + quick_sort(greater)
 
 

From 2333f933236fbd57f9ed8644b0f8f7a19d10a2e7 Mon Sep 17 00:00:00 2001
From: PatOnTheBack <51241310+PatOnTheBack@users.noreply.github.com>
Date: Sun, 30 Jun 2019 00:41:26 -0400
Subject: [PATCH 062/348] Change Declaration of Var 'j' to None (#921)

Since `j` is redefined before it is used, it makes more sense to declare it with the value `None` instead of `1`.

This fixes a [warning from lgtm](https://lgtm.com/projects/g/TheAlgorithms/Python/snapshot/66c4afbd0f28f9989f35ddbeb5c9263390c5d192/files/other/primelib.py?sort=name&dir=ASC&mode=heatmap)
---
 other/primelib.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/other/primelib.py b/other/primelib.py
index 19572f8611cb..c371bc1b9861 100644
--- a/other/primelib.py
+++ b/other/primelib.py
@@ -283,7 +283,7 @@ def goldbach(number):
 
     # run variable for while-loops.
     i = 0
-    j = 1
+    j = None
     
     # exit variable. for break up the loops
     loop = True

From bd4017928ed3054016ea21b8464f36db5fa007dc Mon Sep 17 00:00:00 2001
From: PatOnTheBack <51241310+PatOnTheBack@users.noreply.github.com>
Date: Mon, 1 Jul 2019 04:10:18 -0400
Subject: [PATCH 063/348] Added Whitespace and Docstring (#924)

* Added Whitespace and Docstring

I modified the file to make Pylint happier and make the code more readable.

* Beautified Code and Added Docstring

I modified the file to make Pylint happier and make the code more readable.

* Added DOCSTRINGS, Wikipedia link, and whitespace

I added DOCSTRINGS and whitespace to make the code more readable and understandable.

* Improved Formatting

* Wrapped comments
* Fixed spelling error for `movement` variable
* Added DOCSTRINGs

* Improved Formatting

* Corrected whitespace to improve readability.
* Added docstrings.
* Made comments fit inside an 80 column layout.
---
 arithmetic_analysis/lu_decomposition.py | 48 +++++++++++++------------
 arithmetic_analysis/newton_method.py    | 29 +++++++++------
 maths/Hanoi.py                          | 21 ++++++-----
 maths/abs.py                            | 11 ++++--
 maths/average.py                        | 13 +++++--
 maths/find_lcm.py                       |  7 ++++
 sorts/bucket_sort.py                    | 31 ++++++++++------
 sorts/gnome_sort.py                     | 20 ++++++-----
 sorts/tests.py                          |  8 +++--
 sorts/topological_sort.py               |  3 ++
 sorts/tree_sort.py                      | 33 ++++++++++-------
 sorts/wiggle_sort.py                    | 17 ++++++---
 12 files changed, 154 insertions(+), 87 deletions(-)

diff --git a/arithmetic_analysis/lu_decomposition.py b/arithmetic_analysis/lu_decomposition.py
index f291d2dfe003..19e259afb826 100644
--- a/arithmetic_analysis/lu_decomposition.py
+++ b/arithmetic_analysis/lu_decomposition.py
@@ -1,32 +1,36 @@
+"""Lower-Upper (LU) Decomposition."""
+
 # lower–upper (LU) decomposition - https://en.wikipedia.org/wiki/LU_decomposition
 import numpy
 
-def LUDecompose (table):
+
+def LUDecompose(table):
     # Table that contains our data
     # Table has to be a square array so we need to check first
-    rows,columns=numpy.shape(table)
-    L=numpy.zeros((rows,columns))
-    U=numpy.zeros((rows,columns))
-    if rows!=columns:
+    rows, columns = numpy.shape(table)
+    L = numpy.zeros((rows, columns))
+    U = numpy.zeros((rows, columns))
+    if rows != columns:
         return []
-    for i in range (columns):
-        for j in range(i-1):
-            sum=0
-            for k in range (j-1):
-                sum+=L[i][k]*U[k][j]
-            L[i][j]=(table[i][j]-sum)/U[j][j]
-        L[i][i]=1
-        for j in range(i-1,columns):
-            sum1=0
-            for k in range(i-1):
-                sum1+=L[i][k]*U[k][j]
-            U[i][j]=table[i][j]-sum1
-    return L,U
+    for i in range(columns):
+        for j in range(i - 1):
+            sum = 0
+            for k in range(j - 1):
+                sum += L[i][k] * U[k][j]
+            L[i][j] = (table[i][j] - sum) / U[j][j]
+        L[i][i] = 1
+        for j in range(i - 1, columns):
+            sum1 = 0
+            for k in range(i - 1):
+                sum1 += L[i][k] * U[k][j]
+            U[i][j] = table[i][j] - sum1
+    return L, U
+
 
 if __name__ == "__main__":
-    matrix =numpy.array([[2,-2,1],
-                         [0,1,2],
-                         [5,3,1]])
-    L,U = LUDecompose(matrix)
+    matrix = numpy.array([[2, -2, 1],
+                          [0, 1, 2],
+                          [5, 3, 1]])
+    L, U = LUDecompose(matrix)
     print(L)
     print(U)
diff --git a/arithmetic_analysis/newton_method.py b/arithmetic_analysis/newton_method.py
index 2ed29502522e..cf5649ee3f3b 100644
--- a/arithmetic_analysis/newton_method.py
+++ b/arithmetic_analysis/newton_method.py
@@ -1,18 +1,25 @@
+"""Newton's Method."""
+
 # Newton's Method - https://en.wikipedia.org/wiki/Newton%27s_method
 
-def newton(function,function1,startingInt): #function is the f(x) and function1 is the f'(x)
-  x_n=startingInt
-  while True:
-      x_n1=x_n-function(x_n)/function1(x_n)
-      if abs(x_n-x_n1) < 10**-5:
-          return x_n1
-      x_n=x_n1
-      
+
+# function is the f(x) and function1 is the f'(x)
+def newton(function, function1, startingInt):
+    x_n = startingInt
+    while True:
+        x_n1 = x_n - function(x_n) / function1(x_n)
+        if abs(x_n - x_n1) < 10**-5:
+            return x_n1
+        x_n = x_n1
+
+
 def f(x):
-    return (x**3) - (2 * x) -5
+    return (x**3) - (2 * x) - 5
+
 
 def f1(x):
-    return 3 * (x**2) -2
+    return 3 * (x**2) - 2
+
 
 if __name__ == "__main__":
-    print(newton(f,f1,3))
+    print(newton(f, f1, 3))
diff --git a/maths/Hanoi.py b/maths/Hanoi.py
index dd04d0fa58d8..c7b435a8fe3e 100644
--- a/maths/Hanoi.py
+++ b/maths/Hanoi.py
@@ -1,5 +1,8 @@
+"""Tower of Hanoi."""
+
 # @author willx75
-# Tower of Hanoi recursion game algorithm is a game, it consists of three rods and a number of disks of different sizes, which can slide onto any rod
+# Tower of Hanoi recursion game algorithm is a game, it consists of three rods
+# and a number of disks of different sizes, which can slide onto any rod
 
 import logging
 
@@ -7,18 +10,20 @@
 logging.basicConfig(level=logging.DEBUG)
 
 
-def Tower_Of_Hanoi(n, source, dest, by, mouvement):
+def Tower_Of_Hanoi(n, source, dest, by, movement):
+    """Tower of Hanoi - Move plates to different rods."""
     if n == 0:
         return n
     elif n == 1:
-        mouvement += 1
-        # no print statement (you could make it an optional flag for printing logs)
+        movement += 1
+        # no print statement
+        # (you could make it an optional flag for printing logs)
         logging.debug('Move the plate from', source, 'to', dest)
-        return mouvement
+        return movement
     else:
 
-        mouvement = mouvement + Tower_Of_Hanoi(n-1, source, by, dest, 0)
+        movement = movement + Tower_Of_Hanoi(n - 1, source, by, dest, 0)
         logging.debug('Move the plate from', source, 'to', dest)
 
-        mouvement = mouvement + 1 + Tower_Of_Hanoi(n-1, by, dest, source, 0)
-        return mouvement
+        movement = movement + 1 + Tower_Of_Hanoi(n - 1, by, dest, source, 0)
+        return movement
diff --git a/maths/abs.py b/maths/abs.py
index 6d0596478d5f..624823fc183e 100644
--- a/maths/abs.py
+++ b/maths/abs.py
@@ -1,6 +1,10 @@
+"""Absolute Value."""
+
+
 def absVal(num):
     """
-    Function to fins absolute value of numbers.
+    Find the absolute value of a number.
+
     >>absVal(-5)
     5
     >>absVal(0)
@@ -11,8 +15,11 @@ def absVal(num):
     else:
         return num
 
+
 def main():
-    print(absVal(-34)) # = 34
+    """Print absolute value of -34."""
+    print(absVal(-34))  # = 34
+
 
 if __name__ == '__main__':
     main()
diff --git a/maths/average.py b/maths/average.py
index d15601dd64ca..78387111022d 100644
--- a/maths/average.py
+++ b/maths/average.py
@@ -1,13 +1,20 @@
+"""Find mean of a list of numbers."""
+
+
 def average(nums):
+    """Find mean of a list of numbers."""
     sum = 0
     for x in nums:
-      sum += x
+        sum += x
     avg = sum / len(nums)
     print(avg)
     return avg
 
+
 def main():
-  average([2, 4, 6, 8, 20, 50, 70])
+    """Call average module to find mean of a specific list of numbers."""
+    average([2, 4, 6, 8, 20, 50, 70])
+
 
 if __name__ == '__main__':
-  main()
+    main()
diff --git a/maths/find_lcm.py b/maths/find_lcm.py
index 126242699ab7..779cb128898e 100644
--- a/maths/find_lcm.py
+++ b/maths/find_lcm.py
@@ -1,4 +1,10 @@
+"""Find Least Common Multiple."""
+
+# https://en.wikipedia.org/wiki/Least_common_multiple
+
+
 def find_lcm(num_1, num_2):
+    """Find the LCM of two numbers."""
     max = num_1 if num_1 > num_2 else num_2
     lcm = max
     while (True):
@@ -9,6 +15,7 @@ def find_lcm(num_1, num_2):
 
 
 def main():
+    """Use test numbers to run the find_lcm algorithm."""
     num_1 = 12
     num_2 = 76
     print(find_lcm(num_1, num_2))
diff --git a/sorts/bucket_sort.py b/sorts/bucket_sort.py
index c4d61874fc47..5c4a71513ed3 100644
--- a/sorts/bucket_sort.py
+++ b/sorts/bucket_sort.py
@@ -1,19 +1,26 @@
 #!/usr/bin/env python
+
+"""Illustrate how to implement bucket sort algorithm."""
+
 # Author: OMKAR PATHAK
 # This program will illustrate how to implement bucket sort algorithm
 
-# Wikipedia says: Bucket sort, or bin sort, is a sorting algorithm that works by distributing the
-# elements of an array into a number of buckets. Each bucket is then sorted individually, either using
-# a different sorting algorithm, or by recursively applying the bucket sorting algorithm. It is a
-# distribution sort, and is a cousin of radix sort in the most to least significant digit flavour.
-# Bucket sort is a generalization of pigeonhole sort. Bucket sort can be implemented with comparisons
-# and therefore can also be considered a comparison sort algorithm. The computational complexity estimates
-# involve the number of buckets.
+# Wikipedia says: Bucket sort, or bin sort, is a sorting algorithm that works
+# by distributing the elements of an array into a number of buckets.
+# Each bucket is then sorted individually, either using a different sorting
+# algorithm, or by recursively applying the bucket sorting algorithm. It is a
+# distribution sort, and is a cousin of radix sort in the most to least
+# significant digit flavour.
+# Bucket sort is a generalization of pigeonhole sort. Bucket sort can be
+# implemented with comparisons and therefore can also be considered a
+# comparison sort algorithm. The computational complexity estimates involve the
+# number of buckets.
 
 #  Time Complexity of Solution:
 #  Best Case O(n); Average Case O(n); Worst Case O(n)
 
-DEFAULT_BUCKET_SIZE=5
+DEFAULT_BUCKET_SIZE = 5
+
 
 def bucket_sort(my_list, bucket_size=DEFAULT_BUCKET_SIZE):
     if len(my_list) == 0:
@@ -24,12 +31,14 @@ def bucket_sort(my_list, bucket_size=DEFAULT_BUCKET_SIZE):
     buckets = [[] for _ in range(int(bucket_count))]
 
     for i in range(len(my_list)):
-        buckets[int((my_list[i] - min_value) // bucket_size)].append(my_list[i])
+        buckets[int((my_list[i] - min_value) // bucket_size)
+                ].append(my_list[i])
 
     return sorted([buckets[i][j] for i in range(len(buckets))
-                                 for j in range(len(buckets[i]))])
+                   for j in range(len(buckets[i]))])
+
 
 if __name__ == "__main__":
     user_input = input('Enter numbers separated by a comma:').strip()
     unsorted = [float(n) for n in user_input.split(',') if len(user_input) > 0]
-    print(bucket_sort(unsorted))
\ No newline at end of file
+    print(bucket_sort(unsorted))
diff --git a/sorts/gnome_sort.py b/sorts/gnome_sort.py
index 2927b097f11d..075749e37663 100644
--- a/sorts/gnome_sort.py
+++ b/sorts/gnome_sort.py
@@ -1,29 +1,31 @@
+"""Gnome Sort Algorithm."""
+
 from __future__ import print_function
 
+
 def gnome_sort(unsorted):
-    """
-    Pure implementation of the gnome sort algorithm in Python.
-    """
+    """Pure implementation of the gnome sort algorithm in Python."""
     if len(unsorted) <= 1:
         return unsorted
-        
+
     i = 1
-    
+
     while i < len(unsorted):
-        if unsorted[i-1] <= unsorted[i]:
+        if unsorted[i - 1] <= unsorted[i]:
             i += 1
         else:
-            unsorted[i-1], unsorted[i] = unsorted[i], unsorted[i-1]
+            unsorted[i - 1], unsorted[i] = unsorted[i], unsorted[i - 1]
             i -= 1
             if (i == 0):
                 i = 1
-                
+
+
 if __name__ == '__main__':
     try:
         raw_input          # Python 2
     except NameError:
         raw_input = input  # Python 3
-    
+
     user_input = raw_input('Enter numbers separated by a comma:\n').strip()
     unsorted = [int(item) for item in user_input.split(',')]
     gnome_sort(unsorted)
diff --git a/sorts/tests.py b/sorts/tests.py
index 225763625f51..ec8c8361912f 100644
--- a/sorts/tests.py
+++ b/sorts/tests.py
@@ -1,3 +1,5 @@
+"""Test Sort Algorithms for Errors."""
+
 from bogo_sort import bogo_sort
 from bubble_sort import bubble_sort
 from bucket_sort import bucket_sort
@@ -36,8 +38,8 @@
     TODO:
     - Fix some broken tests in particular cases (as [] for example),
     - Unify the input format: should always be function(input_collection) (no additional args)
-    - Unify the output format: should always be a collection instead of updating input elements
-      and returning None
+    - Unify the output format: should always be a collection instead of
+    updating input elements and returning None
     - Rewrite some algorithms in function format (in case there is no function definition)
 '''
 
@@ -71,4 +73,4 @@
 for function in TEST_FUNCTIONS:
     for case in TEST_CASES:
         result = function(case['input'])
-        assert result  == case['expected'], 'Executed function: {}, {} != {}'.format(function.__name__, result, case['expected'])
+        assert result == case['expected'], 'Executed function: {}, {} != {}'.format(function.__name__, result, case['expected'])
diff --git a/sorts/topological_sort.py b/sorts/topological_sort.py
index db4dd250a119..400cfb4ca270 100644
--- a/sorts/topological_sort.py
+++ b/sorts/topological_sort.py
@@ -1,3 +1,5 @@
+"""Topological Sort."""
+
 from __future__ import print_function
 #     a
 #    / \
@@ -28,6 +30,7 @@ def topological_sort(start, visited, sort):
     # return sort
     return sort
 
+
 if __name__ == '__main__':
     sort = topological_sort('a', [], [])
     print(sort)
diff --git a/sorts/tree_sort.py b/sorts/tree_sort.py
index d06b0de28e56..baa4fc1acc20 100644
--- a/sorts/tree_sort.py
+++ b/sorts/tree_sort.py
@@ -1,14 +1,18 @@
-# Tree_sort algorithm
-# Build a BST and in order traverse.
+"""
+Tree_sort algorithm.
+
+Build a BST and in order traverse.
+"""
+
 
 class node():
     # BST data structure
     def __init__(self, val):
         self.val = val
-        self.left = None 
-        self.right = None 
-    
-    def insert(self,val):
+        self.left = None
+        self.right = None
+
+    def insert(self, val):
         if self.val:
             if val < self.val:
                 if self.left is None:
@@ -23,24 +27,27 @@ def insert(self,val):
         else:
             self.val = val
 
+
 def inorder(root, res):
-    # Recursive travesal 
+    # Recursive travesal
     if root:
-        inorder(root.left,res)
+        inorder(root.left, res)
         res.append(root.val)
-        inorder(root.right,res)
+        inorder(root.right, res)
+
 
 def tree_sort(arr):
     # Build BST
     if len(arr) == 0:
         return arr
     root = node(arr[0])
-    for i in range(1,len(arr)):
+    for i in range(1, len(arr)):
         root.insert(arr[i])
-    # Traverse BST in order. 
+    # Traverse BST in order.
     res = []
-    inorder(root,res)
+    inorder(root, res)
     return res
 
+
 if __name__ == '__main__':
-    print(tree_sort([10,1,3,2,9,14,13]))
+    print(tree_sort([10, 1, 3, 2, 9, 14, 13]))
diff --git a/sorts/wiggle_sort.py b/sorts/wiggle_sort.py
index 0d4f20e3f96b..606feb4d3dd1 100644
--- a/sorts/wiggle_sort.py
+++ b/sorts/wiggle_sort.py
@@ -1,17 +1,24 @@
 """
-Given an unsorted array nums, reorder it such that nums[0] < nums[1] > nums[2] < nums[3]....  
+Wiggle Sort.
+
+Given an unsorted array nums, reorder it such
+that nums[0] < nums[1] > nums[2] < nums[3]....
 For example:
-if input numbers = [3, 5, 2, 1, 6, 4] 
+if input numbers = [3, 5, 2, 1, 6, 4]
 one possible Wiggle Sorted answer is [3, 5, 1, 6, 2, 4].
 """
+
+
 def wiggle_sort(nums):
+    """Perform Wiggle Sort."""
     for i in range(len(nums)):
-        if (i % 2 == 1) == (nums[i-1] > nums[i]):
-            nums[i-1], nums[i] = nums[i], nums[i-1]
+        if (i % 2 == 1) == (nums[i - 1] > nums[i]):
+            nums[i - 1], nums[i] = nums[i], nums[i - 1]
+
 
 if __name__ == '__main__':
     print("Enter the array elements:\n")
-    array=list(map(int,input().split()))
+    array = list(map(int, input().split()))
     print("The unsorted array is:\n")
     print(array)
     wiggle_sort(array)

From a2236cfb97ce96b13c03be9761a3d053997aace9 Mon Sep 17 00:00:00 2001
From: PatOnTheBack <51241310+PatOnTheBack@users.noreply.github.com>
Date: Tue, 2 Jul 2019 00:05:43 -0400
Subject: [PATCH 064/348] Improve Formatting and Code Quality (#934)

* Improved Formatting of basic_maths.py

- Added docstrings.
- Improved whitespace formatting.
- Renamed functions to match snake_case.

* Improved Formatting of factorial_python.py

- Added docstrings.
- Improved whitespace formatting.
- Renamed constants to match UPPER_CASE.

* Improved Formatting of factorial_recursive.py

- Improved whitespace formatting to meet PyLint standards.

* Improved Code to Conform to PyLint

- Renamed `max` to `max_num` to avoid redefining built-in 'max' [pylint]
- Removed unnecessary parens after 'while' keyword [pylint]

* Improved Formatting of factorial_recursive.py

- Added docstrings.
- Improved whitespace formatting.
---
 maths/basic_maths.py         | 66 +++++++++++++++++++++---------------
 maths/factorial_python.py    | 22 ++++++------
 maths/factorial_recursive.py | 17 +++++-----
 maths/find_lcm.py            |  8 ++---
 sorts/pancake_sort.py        | 15 ++++----
 5 files changed, 71 insertions(+), 57 deletions(-)

diff --git a/maths/basic_maths.py b/maths/basic_maths.py
index 6e8c919a001d..cd7bac0113b8 100644
--- a/maths/basic_maths.py
+++ b/maths/basic_maths.py
@@ -1,74 +1,84 @@
+"""Implementation of Basic Math in Python."""
 import math
 
-def primeFactors(n):
+
+def prime_factors(n):
+    """Find Prime Factors."""
     pf = []
     while n % 2 == 0:
         pf.append(2)
         n = int(n / 2)
-        
-    for i in range(3, int(math.sqrt(n))+1, 2):
+
+    for i in range(3, int(math.sqrt(n)) + 1, 2):
         while n % i == 0:
             pf.append(i)
             n = int(n / i)
-    
+
     if n > 2:
         pf.append(n)
-    
+
     return pf
 
-def numberOfDivisors(n):
+
+def number_of_divisors(n):
+    """Calculate Number of Divisors of an Integer."""
     div = 1
-    
+
     temp = 1
     while n % 2 == 0:
         temp += 1
         n = int(n / 2)
-    div = div * (temp) 
-    
-    for i in range(3, int(math.sqrt(n))+1, 2):
+    div = div * (temp)
+
+    for i in range(3, int(math.sqrt(n)) + 1, 2):
         temp = 1
         while n % i == 0:
             temp += 1
             n = int(n / i)
         div = div * (temp)
-    
+
     return div
 
-def sumOfDivisors(n):
+
+def sum_of_divisors(n):
+    """Calculate Sum of Divisors."""
     s = 1
-    
+
     temp = 1
     while n % 2 == 0:
         temp += 1
         n = int(n / 2)
     if temp > 1:
-        s *= (2**temp - 1) / (2 - 1) 
-    
-    for i in range(3, int(math.sqrt(n))+1, 2):
+        s *= (2**temp - 1) / (2 - 1)
+
+    for i in range(3, int(math.sqrt(n)) + 1, 2):
         temp = 1
         while n % i == 0:
             temp += 1
             n = int(n / i)
         if temp > 1:
             s *= (i**temp - 1) / (i - 1)
-    
+
     return s
 
-def eulerPhi(n):
-    l = primeFactors(n)
+
+def euler_phi(n):
+    """Calculte Euler's Phi Function."""
+    l = prime_factors(n)
     l = set(l)
     s = n
     for x in l:
-        s *= (x - 1)/x 
-    return s   
+        s *= (x - 1) / x
+    return s
+
 
 def main():
-    print(primeFactors(100))
-    print(numberOfDivisors(100))
-    print(sumOfDivisors(100))
-    print(eulerPhi(100))
-    
+    """Print the Results of Basic Math Operations."""
+    print(prime_factors(100))
+    print(number_of_divisors(100))
+    print(sum_of_divisors(100))
+    print(euler_phi(100))
+
+
 if __name__ == '__main__':
     main()
-    
-    
\ No newline at end of file
diff --git a/maths/factorial_python.py b/maths/factorial_python.py
index 376983e08dab..6c1349fd5f4c 100644
--- a/maths/factorial_python.py
+++ b/maths/factorial_python.py
@@ -1,19 +1,19 @@
-# Python program to find the factorial of a number provided by the user.
+"""Python program to find the factorial of a number provided by the user."""
 
 # change the value for a different result
-num = 10
+NUM = 10
 
 # uncomment to take input from the user
-#num = int(input("Enter a number: "))
+# num = int(input("Enter a number: "))
 
-factorial = 1
+FACTORIAL = 1
 
 # check if the number is negative, positive or zero
-if num < 0:
-   print("Sorry, factorial does not exist for negative numbers")
-elif num == 0:
-   print("The factorial of 0 is 1")
+if NUM < 0:
+    print("Sorry, factorial does not exist for negative numbers")
+elif NUM == 0:
+    print("The factorial of 0 is 1")
 else:
-   for i in range(1,num + 1):
-       factorial = factorial*i
-   print("The factorial of",num,"is",factorial)
+    for i in range(1, NUM + 1):
+        FACTORIAL = FACTORIAL * i
+    print("The factorial of", NUM, "is", FACTORIAL)
diff --git a/maths/factorial_recursive.py b/maths/factorial_recursive.py
index 41391a2718f6..06173dcbcd7d 100644
--- a/maths/factorial_recursive.py
+++ b/maths/factorial_recursive.py
@@ -1,13 +1,14 @@
 def fact(n):
-	"""
-	Return 1, if n is 1 or below,
-	otherwise, return n * fact(n-1).
-	"""
-	return 1 if n <= 1 else n * fact(n-1)
+    """
+    Return 1, if n is 1 or below,
+    otherwise, return n * fact(n-1).
+    """
+    return 1 if n <= 1 else n * fact(n - 1)
+
 
 """
-Shown factorial for i,
+Show factorial for i,
 where i ranges from 1 to 20.
 """
-for i in range(1,21):
-	print(i, ": ", fact(i), sep='')
+for i in range(1, 21):
+    print(i, ": ", fact(i), sep='')
diff --git a/maths/find_lcm.py b/maths/find_lcm.py
index 779cb128898e..9062d462b8b3 100644
--- a/maths/find_lcm.py
+++ b/maths/find_lcm.py
@@ -5,12 +5,12 @@
 
 def find_lcm(num_1, num_2):
     """Find the LCM of two numbers."""
-    max = num_1 if num_1 > num_2 else num_2
-    lcm = max
-    while (True):
+    max_num = num_1 if num_1 > num_2 else num_2
+    lcm = max_num
+    while True:
         if ((lcm % num_1 == 0) and (lcm % num_2 == 0)):
             break
-        lcm += max
+        lcm += max_num
     return lcm
 
 
diff --git a/sorts/pancake_sort.py b/sorts/pancake_sort.py
index 478a9a967d27..3b48bc6e46d9 100644
--- a/sorts/pancake_sort.py
+++ b/sorts/pancake_sort.py
@@ -1,17 +1,20 @@
-# Pancake sort algorithm 
+"""Pancake Sort Algorithm."""
 # Only can reverse array from 0 to i
 
+
 def pancake_sort(arr):
+    """Sort Array with Pancake Sort."""
     cur = len(arr)
     while cur > 1:
         # Find the maximum number in arr
         mi = arr.index(max(arr[0:cur]))
-        # Reverse from 0 to mi 
-        arr = arr[mi::-1] + arr[mi+1:len(arr)]
-        # Reverse whole list 
-        arr = arr[cur-1::-1] + arr[cur:len(arr)]
+        # Reverse from 0 to mi
+        arr = arr[mi::-1] + arr[mi + 1:len(arr)]
+        # Reverse whole list
+        arr = arr[cur - 1::-1] + arr[cur:len(arr)]
         cur -= 1
     return arr
 
+
 if __name__ == '__main__':
-    print(pancake_sort([0,10,15,3,2,9,14,13]))
+    print(pancake_sort([0, 10, 15, 3, 2, 9, 14, 13]))

From 27a8184ccf871a3afa22839761bf507306c52d58 Mon Sep 17 00:00:00 2001
From: Dharni0607 <30770547+Dharni0607@users.noreply.github.com>
Date: Tue, 2 Jul 2019 17:49:31 +0530
Subject: [PATCH 065/348] add ons in string directory - Bayer_Moore_Search
 (#933)

---
 strings/Boyer_Moore_Search.py | 88 +++++++++++++++++++++++++++++++++++
 1 file changed, 88 insertions(+)
 create mode 100644 strings/Boyer_Moore_Search.py

diff --git a/strings/Boyer_Moore_Search.py b/strings/Boyer_Moore_Search.py
new file mode 100644
index 000000000000..781ff0ca6106
--- /dev/null
+++ b/strings/Boyer_Moore_Search.py
@@ -0,0 +1,88 @@
+"""
+The algorithm finds the pattern in given text using following rule.
+
+The bad-character rule considers the mismatched character in Text. 
+The next occurrence of that character to the left in Pattern is found, 
+
+If the mismatched character occurs to the left in Pattern, 
+a shift is proposed that aligns text block and pattern. 
+
+If the mismatched character does not occur to the left in Pattern, 
+a shift is proposed that moves the entirety of Pattern past 
+the point of mismatch in the text. 
+
+If there no mismatch then the pattern matches with text block.
+
+Time Complexity : O(n/m)
+    n=length of main string
+    m=length of pattern string
+"""
+
+
+class BoyerMooreSearch:
+
+
+    def __init__(self, text, pattern):
+        self.text, self.pattern = text, pattern
+        self.textLen, self.patLen = len(text), len(pattern)
+    
+
+    def match_in_pattern(self, char):
+        """ finds the index of char in pattern in reverse order
+
+        Paremeters : 
+            char (chr): character to be searched
+        
+        Returns :
+            i (int): index of char from last in pattern
+            -1 (int): if char is not found in pattern 
+        """ 
+
+        for i in range(self.patLen-1, -1, -1):
+            if char == self.pattern[i]:
+                return i
+        return -1
+
+
+    def mismatch_in_text(self, currentPos):
+        """ finds the index of mis-matched character in text when compared with pattern from last
+
+        Paremeters : 
+            currentPos (int): current index position of text
+        
+        Returns :
+            i (int): index of mismatched char from last in text
+            -1 (int): if there is no mis-match between pattern and text block
+        """
+
+        for i in range(self.patLen-1, -1, -1):
+            if self.pattern[i] != self.text[currentPos + i]:
+                return currentPos + i
+        return -1
+
+        
+    def bad_character_heuristic(self):
+        # searches pattern in text and returns index positions 
+        positions = []
+        for i in range(self.textLen - self.patLen + 1):
+            mismatch_index = self.mismatch_in_text(i)
+            if mismatch_index == -1:
+                positions.append(i)
+            else:
+                match_index = self.match_in_pattern(self.text[mismatch_index])
+                i = mismatch_index - match_index   #shifting index
+        return positions
+
+ 
+text = "ABAABA"
+pattern = "AB" 
+bms = BoyerMooreSearch(text, pattern)
+positions = bms.bad_character_heuristic()
+
+if len(positions) == 0:
+    print("No match found")
+else:
+    print("Pattern found in following positions: ")
+    print(positions)
+    
+

From 0f56ab5c3cfe50505d12e48493b0f043d1a6fc7a Mon Sep 17 00:00:00 2001
From: Dharni0607 <30770547+Dharni0607@users.noreply.github.com>
Date: Tue, 2 Jul 2019 17:50:25 +0530
Subject: [PATCH 066/348] Divide and conquer Algorithms Issue#817 (#938)

* add ons in string directory - Bayer_Moore_Search

* created divide_and_conquer folder and added max_sub_array_sum.py under it (issue #817)
---
 divide_and_conquer/max_sub_array_sum.py | 72 +++++++++++++++++++++++++
 1 file changed, 72 insertions(+)
 create mode 100644 divide_and_conquer/max_sub_array_sum.py

diff --git a/divide_and_conquer/max_sub_array_sum.py b/divide_and_conquer/max_sub_array_sum.py
new file mode 100644
index 000000000000..531a45abca6f
--- /dev/null
+++ b/divide_and_conquer/max_sub_array_sum.py
@@ -0,0 +1,72 @@
+""" 
+Given a array of length n, max_sub_array_sum() finds the maximum of sum of contiguous sub-array using divide and conquer method.
+
+Time complexity : O(n log n)
+
+Ref : INTRODUCTION TO ALGORITHMS THIRD EDITION (section : 4, sub-section : 4.1, page : 70)
+
+"""
+
+
+def max_sum_from_start(array):
+    """ This function finds the maximum contiguous sum of array from 0 index
+
+    Parameters : 
+    array (list[int]) : given array
+    
+    Returns : 
+    max_sum (int) : maximum contiguous sum of array from 0 index
+
+    """
+    array_sum = 0
+    max_sum = float("-inf")
+    for num in array:
+        array_sum += num
+        if array_sum > max_sum:
+            max_sum = array_sum
+    return max_sum
+
+
+def max_cross_array_sum(array, left, mid, right):
+    """ This function finds the maximum contiguous sum of left and right arrays
+
+    Parameters : 
+    array, left, mid, right (list[int], int, int, int) 
+    
+    Returns : 
+    (int) :  maximum of sum of contiguous sum of left and right arrays
+
+    """
+
+    max_sum_of_left = max_sum_from_start(array[left:mid+1][::-1])
+    max_sum_of_right = max_sum_from_start(array[mid+1: right+1])
+    return max_sum_of_left + max_sum_of_right
+
+
+def max_sub_array_sum(array, left, right):
+    """ This function finds the maximum of sum of contiguous sub-array using divide and conquer method
+
+    Parameters : 
+    array, left, right (list[int], int, int) : given array, current left index and current right index
+    
+    Returns : 
+    int :  maximum of sum of contiguous sub-array
+
+    """
+
+    # base case: array has only one element
+    if left == right:
+        return array[right]
+    
+    # Recursion
+    mid = (left + right) // 2
+    left_half_sum = max_sub_array_sum(array, left, mid)
+    right_half_sum = max_sub_array_sum(array, mid + 1, right)
+    cross_sum = max_cross_array_sum(array, left, mid, right)
+    return max(left_half_sum, right_half_sum, cross_sum)
+
+
+array = [-2, -5, 6, -2, -3, 1, 5, -6]
+array_length = len(array)
+print("Maximum sum of contiguous subarray:", max_sub_array_sum(array, 0, array_length - 1))
+

From 65a12fa317935e04ed0e747db234fe4601e96084 Mon Sep 17 00:00:00 2001
From: Jigyasa G <33327397+jpg-130@users.noreply.github.com>
Date: Tue, 2 Jul 2019 20:53:35 +0530
Subject: [PATCH 067/348] Adding sum of subsets (#929)

---
 dynamic_programming/sum_of_subset.py | 34 ++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 dynamic_programming/sum_of_subset.py

diff --git a/dynamic_programming/sum_of_subset.py b/dynamic_programming/sum_of_subset.py
new file mode 100644
index 000000000000..f6509a259c5d
--- /dev/null
+++ b/dynamic_programming/sum_of_subset.py
@@ -0,0 +1,34 @@
+def isSumSubset(arr, arrLen, requiredSum):
+
+    # a subset value says 1 if that subset sum can be formed else 0
+    #initially no subsets can be formed hence False/0
+    subset = ([[False for i in range(requiredSum + 1)] for i in range(arrLen + 1)])
+
+    #for each arr value, a sum of zero(0) can be formed by not taking any element hence True/1
+    for i in range(arrLen + 1):
+        subset[i][0] = True
+
+    #sum is not zero and set is empty then false
+    for i in range(1, requiredSum + 1):
+        subset[0][i] = False
+
+    for i in range(1, arrLen + 1):
+        for j in range(1, requiredSum + 1):
+            if arr[i-1]>j:
+                subset[i][j] = subset[i-1][j]
+            if arr[i-1]<=j:
+                subset[i][j] = (subset[i-1][j] or subset[i-1][j-arr[i-1]])
+
+    #uncomment to print the subset
+    # for i in range(arrLen+1):
+    #     print(subset[i])
+
+    return subset[arrLen][requiredSum]
+
+arr = [2, 4, 6, 8]
+requiredSum =  5
+arrLen = len(arr)
+if isSumSubset(arr, arrLen, requiredSum):
+    print("Found a subset with required sum")
+else:
+    print("No subset with required sum")
\ No newline at end of file

From 4fb4cb4fd1023e742ba7c06bce70e042294cd157 Mon Sep 17 00:00:00 2001
From: cclauss <cclauss@me.com>
Date: Wed, 3 Jul 2019 09:21:03 +0200
Subject: [PATCH 068/348] Travis CI: Simplify the testing (#887)

* Travis CI: Simplify the testing

* flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics

* python: 3.7

* dist: xenial for python: 3.7

* Delete .lgtm.yml

These changes were created to get around the fact that Travis CI was not enabled on this repo.  Now that Travis is enabled, we can remove these modifications.

The problems are that:
1. [LGTM does not want us running flake8 on their infrstructure](https://discuss.lgtm.com/t/can-i-get-lgtm-to-run-flake8-tests/1445/6) and
2. when we do, it [does not work as expected](https://discuss.lgtm.com/t/tests-are-not-automatically-run-when-lgtm-yml-is-modified/1446/4).
---
 .lgtm.yml   | 12 ------------
 .travis.yml | 29 ++++-------------------------
 2 files changed, 4 insertions(+), 37 deletions(-)
 delete mode 100644 .lgtm.yml

diff --git a/.lgtm.yml b/.lgtm.yml
deleted file mode 100644
index ec550ab72705..000000000000
--- a/.lgtm.yml
+++ /dev/null
@@ -1,12 +0,0 @@
-extraction:
-  python:
-    python_setup:
-      version: 3
-    after_prepare:
-      - python3 -m pip install --upgrade --user flake8
-    before_index:
-      - python3 -m flake8 --version  # flake8 3.6.0 on CPython 3.6.5 on Linux
-      # stop the build if there are Python syntax errors or undefined names
-      - python3 -m flake8 . --count --select=E901,E999,F821,F822,F823 --show-source --statistics
-      # exit-zero treats all errors as warnings.  The GitHub editor is 127 chars wide
-      - python3 -m flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
diff --git a/.travis.yml b/.travis.yml
index 2440899e4f25..8676e5127334 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,26 +1,5 @@
 language: python
-cache: pip
-python:
-    - 2.7
-    - 3.6
-    #- nightly
-    #- pypy
-    #- pypy3
-matrix:
-    allow_failures:
-        - python: nightly
-        - python: pypy
-        - python: pypy3
-install:
-    #- pip install -r requirements.txt
-    - pip install flake8  # pytest  # add another testing frameworks later
-before_script:
-    # stop the build if there are Python syntax errors or undefined names
-    - flake8 . --count --select=E9,F63,F72,F82 --show-source --statistics
-    # exit-zero treats all errors as warnings.  The GitHub editor is 127 chars wide
-    - flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
-script:
-    - true  # pytest --capture=sys  # add other tests here
-notifications:
-    on_success: change
-    on_failure: change  # `always` will be the setting once code changes slow down
+dist: xenial  # required for Python >= 3.7
+python: 3.7
+install: pip install flake8
+script: flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics

From 03f994077557e67493f41ba4c3f7aca08da000d4 Mon Sep 17 00:00:00 2001
From: Ashok Bakthavathsalam <kgashok@users.noreply.github.com>
Date: Wed, 3 Jul 2019 21:01:10 +0530
Subject: [PATCH 069/348] Refactored to one pop() (#917)

---
 sorts/merge_sort.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/sorts/merge_sort.py b/sorts/merge_sort.py
index ecbad7075119..714861e72642 100644
--- a/sorts/merge_sort.py
+++ b/sorts/merge_sort.py
@@ -37,7 +37,7 @@ def merge(left, right):
         '''
         result = []
         while left and right:
-            result.append(left.pop(0) if left[0] <= right[0] else right.pop(0))
+            result.append((left if left[0] <= right[0] else right).pop(0))
         return result + left + right
     if len(collection) <= 1:
         return collection
@@ -53,4 +53,4 @@ def merge(left, right):
 
     user_input = raw_input('Enter numbers separated by a comma:\n').strip()
     unsorted = [int(item) for item in user_input.split(',')]
-    print(*merge_sort(unsorted), sep=',')
\ No newline at end of file
+    print(*merge_sort(unsorted), sep=',')

From 035457f569dc79e8b7b6d3a493895c67182d3539 Mon Sep 17 00:00:00 2001
From: Dharni0607 <30770547+Dharni0607@users.noreply.github.com>
Date: Thu, 4 Jul 2019 13:19:14 +0530
Subject: [PATCH 070/348] closest pair of points algo (#943)

* created divide_and_conquer folder and added max_sub_array_sum.py under it (issue #817)

* additional file in divide_and_conqure (closest pair of points)
---
 divide_and_conquer/closest_pair_of_points.py | 113 +++++++++++++++++++
 divide_and_conquer/max_subarray_sum.py       |  75 ++++++++++++
 2 files changed, 188 insertions(+)
 create mode 100644 divide_and_conquer/closest_pair_of_points.py
 create mode 100644 divide_and_conquer/max_subarray_sum.py

diff --git a/divide_and_conquer/closest_pair_of_points.py b/divide_and_conquer/closest_pair_of_points.py
new file mode 100644
index 000000000000..cc5be428db79
--- /dev/null
+++ b/divide_and_conquer/closest_pair_of_points.py
@@ -0,0 +1,113 @@
+"""
+The algorithm finds distance btw closest pair of points in the given n points.
+Approach used -> Divide and conquer 
+The points are sorted based on Xco-ords 
+& by applying divide and conquer approach, 
+minimum distance is obtained recursively.
+
+>> closest points lie on different sides of partition
+This case handled by forming a strip of points 
+whose Xco-ords distance is less than closest_pair_dis
+from mid-point's Xco-ords.
+Closest pair distance is found in the strip of points. (closest_in_strip)
+
+min(closest_pair_dis, closest_in_strip) would be the final answer.
+ 
+Time complexity: O(n * (logn)^2)
+"""
+
+
+import math 
+
+
+def euclidean_distance_sqr(point1, point2):
+    return pow(point1[0] - point2[0], 2) + pow(point1[1] - point2[1], 2)
+
+
+def column_based_sort(array, column = 0):
+    return sorted(array, key = lambda x: x[column])
+    
+
+def dis_between_closest_pair(points, points_counts, min_dis = float("inf")):
+    """ brute force approach to find distance between closest pair points
+
+    Parameters : 
+    points, points_count, min_dis (list(tuple(int, int)), int, int) 
+    
+    Returns : 
+    min_dis (float):  distance between closest pair of points
+
+    """
+
+    for i in range(points_counts - 1):
+        for j in range(i+1, points_counts):
+            current_dis = euclidean_distance_sqr(points[i], points[j])
+            if current_dis < min_dis:
+                min_dis = current_dis
+    return min_dis
+
+
+def dis_between_closest_in_strip(points, points_counts, min_dis = float("inf")):
+    """ closest pair of points in strip
+
+    Parameters : 
+    points, points_count, min_dis (list(tuple(int, int)), int, int) 
+    
+    Returns : 
+    min_dis (float):  distance btw closest pair of points in the strip (< min_dis)
+
+    """
+
+    for i in range(min(6, points_counts - 1), points_counts):
+        for j in range(max(0, i-6), i):
+            current_dis = euclidean_distance_sqr(points[i], points[j])
+            if current_dis < min_dis:
+                min_dis = current_dis
+    return min_dis
+
+
+def closest_pair_of_points_sqr(points, points_counts):
+    """ divide and conquer approach
+
+    Parameters : 
+    points, points_count (list(tuple(int, int)), int) 
+    
+    Returns : 
+    (float):  distance btw closest pair of points 
+
+    """
+
+    # base case
+    if points_counts <= 3:
+        return dis_between_closest_pair(points, points_counts)
+    
+    # recursion
+    mid = points_counts//2
+    closest_in_left = closest_pair_of_points(points[:mid], mid)
+    closest_in_right = closest_pair_of_points(points[mid:], points_counts - mid)
+    closest_pair_dis = min(closest_in_left, closest_in_right)
+    
+    """ cross_strip contains the points, whose Xcoords are at a 
+    distance(< closest_pair_dis) from mid's Xcoord
+    """
+
+    cross_strip = []
+    for point in points:
+        if abs(point[0] - points[mid][0]) < closest_pair_dis:
+            cross_strip.append(point)
+
+    cross_strip = column_based_sort(cross_strip, 1)
+    closest_in_strip = dis_between_closest_in_strip(cross_strip, 
+                     len(cross_strip), closest_pair_dis)
+    return min(closest_pair_dis, closest_in_strip)
+
+    
+def closest_pair_of_points(points, points_counts):
+    return math.sqrt(closest_pair_of_points_sqr(points, points_counts))
+
+
+points = [(2, 3), (12, 30), (40, 50), (5, 1), (12, 10), (0, 2), (5, 6), (1, 2)]
+points = column_based_sort(points)
+print("Distance:", closest_pair_of_points(points, len(points)))
+
+
diff --git a/divide_and_conquer/max_subarray_sum.py b/divide_and_conquer/max_subarray_sum.py
new file mode 100644
index 000000000000..0428f4e13768
--- /dev/null
+++ b/divide_and_conquer/max_subarray_sum.py
@@ -0,0 +1,75 @@
+""" 
+Given a array of length n, max_subarray_sum() finds 
+the maximum of sum of contiguous sub-array using divide and conquer method.
+
+Time complexity : O(n log n)
+
+Ref : INTRODUCTION TO ALGORITHMS THIRD EDITION 
+(section : 4, sub-section : 4.1, page : 70)
+
+"""
+
+
+def max_sum_from_start(array):
+    """ This function finds the maximum contiguous sum of array from 0 index
+
+    Parameters : 
+    array (list[int]) : given array
+    
+    Returns : 
+    max_sum (int) : maximum contiguous sum of array from 0 index
+
+    """
+    array_sum = 0
+    max_sum = float("-inf")
+    for num in array:
+        array_sum += num
+        if array_sum > max_sum:
+            max_sum = array_sum
+    return max_sum
+
+
+def max_cross_array_sum(array, left, mid, right):
+    """ This function finds the maximum contiguous sum of left and right arrays
+
+    Parameters : 
+    array, left, mid, right (list[int], int, int, int) 
+    
+    Returns : 
+    (int) :  maximum of sum of contiguous sum of left and right arrays
+
+    """
+
+    max_sum_of_left = max_sum_from_start(array[left:mid+1][::-1])
+    max_sum_of_right = max_sum_from_start(array[mid+1: right+1])
+    return max_sum_of_left + max_sum_of_right
+
+
+def max_subarray_sum(array, left, right):
+    """ Maximum contiguous sub-array sum, using divide and conquer method
+
+    Parameters : 
+    array, left, right (list[int], int, int) : 
+    given array, current left index and current right index
+    
+    Returns : 
+    int :  maximum of sum of contiguous sub-array
+
+    """
+
+    # base case: array has only one element
+    if left == right:
+        return array[right]
+    
+    # Recursion
+    mid = (left + right) // 2
+    left_half_sum = max_subarray_sum(array, left, mid)
+    right_half_sum = max_subarray_sum(array, mid + 1, right)
+    cross_sum = max_cross_array_sum(array, left, mid, right)
+    return max(left_half_sum, right_half_sum, cross_sum)
+
+
+array = [-2, -5, 6, -2, -3, 1, 5, -6]
+array_length = len(array)
+print("Maximum sum of contiguous subarray:", max_subarray_sum(array, 0, array_length - 1))
+

From 05fc7f8a33df7d08dba1f162d7618f4e353b534f Mon Sep 17 00:00:00 2001
From: Hector S <hfsam88@gmail.com>
Date: Thu, 4 Jul 2019 11:18:57 -0400
Subject: [PATCH 071/348] Added '~script.py' to ignore files and updated
 DIRECTORY.md (#926)

* Added print function into matrix_multiplication_addition.py and removed blank space in data_structures/binary tree directory

* Removed .vs/ folder per #893

* Rename matrix_multiplication_addition.py to matrix_operation.py

* Added '~script.py' to ignore files and updated DIRECTORY.md
---
 DIRECTORY.md | 22 ++++++++++++----------
 ~script.py   |  2 +-
 2 files changed, 13 insertions(+), 11 deletions(-)

diff --git a/DIRECTORY.md b/DIRECTORY.md
index ad25772b56b6..befd634c1eb0 100644
--- a/DIRECTORY.md
+++ b/DIRECTORY.md
@@ -1,6 +1,3 @@
-## Analysis
-  * Compression Analysis
-    * [psnr](https://github.com/TheAlgorithms/Python/blob/master/analysis/compression_analysis/psnr.py)
 ## Arithmetic Analysis
   * [bisection](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/bisection.py)
   * [intersection](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/intersection.py)
@@ -39,17 +36,19 @@
   * [xor cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/xor_cipher.py)
 ## Compression
   * [huffman](https://github.com/TheAlgorithms/Python/blob/master/compression/huffman.py)
+## Compression Analysis
+  * [psnr](https://github.com/TheAlgorithms/Python/blob/master/compression_analysis/psnr.py)
 ## Data Structures
   * [arrays](https://github.com/TheAlgorithms/Python/blob/master/data_structures/arrays.py)
   * [avl](https://github.com/TheAlgorithms/Python/blob/master/data_structures/avl.py)
   * [LCA](https://github.com/TheAlgorithms/Python/blob/master/data_structures/LCA.py)
   * Binary Tree
-    * [AVL tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary%20tree/AVL_tree.py)
-    * [binary search tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary%20tree/binary_search_tree.py)
-    * [fenwick tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary%20tree/fenwick_tree.py)
-    * [lazy segment tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary%20tree/lazy_segment_tree.py)
-    * [segment tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary%20tree/segment_tree.py)
-    * [treap](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary%20tree/treap.py)
+    * [AVL tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/AVL_tree.py)
+    * [binary search tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/binary_search_tree.py)
+    * [fenwick tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/fenwick_tree.py)
+    * [lazy segment tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/lazy_segment_tree.py)
+    * [segment tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/segment_tree.py)
+    * [treap](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/treap.py)
   * Hashing
     * [double hash](https://github.com/TheAlgorithms/Python/blob/master/data_structures/hashing/double_hash.py)
     * [hash table](https://github.com/TheAlgorithms/Python/blob/master/data_structures/hashing/hash_table.py)
@@ -192,8 +191,9 @@
   * Tests
     * [test fibonacci](https://github.com/TheAlgorithms/Python/blob/master/maths/tests/test_fibonacci.py)
 ## Matrix
-  * [matrix multiplication addition](https://github.com/TheAlgorithms/Python/blob/master/matrix/matrix_multiplication_addition.py)
+  * [matrix operation](https://github.com/TheAlgorithms/Python/blob/master/matrix/matrix_operation.py)
   * [searching in sorted matrix](https://github.com/TheAlgorithms/Python/blob/master/matrix/searching_in_sorted_matrix.py)
+  * [spiralPrint](https://github.com/TheAlgorithms/Python/blob/master/matrix/spiralPrint.py)
 ## Networking Flow
   * [ford fulkerson](https://github.com/TheAlgorithms/Python/blob/master/networking_flow/ford_fulkerson.py)
   * [minimum cut](https://github.com/TheAlgorithms/Python/blob/master/networking_flow/minimum_cut.py)
@@ -294,6 +294,8 @@
     * [p022 names](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_22/p022_names.txt)
     * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_22/sol1.py)
     * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_22/sol2.py)
+  * Problem 234
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_234/sol1.py)
   * Problem 24
     * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_24/sol1.py)
   * Problem 25
diff --git a/~script.py b/~script.py
index 4a2c61c83563..c44f3436fcec 100644
--- a/~script.py
+++ b/~script.py
@@ -52,7 +52,7 @@ def _markdown(parent, ignores, ignores_ext, depth):
 ignores = [".vs",
     ".gitignore",
     ".git",
-    "script.py",
+    "~script.py",
     "__init__.py",
 ]
 # Files with given entensions will be ignored

From 408c5deb3adb0f128f51d3d72e7664f5b864e9b7 Mon Sep 17 00:00:00 2001
From: Shoujue Xu <lightxusj@126.com>
Date: Fri, 5 Jul 2019 16:20:11 +0800
Subject: [PATCH 072/348] add gaussian filter algorithm and lena.jpg (#955)

---
 .../filters/gaussian_filter.py                |  53 ++++++++++++++++++
 .../filters/median_filter.py                  |   2 +-
 digital_image_processing/image_data/lena.jpg  | Bin 0 -> 104428 bytes
 3 files changed, 54 insertions(+), 1 deletion(-)
 create mode 100644 digital_image_processing/filters/gaussian_filter.py
 create mode 100644 digital_image_processing/image_data/lena.jpg

diff --git a/digital_image_processing/filters/gaussian_filter.py b/digital_image_processing/filters/gaussian_filter.py
new file mode 100644
index 000000000000..ff85ce047220
--- /dev/null
+++ b/digital_image_processing/filters/gaussian_filter.py
@@ -0,0 +1,53 @@
+"""
+Implementation of gaussian filter algorithm
+"""
+from cv2 import imread, cvtColor, COLOR_BGR2GRAY, imshow, waitKey
+from numpy import pi, mgrid, exp, square, zeros, ravel, dot, uint8
+
+
+def gen_gaussian_kernel(k_size, sigma):
+    center = k_size // 2
+    x, y = mgrid[0-center:k_size-center, 0-center:k_size-center]
+    g = 1/(2*pi*sigma) * exp(-(square(x) + square(y))/(2*square(sigma)))
+    return g
+
+
+def gaussian_filter(image, k_size, sigma):
+    height, width = image.shape[0], image.shape[1]
+    # dst image height and width
+    dst_height = height-k_size+1
+    dst_width = width-k_size+1
+
+    # im2col, turn the k_size*k_size pixels into a row and np.vstack all rows
+    image_array = zeros((dst_height*dst_width, k_size*k_size))
+    row = 0
+    for i in range(0, dst_height):
+        for j in range(0, dst_width):
+            window = ravel(image[i:i + k_size, j:j + k_size])
+            image_array[row, :] = window
+            row += 1
+
+    #  turn the kernel into shape(k*k, 1)
+    gaussian_kernel = gen_gaussian_kernel(k_size, sigma)
+    filter_array = ravel(gaussian_kernel)
+
+    # reshape and get the dst image
+    dst = dot(image_array, filter_array).reshape(dst_height, dst_width).astype(uint8)
+
+    return dst
+
+
+if __name__ == '__main__':
+    # read original image
+    img = imread(r'../image_data/lena.jpg')
+    # turn image in gray scale value
+    gray = cvtColor(img, COLOR_BGR2GRAY)
+
+    # get values with two different mask size
+    gaussian3x3 = gaussian_filter(gray, 3, sigma=1)
+    gaussian5x5 = gaussian_filter(gray, 5, sigma=0.8)
+
+    # show result images
+    imshow('gaussian filter with 3x3 mask', gaussian3x3)
+    imshow('gaussian filter with 5x5 mask', gaussian5x5)
+    waitKey()
diff --git a/digital_image_processing/filters/median_filter.py b/digital_image_processing/filters/median_filter.py
index eea4295632a1..ed20b1ab7f78 100644
--- a/digital_image_processing/filters/median_filter.py
+++ b/digital_image_processing/filters/median_filter.py
@@ -28,7 +28,7 @@ def median_filter(gray_img, mask=3):
 
 if __name__ == '__main__':
     # read original image
-    img = imread('lena.jpg')
+    img = imread('../image_data/lena.jpg')
     # turn image in gray scale value
     gray = cvtColor(img, COLOR_BGR2GRAY)
 
diff --git a/digital_image_processing/image_data/lena.jpg b/digital_image_processing/image_data/lena.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..15c4d9764effe5ad9d84dc0e4af553788f80dc73
GIT binary patch
literal 104428
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

literal 0
HcmV?d00001


From 217615abf68592e69725bbb4ef8d86713e9be1ce Mon Sep 17 00:00:00 2001
From: PatOnTheBack <51241310+PatOnTheBack@users.noreply.github.com>
Date: Fri, 5 Jul 2019 04:34:46 -0400
Subject: [PATCH 073/348] Removed Unused Variables (#949)

- Removed two unused variables.
- Changed `a` to `_` since the `a` variable is never used.

This addresses [3 alerts from lgtm](https://lgtm.com/projects/g/TheAlgorithms/Python/snapshot/d55bbcd204dfbd436914a5f9031a6a8fdf22f6f4/files/sorts/Odd-Even_transposition_parallel.py?sort=name&dir=ASC&mode=heatmap).
---
 sorts/Odd-Even_transposition_parallel.py | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/sorts/Odd-Even_transposition_parallel.py b/sorts/Odd-Even_transposition_parallel.py
index d7f983fc0469..9bf81a39e27a 100644
--- a/sorts/Odd-Even_transposition_parallel.py
+++ b/sorts/Odd-Even_transposition_parallel.py
@@ -70,13 +70,11 @@ def oeProcess(position, value, LSend, RSend, LRcv, RRcv, resultPipe):
 def OddEvenTransposition(arr):
 
     processArray = []
-    tempRrcv = None
-    tempLrcv = None
 
     resultPipe = []
 
     #initialize the list of pipes where the values will be retrieved
-    for a in arr:
+    for _ in arr:
         resultPipe.append(Pipe())
 
     #creates the processes

From 1c9d995b9eb05f439fee5892210af3ab659f9760 Mon Sep 17 00:00:00 2001
From: PatOnTheBack <51241310+PatOnTheBack@users.noreply.github.com>
Date: Fri, 5 Jul 2019 04:36:48 -0400
Subject: [PATCH 074/348] Implement Three New Algorithms (#948)

* Create average_median.py

I created a program to calculate the median of a list of numbers.

* Changed Odd to Even in String

* Create decimal_to_binary.py

- Added 'conversions' folder.
- Created a decimal to binary converter.

* Implemented Decimal to Octal Algorithm

- I created a decimal to octal converter based on the converter in the TheAlgorithms/Python project.
- I added two newlines to make the output of decimal_to_binary.py better.
---
 conversions/decimal_to_binary.py | 25 +++++++++++++++++++
 conversions/decimal_to_octal.py  | 38 +++++++++++++++++++++++++++++
 maths/average_median.py          | 41 ++++++++++++++++++++++++++++++++
 3 files changed, 104 insertions(+)
 create mode 100644 conversions/decimal_to_binary.py
 create mode 100644 conversions/decimal_to_octal.py
 create mode 100644 maths/average_median.py

diff --git a/conversions/decimal_to_binary.py b/conversions/decimal_to_binary.py
new file mode 100644
index 000000000000..43ceee61a388
--- /dev/null
+++ b/conversions/decimal_to_binary.py
@@ -0,0 +1,25 @@
+"""Convert a Decimal Number to a Binary Number."""
+
+
+def decimal_to_binary(num):
+    """Convert a Decimal Number to a Binary Number."""
+    binary = []
+    while num > 0:
+        binary.insert(0, num % 2)
+        num >>= 1
+    return "".join(str(e) for e in binary)
+
+
+def main():
+    """Print binary equivelents of decimal numbers."""
+    print("\n2 in binary is:")
+    print(decimal_to_binary(2))  # = 10
+    print("\n7 in binary is:")
+    print(decimal_to_binary(7))  # = 111
+    print("\n35 in binary is:")
+    print(decimal_to_binary(35))  # = 100011
+    print("\n")
+
+
+if __name__ == '__main__':
+    main()
diff --git a/conversions/decimal_to_octal.py b/conversions/decimal_to_octal.py
new file mode 100644
index 000000000000..187a0300e33a
--- /dev/null
+++ b/conversions/decimal_to_octal.py
@@ -0,0 +1,38 @@
+"""Convert a Decimal Number to an Octal Number."""
+
+import math
+
+# Modified from:
+# https://github.com/TheAlgorithms/Javascript/blob/master/Conversions/DecimalToOctal.js
+
+
+def decimal_to_octal(num):
+    """Convert a Decimal Number to an Octal Number."""
+    octal = 0
+    counter = 0
+    while num > 0:
+        remainder = num % 8
+        octal = octal + (remainder * math.pow(10, counter))
+        counter += 1
+        num = math.floor(num / 8)  # basically /= 8 without remainder if any
+        # This formatting removes trailing '.0' from `octal`.
+    return'{0:g}'.format(float(octal))
+
+
+def main():
+    """Print octal equivelents of decimal numbers."""
+    print("\n2 in octal is:")
+    print(decimal_to_octal(2))  # = 2
+    print("\n8 in octal is:")
+    print(decimal_to_octal(8))  # = 10
+    print("\n65 in octal is:")
+    print(decimal_to_octal(65))  # = 101
+    print("\n216 in octal is:")
+    print(decimal_to_octal(216))  # = 330
+    print("\n512 in octal is:")
+    print(decimal_to_octal(512))  # = 1000
+    print("\n")
+
+
+if __name__ == '__main__':
+    main()
diff --git a/maths/average_median.py b/maths/average_median.py
new file mode 100644
index 000000000000..565bb4afd112
--- /dev/null
+++ b/maths/average_median.py
@@ -0,0 +1,41 @@
+"""
+Find median of a list of numbers.
+
+Read more about medians:
+    https://en.wikipedia.org/wiki/Median
+"""
+
+
+def median(nums):
+    """Find median of a list of numbers."""
+    # Sort list
+    sorted_list = sorted(nums)
+    print("List of numbers:")
+    print(sorted_list)
+
+    # Is number of items in list even?
+    if len(sorted_list) % 2 == 0:
+        # Find index for first middle value.
+        mid_index_1 = len(sorted_list) / 2
+        # Find index for second middle value.
+        mid_index_2 = -(len(sorted_list) / 2) - 1
+        # Divide middle values by 2 to get average (mean).
+        med = (sorted_list[mid_index_1] + sorted_list[mid_index_2]) / float(2)
+        return med  # Return makes `else:` unnecessary.
+    # Number of items is odd.
+    mid_index = (len(sorted_list) - 1) / 2
+    # Middle index is median.
+    med = sorted_list[mid_index]
+    return med
+
+
+def main():
+    """Call average module to find median of a specific list of numbers."""
+    print("Odd number of numbers:")
+    print(median([2, 4, 6, 8, 20, 50, 70]))
+    print("Even number of numbers:")
+    print(median([2, 4, 6, 8, 20, 50]))
+
+
+if __name__ == '__main__':
+    main()

From 506bb5ccfe97fe5b37faa2bcd9df0fd0fab07ac0 Mon Sep 17 00:00:00 2001
From: Jarred Allen <jarredallen73@gmail.com>
Date: Fri, 5 Jul 2019 01:43:16 -0700
Subject: [PATCH 075/348] Add Red-Black Binary Search Trees (#954)

* Wrote most of an rbt, missing just removal

* Added some convenience methods.

* Added a color method

* Wrote code to delete, but has issues :(

* Fixed a bug in Red-Black trees

* Fixed bug in tree color validation and delete repairing

* Clean up == comparison to None
---
 data_structures/binary_tree/red_black_tree.py | 665 ++++++++++++++++++
 1 file changed, 665 insertions(+)
 create mode 100644 data_structures/binary_tree/red_black_tree.py

diff --git a/data_structures/binary_tree/red_black_tree.py b/data_structures/binary_tree/red_black_tree.py
new file mode 100644
index 000000000000..4ca1301dd8fe
--- /dev/null
+++ b/data_structures/binary_tree/red_black_tree.py
@@ -0,0 +1,665 @@
+class RedBlackTree:
+    """
+    A Red-Black tree, which is a self-balancing BST (binary search
+    tree).
+
+    This tree has similar performance to AVL trees, but the balancing is
+    less strict, so it will perform faster for writing/deleting nodes
+    and slower for reading in the average case, though, because they're
+    both balanced binary search trees, both will get the same asymptotic
+    perfomance.
+
+    To read more about them, https://en.wikipedia.org/wiki/Red–black_tree
+
+    Unless otherwise specified, all asymptotic runtimes are specified in
+    terms of the size of the tree.
+    """
+    def __init__(self, label=None, color=0, parent=None, left=None, right=None):
+        """Initialize a new Red-Black Tree node with the given values:
+            label: The value associated with this node
+            color: 0 if black, 1 if red
+            parent: The parent to this node
+            left: This node's left child
+            right: This node's right child
+        """
+        self.label = label
+        self.parent = parent
+        self.left = left
+        self.right = right
+        self.color = color
+
+    # Here are functions which are specific to red-black trees
+
+    def rotate_left(self):
+        """Rotate the subtree rooted at this node to the left and
+        returns the new root to this subtree.
+
+        Perfoming one rotation can be done in O(1).
+        """
+        parent = self.parent
+        right = self.right
+        self.right = right.left
+        if self.right:
+            self.right.parent = self
+        self.parent = right
+        right.left = self
+        if parent is not None:
+            if parent.left is self:
+                parent.left = right
+            else:
+                parent.right = right
+        right.parent = parent
+        return right
+    
+    def rotate_right(self):
+        """Rotate the subtree rooted at this node to the right and
+        returns the new root to this subtree.
+
+        Performing one rotation can be done in O(1).
+        """
+        parent = self.parent
+        left = self.left
+        self.left = left.right
+        if self.left:
+            self.left.parent = self
+        self.parent = left
+        left.right = self
+        if parent is not None:
+            if parent.right is self:
+                parent.right = left
+            else:
+                parent.left = left
+        left.parent = parent
+        return left
+
+    def insert(self, label):
+        """Inserts label into the subtree rooted at self, performs any
+        rotations necessary to maintain balance, and then returns the
+        new root to this subtree (likely self).
+
+        This is guaranteed to run in O(log(n)) time.
+        """
+        if self.label is None:
+            # Only possible with an empty tree
+            self.label = label
+            return self
+        if self.label == label:
+            return self
+        elif self.label > label:
+            if self.left:
+                self.left.insert(label)
+            else:
+                self.left = RedBlackTree(label, 1, self)
+                self.left._insert_repair()
+        else:
+            if self.right:
+                self.right.insert(label)
+            else:
+                self.right = RedBlackTree(label, 1, self)
+                self.right._insert_repair()
+        return self.parent or self
+
+    def _insert_repair(self):
+        """Repair the coloring from inserting into a tree."""
+        if self.parent is None:
+            # This node is the root, so it just needs to be black
+            self.color = 0
+        elif color(self.parent) == 0:
+            # If the parent is black, then it just needs to be red
+            self.color = 1
+        else:
+            uncle = self.parent.sibling
+            if color(uncle) == 0:
+                if self.is_left() and self.parent.is_right():
+                    self.parent.rotate_right()
+                    self.right._insert_repair()
+                elif self.is_right() and self.parent.is_left():
+                    self.parent.rotate_left()
+                    self.left._insert_repair()
+                elif self.is_left():
+                    self.grandparent.rotate_right()
+                    self.parent.color = 0
+                    self.parent.right.color = 1
+                else:
+                    self.grandparent.rotate_left()
+                    self.parent.color = 0
+                    self.parent.left.color = 1
+            else:
+                self.parent.color = 0
+                uncle.color = 0
+                self.grandparent.color = 1
+                self.grandparent._insert_repair()
+
+    def remove(self, label):
+        """Remove label from this tree."""
+        if self.label == label:
+            if self.left and self.right:
+                # It's easier to balance a node with at most one child,
+                # so we replace this node with the greatest one less than
+                # it and remove that.
+                value = self.left.get_max()
+                self.label = value
+                self.left.remove(value)
+            else:
+                # This node has at most one non-None child, so we don't
+                # need to replace
+                child = self.left or self.right
+                if self.color == 1:
+                    # This node is red, and its child is black
+                    # The only way this happens to a node with one child
+                    # is if both children are None leaves.
+                    # We can just remove this node and call it a day.
+                    if self.is_left():
+                        self.parent.left = None
+                    else:
+                        self.parent.right = None
+                else:
+                    # The node is black
+                    if child is None:
+                        # This node and its child are black
+                        if self.parent is None:
+                            # The tree is now empty
+                            return RedBlackTree(None)
+                        else:
+                            self._remove_repair()
+                            if self.is_left():
+                                self.parent.left = None
+                            else:
+                                self.parent.right = None
+                            self.parent = None
+                    else:
+                        # This node is black and its child is red
+                        # Move the child node here and make it black
+                        self.label = child.label
+                        self.left = child.left
+                        self.right = child.right
+                        if self.left:
+                            self.left.parent = self
+                        if self.right:
+                            self.right.parent = self
+        elif self.label > label:
+            if self.left:
+                self.left.remove(label)
+        else:
+            if self.right:
+                self.right.remove(label)
+        return self.parent or self
+
+    def _remove_repair(self):
+        """Repair the coloring of the tree that may have been messed up."""
+        if color(self.sibling) == 1:
+            self.sibling.color = 0
+            self.parent.color = 1
+            if self.is_left():
+                self.parent.rotate_left()
+            else:
+                self.parent.rotate_right()
+        if color(self.parent) == 0 and color(self.sibling) == 0 \
+                and color(self.sibling.left) == 0 \
+                and color(self.sibling.right) == 0:
+            self.sibling.color = 1
+            self.parent._remove_repair()
+            return
+        if color(self.parent) == 1 and color(self.sibling) == 0 \
+                and color(self.sibling.left) == 0 \
+                and color(self.sibling.right) == 0:
+            self.sibling.color = 1
+            self.parent.color = 0
+            return
+        if (self.is_left() 
+                and color(self.sibling) == 0
+                and color(self.sibling.right) == 0
+                and color(self.sibling.left) == 1):
+            self.sibling.rotate_right()
+            self.sibling.color = 0
+            self.sibling.right.color = 1
+        if (self.is_right()
+                and color(self.sibling) == 0
+                and color(self.sibling.right) == 1
+                and color(self.sibling.left) == 0):
+            self.sibling.rotate_left()
+            self.sibling.color = 0
+            self.sibling.left.color = 1
+        if (self.is_left()
+                and color(self.sibling) == 0
+                and color(self.sibling.right) == 1):
+            self.parent.rotate_left()
+            self.grandparent.color = self.parent.color
+            self.parent.color = 0
+            self.parent.sibling.color = 0
+        if (self.is_right()
+                and color(self.sibling) == 0
+                and color(self.sibling.left) == 1):
+            self.parent.rotate_right()
+            self.grandparent.color = self.parent.color
+            self.parent.color = 0
+            self.parent.sibling.color = 0
+
+    def check_color_properties(self):
+        """Check the coloring of the tree, and return True iff the tree
+        is colored in a way which matches these five properties:
+        (wording stolen from wikipedia article)
+         1. Each node is either red or black.
+         2. The root node is black.
+         3. All leaves are black.
+         4. If a node is red, then both its children are black.
+         5. Every path from any node to all of its descendent NIL nodes
+            has the same number of black nodes.
+
+        This function runs in O(n) time, because properties 4 and 5 take
+        that long to check.
+        """
+        # I assume property 1 to hold because there is nothing that can
+        # make the color be anything other than 0 or 1.
+
+        # Property 2
+        if self.color:
+            # The root was red
+            print('Property 2')
+            return False;
+
+        # Property 3 does not need to be checked, because None is assumed
+        # to be black and is all the leaves.
+
+        # Property 4
+        if not self.check_coloring():
+            print('Property 4')
+            return False
+
+        # Property 5
+        if self.black_height() is None:
+            print('Property 5')
+            return False
+        # All properties were met
+        return True
+
+    def check_coloring(self):
+        """A helper function to recursively check Property 4 of a
+        Red-Black Tree. See check_color_properties for more info.
+        """
+        if self.color == 1:
+            if color(self.left) == 1 or color(self.right) == 1:
+                return False
+        if self.left and not self.left.check_coloring():
+            return False
+        if self.right and not self.right.check_coloring():
+            return False
+        return True
+
+    def black_height(self):
+        """Returns the number of black nodes from this node to the
+        leaves of the tree, or None if there isn't one such value (the
+        tree is color incorrectly).
+        """
+        if self is None:
+            # If we're already at a leaf, there is no path
+            return 1
+        left = RedBlackTree.black_height(self.left)
+        right = RedBlackTree.black_height(self.right)
+        if left is None or right is None:
+            # There are issues with coloring below children nodes
+            return None
+        if left != right:
+            # The two children have unequal depths
+            return None
+        # Return the black depth of children, plus one if this node is
+        # black
+        return left + (1-self.color)
+
+    # Here are functions which are general to all binary search trees
+
+    def __contains__(self, label):
+        """Search through the tree for label, returning True iff it is
+        found somewhere in the tree.
+        
+        Guaranteed to run in O(log(n)) time.
+        """
+        return self.search(label) is not None
+
+    def search(self, label):
+        """Search through the tree for label, returning its node if
+        it's found, and None otherwise.
+
+        This method is guaranteed to run in O(log(n)) time.
+        """
+        if self.label == label:
+            return self
+        elif label > self.label:
+            if self.right is None:
+                return None
+            else:
+                return self.right.search(label)
+        else:
+            if self.left is None:
+                return None
+            else:
+                return self.left.search(label)
+
+    def floor(self, label):
+        """Returns the largest element in this tree which is at most label.
+        
+        This method is guaranteed to run in O(log(n)) time."""
+        if self.label == label:
+            return self.label
+        elif self.label > label:
+            if self.left:
+                return self.left.floor(label)
+            else:
+                return None
+        else:
+            if self.right:
+                attempt = self.right.floor(label)
+                if attempt is not None:
+                    return attempt
+            return self.label
+
+    def ceil(self, label):
+        """Returns the smallest element in this tree which is at least label.
+        
+        This method is guaranteed to run in O(log(n)) time.
+        """
+        if self.label == label:
+            return self.label
+        elif self.label < label:
+            if self.right:
+                return self.right.ceil(label)
+            else:
+                return None
+        else:
+            if self.left:
+                attempt = self.left.ceil(label)
+                if attempt is not None:
+                    return attempt
+            return self.label
+
+    def get_max(self):
+        """Returns the largest element in this tree.
+
+        This method is guaranteed to run in O(log(n)) time.
+        """
+        if self.right:
+            # Go as far right as possible
+            return self.right.get_max()
+        else:
+            return self.label
+
+    def get_min(self):
+        """Returns the smallest element in this tree.
+
+        This method is guaranteed to run in O(log(n)) time.
+        """
+        if self.left:
+            # Go as far left as possible
+            return self.left.get_min()
+        else:
+            return self.label
+
+    @property
+    def grandparent(self):
+        """Get the current node's grandparent, or None if it doesn't exist."""
+        if self.parent is None:
+            return None
+        else:
+            return self.parent.parent
+    
+    @property
+    def sibling(self):
+        """Get the current node's sibling, or None if it doesn't exist."""
+        if self.parent is None:
+            return None
+        elif self.parent.left is self:
+            return self.parent.right
+        else:
+            return self.parent.left
+
+    def is_left(self):
+        """Returns true iff this node is the left child of its parent."""
+        return self.parent and self.parent.left is self
+
+    def is_right(self):
+        """Returns true iff this node is the right child of its parent."""
+        return self.parent and self.parent.right is self
+
+    def __bool__(self):
+        return True
+
+    def __len__(self):
+        """
+        Return the number of nodes in this tree.
+        """
+        ln = 1
+        if self.left:
+            ln += len(self.left)
+        if self.right:
+            ln += len(self.right)
+        return ln
+
+    def preorder_traverse(self):
+        yield self.label
+        if self.left:
+            yield from self.left.preorder_traverse()
+        if self.right:
+            yield from self.right.preorder_traverse()
+
+    def inorder_traverse(self):
+        if self.left:
+            yield from self.left.inorder_traverse()
+        yield self.label
+        if self.right:
+            yield from self.right.inorder_traverse()
+
+
+    def postorder_traverse(self):
+        if self.left:
+            yield from self.left.postorder_traverse()
+        if self.right:
+            yield from self.right.postorder_traverse()
+        yield self.label
+
+    def __repr__(self):
+        from pprint import pformat
+        if self.left is None and self.right is None:
+            return "'%s %s'" % (self.label, (self.color and 'red') or 'blk')
+        return pformat({'%s %s' % (self.label, (self.color and 'red') or 'blk'):
+                            (self.left, self.right)},
+                       indent=1)
+
+    def __eq__(self, other):
+        """Test if two trees are equal."""
+        if self.label == other.label:
+            return self.left == other.left and self.right == other.right
+        else:
+            return False
+
+def color(node):
+    """Returns the color of a node, allowing for None leaves."""
+    if node is None:
+        return 0
+    else:
+        return node.color
+
+"""
+Code for testing the various functions of the red-black tree.
+"""
+
+def test_rotations():
+    """Test that the rotate_left and rotate_right functions work."""
+    # Make a tree to test on
+    tree = RedBlackTree(0)
+    tree.left = RedBlackTree(-10, parent=tree)
+    tree.right = RedBlackTree(10, parent=tree)
+    tree.left.left = RedBlackTree(-20, parent=tree.left)
+    tree.left.right = RedBlackTree(-5, parent=tree.left)
+    tree.right.left = RedBlackTree(5, parent=tree.right)
+    tree.right.right = RedBlackTree(20, parent=tree.right)
+    # Make the right rotation
+    left_rot = RedBlackTree(10)
+    left_rot.left = RedBlackTree(0, parent=left_rot)
+    left_rot.left.left = RedBlackTree(-10, parent=left_rot.left)
+    left_rot.left.right = RedBlackTree(5, parent=left_rot.left)
+    left_rot.left.left.left = RedBlackTree(-20, parent=left_rot.left.left)
+    left_rot.left.left.right = RedBlackTree(-5, parent=left_rot.left.left)
+    left_rot.right = RedBlackTree(20, parent=left_rot)
+    tree = tree.rotate_left()
+    if tree != left_rot:
+        return False
+    tree = tree.rotate_right()
+    tree = tree.rotate_right()
+    # Make the left rotation
+    right_rot = RedBlackTree(-10)
+    right_rot.left = RedBlackTree(-20, parent=right_rot)
+    right_rot.right = RedBlackTree(0, parent=right_rot)
+    right_rot.right.left = RedBlackTree(-5, parent=right_rot.right)
+    right_rot.right.right = RedBlackTree(10, parent=right_rot.right)
+    right_rot.right.right.left = RedBlackTree(5, parent=right_rot.right.right)
+    right_rot.right.right.right = RedBlackTree(20, parent=right_rot.right.right)
+    if tree != right_rot:
+        return False
+    return True
+
+def test_insertion_speed():
+    """Test that the tree balances inserts to O(log(n)) by doing a lot
+    of them.
+    """
+    tree = RedBlackTree(-1)
+    for i in range(300000):
+        tree = tree.insert(i)
+    return True
+
+def test_insert():
+    """Test the insert() method of the tree correctly balances, colors,
+    and inserts.
+    """
+    tree = RedBlackTree(0)
+    tree.insert(8)
+    tree.insert(-8)
+    tree.insert(4)
+    tree.insert(12)
+    tree.insert(10)
+    tree.insert(11)
+    ans = RedBlackTree(0, 0)
+    ans.left = RedBlackTree(-8, 0, ans)
+    ans.right = RedBlackTree(8, 1, ans)
+    ans.right.left = RedBlackTree(4, 0, ans.right)
+    ans.right.right = RedBlackTree(11, 0, ans.right)
+    ans.right.right.left = RedBlackTree(10, 1, ans.right.right)
+    ans.right.right.right = RedBlackTree(12, 1, ans.right.right)
+    return tree == ans
+
+def test_insert_and_search():
+    """Tests searching through the tree for values."""
+    tree = RedBlackTree(0)
+    tree.insert(8)
+    tree.insert(-8)
+    tree.insert(4)
+    tree.insert(12)
+    tree.insert(10)
+    tree.insert(11)
+    if 5 in tree or -6 in tree or -10 in tree or 13 in tree:
+        # Found something not in there
+        return False
+    if not (11 in tree and 12 in tree and -8 in tree and 0 in tree):
+        # Didn't find something in there
+        return False
+    return True
+
+def test_insert_delete():
+    """Test the insert() and delete() method of the tree, verifying the
+    insertion and removal of elements, and the balancing of the tree.
+    """
+    tree = RedBlackTree(0)
+    tree = tree.insert(-12)
+    tree = tree.insert(8)
+    tree = tree.insert(-8)
+    tree = tree.insert(15)
+    tree = tree.insert(4)
+    tree = tree.insert(12)
+    tree = tree.insert(10)
+    tree = tree.insert(9)
+    tree = tree.insert(11)
+    tree = tree.remove(15)
+    tree = tree.remove(-12)
+    tree = tree.remove(9)
+    if not tree.check_color_properties():
+        return False
+    if list(tree.inorder_traverse()) != [-8, 0, 4, 8, 10, 11, 12]:
+        return False
+    return True
+
+def test_floor_ceil():
+    """Tests the floor and ceiling functions in the tree."""
+    tree = RedBlackTree(0)
+    tree.insert(-16)
+    tree.insert(16)
+    tree.insert(8)
+    tree.insert(24)
+    tree.insert(20)
+    tree.insert(22)
+    tuples = [(-20, None, -16), (-10, -16, 0), (8, 8, 8), (50, 24, None)]
+    for val, floor, ceil in tuples:
+        if tree.floor(val) != floor or tree.ceil(val) != ceil:
+            return False
+    return True
+
+def test_min_max():
+    """Tests the min and max functions in the tree."""
+    tree = RedBlackTree(0)
+    tree.insert(-16)
+    tree.insert(16)
+    tree.insert(8)
+    tree.insert(24)
+    tree.insert(20)
+    tree.insert(22)
+    if tree.get_max() != 22 or tree.get_min() != -16:
+        return False
+    return True
+
+def test_tree_traversal():
+    """Tests the three different tree traversal functions."""
+    tree = RedBlackTree(0)
+    tree.insert(-16)
+    tree.insert(16)
+    tree.insert(8)
+    tree.insert(24)
+    tree.insert(20)
+    tree.insert(22)
+    if list(tree.inorder_traverse()) != [-16, 0, 8, 16, 20, 22, 24]:
+        return False
+    if list(tree.preorder_traverse()) != [0, -16, 16, 8, 22, 20, 24]:
+        return False
+    if list(tree.postorder_traverse()) != [-16, 8, 20, 24, 22, 16, 0]:
+        return False
+    return True
+
+def main():
+    if test_rotations():
+        print('Rotating right and left works!')
+    else:
+        print('Rotating right and left doesn\'t work. :(')
+    if test_insert():
+        print('Inserting works!')
+    else:
+        print('Inserting doesn\'t work :(')
+    if test_insert_and_search():
+        print('Searching works!')
+    else:
+        print('Searching doesn\'t work :(')
+    if test_insert_delete():
+        print('Deleting works!')
+    else:
+        print('Deleting doesn\'t work :(')
+    if test_floor_ceil():
+        print('Floor and ceil work!')
+    else:
+        print('Floor and ceil don\'t work :(')
+    if test_tree_traversal():
+        print('Tree traversal works!')
+    else:
+        print('Tree traversal doesn\'t work :(')
+    print('Testing tree balancing...')
+    print('This should only be a few seconds.')
+    test_insertion_speed()
+    print('Done!')
+
+if __name__ == '__main__':
+    main()

From afb98e6c232dac73fb895f9e06a645a82410fd9e Mon Sep 17 00:00:00 2001
From: Dhandarah <dhandarah1996@gmail.com>
Date: Fri, 5 Jul 2019 05:47:18 -0300
Subject: [PATCH 076/348] KNN (#944)

Creates an example of KNN algorithm using sklearn library.
---
 machine_learning/knn_sklearn.py | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 machine_learning/knn_sklearn.py

diff --git a/machine_learning/knn_sklearn.py b/machine_learning/knn_sklearn.py
new file mode 100644
index 000000000000..64582564304f
--- /dev/null
+++ b/machine_learning/knn_sklearn.py
@@ -0,0 +1,28 @@
+from sklearn.model_selection import train_test_split
+from sklearn.datasets import load_iris
+from sklearn.neighbors import KNeighborsClassifier
+
+#Load iris file
+iris = load_iris()
+iris.keys()
+
+
+print('Target names: \n {} '.format(iris.target_names))
+print('\n Features: \n {}'.format(iris.feature_names))
+
+#Train set e Test set
+X_train, X_test, y_train, y_test = train_test_split(iris['data'],iris['target'], random_state=4)
+
+#KNN
+
+knn = KNeighborsClassifier (n_neighbors = 1)
+knn.fit(X_train, y_train)
+
+#new array to test
+X_new = [[1,2,1,4],
+		 [2,3,4,5]]	
+
+prediction = knn.predict(X_new)
+
+print('\nNew array: \n {}'
+	  '\n\nTarget Names Prediction: \n {}'.format(X_new, iris['target_names'][prediction]))

From 831558d38dd00c7b4d64743ca4f3fe62d16e71d1 Mon Sep 17 00:00:00 2001
From: Hetal Kuvadia <hetal.kuvadia@somaiya.edu>
Date: Fri, 5 Jul 2019 14:18:36 +0530
Subject: [PATCH 077/348] #945 Backtracking Algorithms (#953)

* Adding nqueens.py for backtracking

* Adding sum_of_subsets.py for backtracking

* Update nqueens.py

* Rename nqueens.py to n_queens.py

* Deleting /other/n_queens.py
---
 backtracking/n_queens.py       | 84 ++++++++++++++++++++++++++++++++++
 backtracking/sum_of_subsets.py | 45 ++++++++++++++++++
 other/n_queens.py              | 77 -------------------------------
 3 files changed, 129 insertions(+), 77 deletions(-)
 create mode 100644 backtracking/n_queens.py
 create mode 100644 backtracking/sum_of_subsets.py
 delete mode 100644 other/n_queens.py

diff --git a/backtracking/n_queens.py b/backtracking/n_queens.py
new file mode 100644
index 000000000000..dfd4498b166b
--- /dev/null
+++ b/backtracking/n_queens.py
@@ -0,0 +1,84 @@
+'''
+
+ The nqueens problem is of placing N queens on a N * N 
+ chess board such that no queen can attack any other queens placed
+ on that chess board.
+ This means that one queen cannot have any other queen on its horizontal, vertical and 
+ diagonal lines.
+
+'''
+solution = []
+
+def isSafe(board, row, column):
+    '''
+    This function returns a boolean value True if it is safe to place a queen there considering 
+    the current state of the board.
+
+    Parameters :
+    board(2D matrix) : board
+    row ,column : coordinates of the cell on a board
+
+    Returns :
+    Boolean Value
+
+    '''
+    for i in range(len(board)):
+        if board[row][i] == 1:
+            return False
+    for i in range(len(board)):
+        if board[i][column] == 1:
+            return False
+    for i,j in zip(range(row,-1,-1),range(column,-1,-1)):
+        if board[i][j] == 1:
+            return False
+    for i,j in zip(range(row,-1,-1),range(column,len(board))):
+        if board[i][j] == 1:
+            return False
+    return True
+
+def solve(board, row):
+    '''
+    It creates a state space tree and calls the safe function untill it receives a 
+    False Boolean and terminates that brach and backtracks to the next 
+    poosible solution branch.
+    '''
+    if row >= len(board):
+        '''
+        If the row number exceeds N we have board with a successful combination 
+        and that combination is appended to the solution list and the board is printed.
+
+        '''
+        solution.append(board)
+        printboard(board)
+        print()
+        return 
+    for i in range(len(board)):
+        '''
+        For every row it iterates through each column to check if it is feesible to place a 
+        queen there.
+        If all the combinations for that particaular branch are successfull the board is 
+        reinitialized for the next possible combination.
+        '''
+        if isSafe(board,row,i):
+            board[row][i] = 1
+            solve(board,row+1)
+            board[row][i] = 0
+    return False
+
+def printboard(board):
+    '''
+    Prints the boards that have a successfull combination.
+    '''
+    for i in range(len(board)):
+        for j in range(len(board)):
+            if board[i][j] == 1:
+                print("Q", end = " ")
+            else :
+                print(".", end = " ")
+        print()
+
+#n=int(input("The no. of queens")) 
+n = 8
+board = [[0 for i in range(n)]for j in range(n)]
+solve(board, 0)
+print("The total no. of solutions are :", len(solution))
diff --git a/backtracking/sum_of_subsets.py b/backtracking/sum_of_subsets.py
new file mode 100644
index 000000000000..b01bffbb651d
--- /dev/null
+++ b/backtracking/sum_of_subsets.py
@@ -0,0 +1,45 @@
+'''
+	The sum-of-subsetsproblem states that a set of non-negative integers, and a value M, 
+	determine all possible subsets of the given set whose summation sum equal to given M.
+
+	Summation of the chosen numbers must be equal to given number M and one number can 
+	be used only once.
+'''
+
+def generate_sum_of_subsets_soln(nums, max_sum):
+	result = []
+	path = []
+	num_index = 0
+	remaining_nums_sum = sum(nums)
+	create_state_space_tree(nums, max_sum, num_index, path,result, remaining_nums_sum)
+	return result
+
+def create_state_space_tree(nums,max_sum,num_index,path,result, remaining_nums_sum):
+	'''
+	Creates a state space tree to iterate through each branch using DFS.
+	It terminates the branching of a node when any of the two conditions 
+	given below satisfy.
+	This algorithm follows depth-fist-search and backtracks when the node is not branchable.
+
+	'''
+	if sum(path) > max_sum or (remaining_nums_sum + sum(path)) < max_sum:
+		return
+	if sum(path) == max_sum:
+		result.append(path)
+		return
+	for num_index in range(num_index,len(nums)):
+		create_state_space_tree(nums, max_sum, num_index + 1, path + [nums[num_index]], result, remaining_nums_sum - nums[num_index])
+
+'''
+remove the comment to take an input from the user 
+
+print("Enter the elements")
+nums = list(map(int, input().split()))
+print("Enter max_sum sum")
+max_sum = int(input())
+
+'''
+nums = [3, 34, 4, 12, 5, 2]
+max_sum = 9
+result = generate_sum_of_subsets_soln(nums,max_sum)
+print(*result)
\ No newline at end of file
diff --git a/other/n_queens.py b/other/n_queens.py
deleted file mode 100644
index 0e80a0cff5e9..000000000000
--- a/other/n_queens.py
+++ /dev/null
@@ -1,77 +0,0 @@
-#! /usr/bin/python3
-import sys
-
-def nqueens(board_width):
-	board = [0]
-	current_row = 0
-	while True:
-		conflict = False
-		
-		for review_index in range(0, current_row):
-			left = board[review_index] - (current_row - review_index)
-			right = board[review_index] + (current_row - review_index);
-			if (board[current_row] == board[review_index] or (left >= 0 and left == board[current_row]) or (right < board_width and right == board[current_row])):
-				conflict = True;
-				break
-	
-		if (current_row == 0 and conflict == False):
-			board.append(0)
-			current_row = 1
-			continue
-
-		if (conflict == True):
-			board[current_row] += 1
-			
-			if (current_row == 0 and board[current_row] == board_width):
-				print("No solution exists for specificed board size.")
-				return None
-			
-			while True:
-				if (board[current_row] == board_width):
-					board[current_row] = 0
-					if (current_row == 0):
-						print("No solution exists for specificed board size.")
-						return None
-					
-					board.pop()
-					current_row -= 1
-					board[current_row] += 1
-					
-				if board[current_row] != board_width:
-					break
-		else:
-			current_row += 1
-			if (current_row == board_width):
-				break
-
-			board.append(0)
-	return board
-
-def print_board(board):
-	if (board == None):
-		return
-
-	board_width = len(board)
-	for row in range(board_width):
-		line_print = []
-		for column in range(board_width):
-			if column == board[row]:
-				line_print.append("Q")
-			else:
-				line_print.append(".")
-		print(line_print)
-
-
-if __name__ == '__main__':
-	default_width = 8
-	for arg in sys.argv:
-		if (arg.isdecimal() and int(arg) > 3):
-			default_width = int(arg)
-			break
-		
-	if (default_width == 8):
-		print("Running algorithm with board size of 8. Specify an alternative Chess board size for N-Queens as a command line argument.")
-	
-	board = nqueens(default_width)
-	print(board)
-	print_board(board)

From 4e413c018342e71e064c3bdd4a692121bda14fcb Mon Sep 17 00:00:00 2001
From: Anup Kumar Panwar <1anuppanwar@gmail.com>
Date: Sat, 6 Jul 2019 11:11:20 +0530
Subject: [PATCH 078/348] Updated README

---
 CONTRIBUTING.md                               |  12 +-
 DIRECTORY.py                                  |  50 +++
 README.md                                     | 346 ++++++++++++++++++
 .../image_data}/PSNR-example-base.png         | Bin
 .../image_data}/PSNR-example-comp-10.jpg      | Bin
 .../image_data}/compressed_image.png          | Bin
 .../image_data}/example_image.jpg             | Bin
 .../image_data}/example_wikipedia_image.jpg   | Bin
 .../image_data}/original_image.png            | Bin
 .../peak_signal_to_noise_ratio.py             |   8 +-
 data_structures/__init__.py                   |   0
 data_structures/arrays.py                     |   3 -
 data_structures/avl.py                        | 181 ---------
 data_structures/{ => binary_tree}/LCA.py      |   0
 .../binary_tree}/basic_binary_tree.py         |   0
 data_structures/hashing/__init__.py           |   6 -
 .../hashing/number_theory/__init__.py         |   0
 .../{swapNodes.py => swap_nodes.py}           |   0
 data_structures/queue/__init__.py             |   0
 .../{next.py => next_greater_element.py}      |   0
 data_structures/union_find/__init__.py        |   0
 .../union_find/tests_union_find.py            |  78 ----
 data_structures/union_find/union_find.py      |  87 -----
 .../Social_Network_Ads.csv                    |   0
 .../random_forest_classification.py           |   0
 .../random_forest_classifier.ipynb}           |   0
 .../Position_Salaries.csv                     |   0
 .../random_forest_regression.ipynb}           |   0
 .../random_forest_regression.py               |   0
 maths/Hanoi.py                                |  29 --
 maths/{lucasSeries.py => lucas series.py}     |   0
 maths/tests/__init__.py                       |   1 -
 maths/tests/test_fibonacci.py                 |  34 --
 matrix/{spiralPrint.py => spiral_print.py}    |   0
 ....py => back_propagation_neural_network.py} |   0
 ...b => fully_connected_neural_network.ipynb} |   0
 .../game_o_life.py => game_of_life.py}        |   0
 other/game_of_life/sample.gif                 | Bin 228847 -> 0 bytes
 searches/test_interpolation_search.py         |  93 -----
 searches/test_tabu_search.py                  |  46 ---
 simple_client/README.md                       |   6 -
 simple_client/client.py                       |  29 --
 simple_client/server.py                       |  21 --
 sorts/sorting_graphs.png                      | Bin 10362 -> 0 bytes
 sorts/tests.py                                |  76 ----
 45 files changed, 404 insertions(+), 702 deletions(-)
 create mode 100644 DIRECTORY.py
 rename {compression_analysis => compression/image_data}/PSNR-example-base.png (100%)
 rename {compression_analysis => compression/image_data}/PSNR-example-comp-10.jpg (100%)
 rename {compression_analysis => compression/image_data}/compressed_image.png (100%)
 rename {compression_analysis => compression/image_data}/example_image.jpg (100%)
 rename {compression_analysis => compression/image_data}/example_wikipedia_image.jpg (100%)
 rename {compression_analysis => compression/image_data}/original_image.png (100%)
 rename compression_analysis/psnr.py => compression/peak_signal_to_noise_ratio.py (71%)
 delete mode 100644 data_structures/__init__.py
 delete mode 100644 data_structures/arrays.py
 delete mode 100644 data_structures/avl.py
 rename data_structures/{ => binary_tree}/LCA.py (100%)
 rename {binary_tree => data_structures/binary_tree}/basic_binary_tree.py (100%)
 delete mode 100644 data_structures/hashing/__init__.py
 delete mode 100644 data_structures/hashing/number_theory/__init__.py
 rename data_structures/linked_list/{swapNodes.py => swap_nodes.py} (100%)
 delete mode 100644 data_structures/queue/__init__.py
 rename data_structures/stacks/{next.py => next_greater_element.py} (100%)
 delete mode 100644 data_structures/union_find/__init__.py
 delete mode 100644 data_structures/union_find/tests_union_find.py
 delete mode 100644 data_structures/union_find/union_find.py
 rename machine_learning/{Random Forest Classification => random_forest_classification}/Social_Network_Ads.csv (100%)
 rename machine_learning/{Random Forest Classification => random_forest_classification}/random_forest_classification.py (100%)
 rename machine_learning/{Random Forest Classification/Random Forest Classifier.ipynb => random_forest_classification/random_forest_classifier.ipynb} (100%)
 rename machine_learning/{Random Forest Regression => random_forest_regression}/Position_Salaries.csv (100%)
 rename machine_learning/{Random Forest Regression/Random Forest Regression.ipynb => random_forest_regression/random_forest_regression.ipynb} (100%)
 rename machine_learning/{Random Forest Regression => random_forest_regression}/random_forest_regression.py (100%)
 delete mode 100644 maths/Hanoi.py
 rename maths/{lucasSeries.py => lucas series.py} (100%)
 delete mode 100644 maths/tests/__init__.py
 delete mode 100644 maths/tests/test_fibonacci.py
 rename matrix/{spiralPrint.py => spiral_print.py} (100%)
 rename neural_network/{bpnn.py => back_propagation_neural_network.py} (100%)
 rename neural_network/{fcn.ipynb => fully_connected_neural_network.ipynb} (100%)
 rename other/{game_of_life/game_o_life.py => game_of_life.py} (100%)
 delete mode 100644 other/game_of_life/sample.gif
 delete mode 100644 searches/test_interpolation_search.py
 delete mode 100644 searches/test_tabu_search.py
 delete mode 100644 simple_client/README.md
 delete mode 100644 simple_client/client.py
 delete mode 100644 simple_client/server.py
 delete mode 100644 sorts/sorting_graphs.png
 delete mode 100644 sorts/tests.py

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 19b928c187f9..ac632574e870 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -72,9 +72,9 @@ We want your work to be readable by others; therefore, we encourage you to note
 
 - Write tests to illustrate your work.
 
-  The following "testing" approaches are not encouraged:
+  The following "testing" approaches are **not** encouraged:
 
-  ```python
+  ```python*
   input('Enter your input:') 
   # Or even worse...
   input = eval(raw_input("Enter your input: "))
@@ -97,13 +97,9 @@ We want your work to be readable by others; therefore, we encourage you to note
 
 #### Other Standard While Submitting Your Work
 
-- File extension for code should be `.py`.
-
-- Please file your work to let others use it in the future. Here are the examples that are acceptable:
+- File extension for code should be `.py`. Jupiter notebook files are acceptable in machine learning algorithms.
 
-  - Camel cases
-  - `-` Hyphenated names
-  - `_` Underscore-separated names
+- Strictly use snake case (underscore separated) in your file name, as it will be easy to parse in future using scripts.
 
   If possible, follow the standard *within* the folder you are submitting to.
 
diff --git a/DIRECTORY.py b/DIRECTORY.py
new file mode 100644
index 000000000000..434b2a3dd3ed
--- /dev/null
+++ b/DIRECTORY.py
@@ -0,0 +1,50 @@
+import os
+
+def getListOfFiles(dirName):
+    # create a list of file and sub directories 
+    # names in the given directory 
+    listOfFile = os.listdir(dirName)
+    allFiles = list()
+    # Iterate over all the entries
+    for entry in listOfFile:
+        # if entry == listOfFile[len(listOfFile)-1]:
+        #     continue
+        if entry=='.git':
+            continue
+        # Create full path
+        fullPath = os.path.join(dirName, entry)
+        entryName = entry.split('_')
+        # print(entryName)
+        ffname = ''
+        try:
+            for word in entryName:
+                temp = word[0].upper() + word[1:]
+                ffname = ffname + ' ' + temp
+                # print(temp)
+            final_fn = ffname.replace('.py', '')
+            final_fn = final_fn.strip()
+            print('* ['+final_fn+']('+fullPath+')')
+                # pass    
+        except:
+            pass
+        # If entry is a directory then get the list of files in this directory 
+        if os.path.isdir(fullPath):
+            print ('\n## '+entry)
+            filesInCurrDir = getListOfFiles(fullPath)
+            for file in filesInCurrDir:
+                fileName = file.split('/')
+                fileName = fileName[len(fileName)-1]
+
+                # print (fileName)
+            allFiles = allFiles + filesInCurrDir
+        else:
+            allFiles.append(fullPath)
+                
+    return allFiles
+
+
+dirName = './';
+ 
+# Get the list of all files in directory tree at given path
+listOfFiles = getListOfFiles(dirName)
+# print (listOfFiles)
\ No newline at end of file
diff --git a/README.md b/README.md
index 527b80269fdc..9edddb60552a 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,5 @@
 # The Algorithms - Python <!-- [![Build Status](https://travis-ci.org/TheAlgorithms/Python.svg)](https://travis-ci.org/TheAlgorithms/Python) -->
+
 [![Donate](https://img.shields.io/badge/Donate-PayPal-green.svg)](https://www.paypal.me/TheAlgorithms/100) &nbsp;
 [![Gitter chat](https://badges.gitter.im/gitterHQ/gitter.png)](https://gitter.im/TheAlgorithms) &nbsp;
 [![Open in Gitpod](https://gitpod.io/button/open-in-gitpod.svg)](https://gitpod.io/#https://github.com/TheAlgorithms/Python)
@@ -7,6 +8,17 @@
 
 These implementations are for learning purposes. They may be less efficient than the implementations in the Python standard library.
 
+## Owners
+
+Anup Kumar Panwar
+&nbsp; [[Gmail](mailto:1anuppanwar@gmail.com?Subject=The%20Algorithms%20-%20Python)
+&nbsp; [Gihub](https://github.com/anupkumarpanwar)
+&nbsp; [LinkedIn](https://www.linkedin.com/in/anupkumarpanwar/)]
+
+Chetan Kaushik
+&nbsp; [[Gmail](mailto:dynamitechetan@gmail.com?Subject=The%20Algorithms%20-%20Python)
+&nbsp; [Gihub](https://github.com/dynamitechetan)
+&nbsp; [LinkedIn](https://www.linkedin.com/in/chetankaushik/)]
 
 ## Contribution Guidelines
 
@@ -15,3 +27,337 @@ Read our [Contribution Guidelines](CONTRIBUTING.md) before you contribute.
 ## Community Channel
 
 We're on [Gitter](https://gitter.im/TheAlgorithms)! Please join us.
+
+# Algorithms
+
+## Hashes
+
+- [Md5](./hashes/md5.py)
+- [Chaos Machine](./hashes/chaos_machine.py)
+- [Sha1](./hashes/sha1.py)
+
+## File Transfer Protocol
+
+- [Ftp Client Server](./file_transfer_protocol/ftp_client_server.py)
+- [Ftp Send Receive](./file_transfer_protocol/ftp_send_receive.py)
+
+## Backtracking
+
+- [N Queens](./backtracking/n_queens.py)
+- [Sum Of Subsets](./backtracking/sum_of_subsets.py)
+
+## Ciphers
+
+- [Transposition Cipher](./ciphers/transposition_cipher.py)
+- [Atbash](./ciphers/Atbash.py)
+- [Rot13](./ciphers/rot13.py)
+- [Rabin Miller](./ciphers/rabin_miller.py)
+- [Transposition Cipher Encrypt Decrypt File](./ciphers/transposition_cipher_encrypt_decrypt_file.py)
+- [Affine Cipher](./ciphers/affine_cipher.py)
+- [Trafid Cipher](./ciphers/trafid_cipher.py)
+- [Base16](./ciphers/base16.py)
+- [Elgamal Key Generator](./ciphers/elgamal_key_generator.py)
+- [Rsa Cipher](./ciphers/rsa_cipher.py)
+- [Prehistoric Men.txt](./ciphers/prehistoric_men.txt)
+- [Vigenere Cipher](./ciphers/vigenere_cipher.py)
+- [Xor Cipher](./ciphers/xor_cipher.py)
+- [Brute Force Caesar Cipher](./ciphers/brute_force_caesar_cipher.py)
+- [Rsa Key Generator](./ciphers/rsa_key_generator.py)
+- [Simple Substitution Cipher](./ciphers/simple_substitution_cipher.py)
+- [Playfair Cipher](./ciphers/playfair_cipher.py)
+- [Morse Code Implementation](./ciphers/morse_Code_implementation.py)
+- [Base32](./ciphers/base32.py)
+- [Base85](./ciphers/base85.py)
+- [Base64 Cipher](./ciphers/base64_cipher.py)
+- [Onepad Cipher](./ciphers/onepad_cipher.py)
+- [Caesar Cipher](./ciphers/caesar_cipher.py)
+- [Hill Cipher](./ciphers/hill_cipher.py)
+- [Cryptomath Module](./ciphers/cryptomath_module.py)
+
+## Arithmetic Analysis
+
+- [Bisection](./arithmetic_analysis/bisection.py)
+- [Newton Method](./arithmetic_analysis/newton_method.py)
+- [Newton Raphson Method](./arithmetic_analysis/newton_raphson_method.py)
+- [Intersection](./arithmetic_analysis/intersection.py)
+- [Lu Decomposition](./arithmetic_analysis/lu_decomposition.py)
+
+## Boolean Algebra
+
+- [Quine Mc Cluskey](./boolean_algebra/quine_mc_cluskey.py)
+
+## Traversals
+
+- [Binary Tree Traversals](./traversals/binary_tree_traversals.py)
+
+## Maths
+
+- [Average](./maths/average.py)
+- [Abs Max](./maths/abs_Max.py)
+- [Average Median](./maths/average_median.py)
+- [Trapezoidal Rule](./maths/trapezoidal_rule.py)
+- [Prime Check](./maths/Prime_Check.py)
+- [Modular Exponential](./maths/modular_exponential.py)
+- [Newton Raphson](./maths/newton_raphson.py)
+- [Factorial Recursive](./maths/factorial_recursive.py)
+- [Extended Euclidean Algorithm](./maths/extended_euclidean_algorithm.py)
+- [Greater Common Divisor](./maths/greater_common_divisor.py)
+- [Fibonacci](./maths/fibonacci.py)
+- [Find Lcm](./maths/find_lcm.py)
+- [Find Max](./maths/Find_Max.py)
+- [Fermat Little Theorem](./maths/fermat_little_theorem.py)
+- [Factorial Python](./maths/factorial_python.py)
+- [Fibonacci Sequence Recursion](./maths/fibonacci_sequence_recursion.py)
+- [Sieve Of Eratosthenes](./maths/sieve_of_eratosthenes.py)
+- [Abs Min](./maths/abs_Min.py)
+- [Lucas Series](./maths/lucasSeries.py)
+- [Segmented Sieve](./maths/segmented_sieve.py)
+- [Find Min](./maths/Find_Min.py)
+- [Abs](./maths/abs.py)
+- [Simpson Rule](./maths/simpson_rule.py)
+- [Basic Maths](./maths/basic_maths.py)
+- [3n+1](./maths/3n+1.py)
+- [Binary Exponentiation](./maths/Binary_Exponentiation.py)
+
+## Digital Image Processing
+
+- ## Filters
+
+  - [Median Filter](./digital_image_processing/filters/median_filter.py)
+  - [Gaussian Filter](./digital_image_processing/filters/gaussian_filter.py)
+
+
+## Compression
+
+- [Peak Signal To Noise Ratio](./compression_analysis/peak_signal_to_noise_ratio.py)
+- [Huffman](./compression/huffman.py)
+
+## Graphs
+
+- [BFS Shortest Path](./graphs/bfs_shortest_path.py)
+- [Directed And Undirected (Weighted) Graph](<./graphs/Directed_and_Undirected_(Weighted)_Graph.py>)
+- [Minimum Spanning Tree Prims](./graphs/minimum_spanning_tree_prims.py)
+- [Graph Matrix](./graphs/graph_matrix.py)
+- [Basic Graphs](./graphs/basic_graphs.py)
+- [Dijkstra 2](./graphs/dijkstra_2.py)
+- [Tarjans Strongly Connected Components](./graphs/tarjans_scc.py)
+- [Check Bipartite Graph BFS](./graphs/check_bipartite_graph_bfs.py)
+- [Depth First Search](./graphs/depth_first_search.py)
+- [Kahns Algorithm Long](./graphs/kahns_algorithm_long.py)
+- [Breadth First Search](./graphs/breadth_first_search.py)
+- [Dijkstra](./graphs/dijkstra.py)
+- [Articulation Points](./graphs/articulation_points.py)
+- [Bellman Ford](./graphs/bellman_ford.py)
+- [Check Bipartite Graph Dfs](./graphs/check_bipartite_graph_dfs.py)
+- [Strongly Connected Components Kosaraju](./graphs/scc_kosaraju.py)
+- [Multi Hueristic Astar](./graphs/multi_hueristic_astar.py)
+- [Page Rank](./graphs/page_rank.py)
+- [Eulerian Path And Circuit For Undirected Graph](./graphs/Eulerian_path_and_circuit_for_undirected_graph.py)
+- [Edmonds Karp Multiple Source And Sink](./graphs/edmonds_karp_multiple_source_and_sink.py)
+- [Floyd Warshall](./graphs/floyd_warshall.py)
+- [Minimum Spanning Tree Kruskal](./graphs/minimum_spanning_tree_kruskal.py)
+- [Prim](./graphs/prim.py)
+- [Kahns Algorithm Topo](./graphs/kahns_algorithm_topo.py)
+- [BFS](./graphs/BFS.py)
+- [Finding Bridges](./graphs/finding_bridges.py)
+- [Graph List](./graphs/graph_list.py)
+- [Dijkstra Algorithm](./graphs/dijkstra_algorithm.py)
+- [A Star](./graphs/a_star.py)
+- [Even Tree](./graphs/even_tree.py)
+- [DFS](./graphs/DFS.py)
+
+## Networking Flow
+
+- [Minimum Cut](./networking_flow/minimum_cut.py)
+- [Ford Fulkerson](./networking_flow/ford_fulkerson.py)
+
+## Matrix
+
+- [Matrix Operation](./matrix/matrix_operation.py)
+- [Searching In Sorted Matrix](./matrix/searching_in_sorted_matrix.py)
+- [Spiral Print](./matrix/spiral_print.py)
+
+## Searches
+
+- [Quick Select](./searches/quick_select.py)
+- [Binary Search](./searches/binary_search.py)
+- [Interpolation Search](./searches/interpolation_search.py)
+- [Jump Search](./searches/jump_search.py)
+- [Linear Search](./searches/linear_search.py)
+- [Ternary Search](./searches/ternary_search.py)
+- [Tabu Search](./searches/tabu_search.py)
+- [Sentinel Linear Search](./searches/sentinel_linear_search.py)
+
+## Conversions
+
+- [Decimal To Binary](./conversions/decimal_to_binary.py)
+- [Decimal To Octal](./conversions/decimal_to_octal.py)
+
+## Dynamic Programming
+
+- [Fractional Knapsack](./dynamic_programming/Fractional_Knapsack.py)
+- [Sum Of Subset](./dynamic_programming/sum_of_subset.py)
+- [Fast Fibonacci](./dynamic_programming/fast_fibonacci.py)
+- [Bitmask](./dynamic_programming/bitmask.py)
+- [Abbreviation](./dynamic_programming/abbreviation.py)
+- [Rod Cutting](./dynamic_programming/rod_cutting.py)
+- [Knapsack](./dynamic_programming/knapsack.py)
+- [Max Sub Array](./dynamic_programming/max_sub_array.py)
+- [Fibonacci](./dynamic_programming/fibonacci.py)
+- [Minimum Partition](./dynamic_programming/minimum_partition.py)
+- [K Means Clustering Tensorflow](./dynamic_programming/k_means_clustering_tensorflow.py)
+- [Coin Change](./dynamic_programming/coin_change.py)
+- [Subset Generation](./dynamic_programming/subset_generation.py)
+- [Floyd Warshall](./dynamic_programming/floyd_warshall.py)
+- [Longest Sub Array](./dynamic_programming/longest_sub_array.py)
+- [Integer Partition](./dynamic_programming/integer_partition.py)
+- [Matrix Chain Order](./dynamic_programming/matrix_chain_order.py)
+- [Edit Distance](./dynamic_programming/edit_distance.py)
+- [Longest Common Subsequence](./dynamic_programming/longest_common_subsequence.py)
+- [Longest Increasing Subsequence O(nlogn)](<./dynamic_programming/longest_increasing_subsequence_O(nlogn).py>)
+- [Longest Increasing Subsequence](./dynamic_programming/longest_increasing_subsequence.py)
+
+## Divide And Conquer
+
+- [Max Subarray Sum](./divide_and_conquer/max_subarray_sum.py)
+- [Max Sub Array Sum](./divide_and_conquer/max_sub_array_sum.py)
+- [Closest Pair Of Points](./divide_and_conquer/closest_pair_of_points.py)
+
+## Strings
+
+- [Knuth Morris Pratt](./strings/knuth_morris_pratt.py)
+- [Rabin Karp](./strings/rabin_karp.py)
+- [Naive String Search](./strings/naive_String_Search.py)
+- [Levenshtein Distance](./strings/levenshtein_distance.py)
+- [Min Cost String Conversion](./strings/min_cost_string_conversion.py)
+- [Boyer Moore Search](./strings/Boyer_Moore_Search.py)
+- [Manacher](./strings/manacher.py)
+
+## Sorts
+
+- [Quick Sort](./sorts/quick_sort.py)
+- [Selection Sort](./sorts/selection_sort.py)
+- [Bitonic Sort](./sorts/Bitonic_Sort.py)
+- [Cycle Sort](./sorts/cycle_sort.py)
+- [Comb Sort](./sorts/comb_sort.py)
+- [Topological Sort](./sorts/topological_sort.py)
+- [Merge Sort Fastest](./sorts/merge_sort_fastest.py)
+- [Random Pivot Quick Sort](./sorts/random_pivot_quick_sort.py)
+- [Heap Sort](./sorts/heap_sort.py)
+- [Insertion Sort](./sorts/insertion_sort.py)
+- [Counting Sort](./sorts/counting_sort.py)
+- [Bucket Sort](./sorts/bucket_sort.py)
+- [Quick Sort 3 Partition](./sorts/quick_sort_3_partition.py)
+- [Bogo Sort](./sorts/bogo_sort.py)
+- [Shell Sort](./sorts/shell_sort.py)
+- [Pigeon Sort](./sorts/pigeon_sort.py)
+- [Odd-Even Transposition Parallel](./sorts/Odd-Even_transposition_parallel.py)
+- [Tree Sort](./sorts/tree_sort.py)
+- [Cocktail Shaker Sort](./sorts/cocktail_shaker_sort.py)
+- [Random Normal Distribution Quicksort](./sorts/random_normal_distribution_quicksort.py)
+- [Wiggle Sort](./sorts/wiggle_sort.py)
+- [Pancake Sort](./sorts/pancake_sort.py)
+- [External Sort](./sorts/external_sort.py)
+- [Tim Sort](./sorts/tim_sort.py)
+- [Sorting Graphs.png](./sorts/sorting_graphs.png)
+- [Radix Sort](./sorts/radix_sort.py)
+- [Odd-Even Transposition Single-threaded](./sorts/Odd-Even_transposition_single-threaded.py)
+- [Bubble Sort](./sorts/bubble_sort.py)
+- [Gnome Sort](./sorts/gnome_sort.py)
+- [Merge Sort](./sorts/merge_sort.py)
+
+## Machine Learning
+
+- [Perceptron](./machine_learning/perceptron.py)
+- [Random Forest Classifier](./machine_learning/random_forest_classification/random_forest_classifier.ipynb)
+- [NaiveBayes.ipynb](./machine_learning/NaiveBayes.ipynb)
+- [Scoring Functions](./machine_learning/scoring_functions.py)
+- [Logistic Regression](./machine_learning/logistic_regression.py)
+- [Gradient Descent](./machine_learning/gradient_descent.py)
+- [Linear Regression](./machine_learning/linear_regression.py)
+- [Random Forest Regression](./machine_learning/random_forest_regression/random_forest_regression.py)
+- [Random Forest Regression](./machine_learning/random_forest_regression/random_forest_regression.ipynb)
+- [Reuters One Vs Rest Classifier.ipynb](./machine_learning/reuters_one_vs_rest_classifier.ipynb)
+- [Decision Tree](./machine_learning/decision_tree.py)
+- [Knn Sklearn](./machine_learning/knn_sklearn.py)
+- [K Means Clust](./machine_learning/k_means_clust.py)
+
+## Neural Network
+
+- [Perceptron](./neural_network/perceptron.py)
+- [Fully Connected Neural Network](./neural_network/fully_connected_neural_network.ipynb)
+- [Convolution Neural Network](./neural_network/convolution_neural_network.py)
+- [Back Propagation Neural Network](./neural_network/back_propagation_neural_network.py)
+
+## Data Structures
+
+- ## Binary Tree
+
+   - [Basic Binary Tree](./data_structures/binary_tree/basic_binary_tree.py)
+  - [Red Black Tree](./data_structures/binary_tree/red_black_tree.py)
+  - [Fenwick Tree](./data_structures/binary_tree/fenwick_tree.py)
+  - [Treap](./data_structures/binary_tree/treap.py)
+  - [AVL Tree](./data_structures/binary_tree/AVL_tree.py)
+  - [Segment Tree](./data_structures/binary_tree/segment_tree.py)
+  - [Lazy Segment Tree](./data_structures/binary_tree/lazy_segment_tree.py)
+  - [Binary Search Tree](./data_structures/binary_tree/binary_search_tree.py)
+
+- ## Trie
+
+  - [Trie](./data_structures/trie/trie.py)
+
+- ## Linked List
+
+  - [Swap Nodes](./data_structures/linked_list/swap_nodes.py)
+  - [Doubly Linked List](./data_structures/linked_list/doubly_linked_list.py)
+  - [Singly Linked List](./data_structures/linked_list/singly_linked_list.py)
+  - [Is Palindrome](./data_structures/linked_list/is_Palindrome.py)
+
+- ## Stacks
+
+  - [Postfix Evaluation](./data_structures/stacks/postfix_evaluation.py)
+  - [Balanced Parentheses](./data_structures/stacks/balanced_parentheses.py)
+  - [Infix To Prefix Conversion](./data_structures/stacks/infix_to_prefix_conversion.py)
+  - [Stack](./data_structures/stacks/stack.py)
+  - [Infix To Postfix Conversion](./data_structures/stacks/infix_to_postfix_conversion.py)
+  - [Next Greater Element](./data_structures/stacks/next_greater_element.py)
+  - [Stock Span Problem](./data_structures/stacks/stock_span_problem.py)
+
+- ## Queue
+
+  - [Queue On Pseudo Stack](./data_structures/queue/queue_on_pseudo_stack.py)
+  - [Double Ended Queue](./data_structures/queue/double_ended_queue.py)
+  - [Queue On List](./data_structures/queue/queue_on_list.py)
+
+- ## Heap
+
+  - [Heap](./data_structures/heap/heap.py)
+
+- ## Hashing
+
+  - [Hash Table With Linked List](./data_structures/hashing/hash_table_with_linked_list.py)
+  - [Quadratic Probing](./data_structures/hashing/quadratic_probing.py)
+  - [Hash Table](./data_structures/hashing/hash_table.py)
+  - [Double Hash](./data_structures/hashing/double_hash.py)
+
+
+## Other
+
+- [Detecting English Programmatically](./other/detecting_english_programmatically.py)
+- [Fischer Yates Shuffle](./other/fischer_yates_shuffle.py)
+- [Primelib](./other/primelib.py)
+- [Binary Exponentiation 2](./other/binary_exponentiation_2.py)
+- [Anagrams](./other/anagrams.py)
+- [Palindrome](./other/palindrome.py)
+- [Finding Primes](./other/finding_Primes.py)
+- [Two Sum](./other/two_sum.py)
+- [Password Generator](./other/password_generator.py)
+- [Linear Congruential Generator](./other/linear_congruential_generator.py)
+- [Frequency Finder](./other/frequency_finder.py)
+- [Euclidean Gcd](./other/euclidean_gcd.py)
+- [Word Patterns](./other/word_patterns.py)
+- [Nested Brackets](./other/nested_brackets.py)
+- [Binary Exponentiation](./other/binary_exponentiation.py)
+- [Sierpinski Triangle](./other/sierpinski_triangle.py)
+- [Game Of Life](./other/game_of_life.py)
+- [Tower Of Hanoi](./other/tower_of_hanoi.py)
diff --git a/compression_analysis/PSNR-example-base.png b/compression/image_data/PSNR-example-base.png
similarity index 100%
rename from compression_analysis/PSNR-example-base.png
rename to compression/image_data/PSNR-example-base.png
diff --git a/compression_analysis/PSNR-example-comp-10.jpg b/compression/image_data/PSNR-example-comp-10.jpg
similarity index 100%
rename from compression_analysis/PSNR-example-comp-10.jpg
rename to compression/image_data/PSNR-example-comp-10.jpg
diff --git a/compression_analysis/compressed_image.png b/compression/image_data/compressed_image.png
similarity index 100%
rename from compression_analysis/compressed_image.png
rename to compression/image_data/compressed_image.png
diff --git a/compression_analysis/example_image.jpg b/compression/image_data/example_image.jpg
similarity index 100%
rename from compression_analysis/example_image.jpg
rename to compression/image_data/example_image.jpg
diff --git a/compression_analysis/example_wikipedia_image.jpg b/compression/image_data/example_wikipedia_image.jpg
similarity index 100%
rename from compression_analysis/example_wikipedia_image.jpg
rename to compression/image_data/example_wikipedia_image.jpg
diff --git a/compression_analysis/original_image.png b/compression/image_data/original_image.png
similarity index 100%
rename from compression_analysis/original_image.png
rename to compression/image_data/original_image.png
diff --git a/compression_analysis/psnr.py b/compression/peak_signal_to_noise_ratio.py
similarity index 71%
rename from compression_analysis/psnr.py
rename to compression/peak_signal_to_noise_ratio.py
index 0f21aac07d34..b0efb1462dcc 100644
--- a/compression_analysis/psnr.py
+++ b/compression/peak_signal_to_noise_ratio.py
@@ -21,11 +21,11 @@ def psnr(original, contrast):
 def main():
     dir_path = os.path.dirname(os.path.realpath(__file__))
     # Loading images (original image and compressed image)
-    original = cv2.imread(os.path.join(dir_path, 'original_image.png'))
-    contrast = cv2.imread(os.path.join(dir_path, 'compressed_image.png'), 1)
+    original = cv2.imread(os.path.join(dir_path, 'image_data/original_image.png'))
+    contrast = cv2.imread(os.path.join(dir_path, 'image_data/compressed_image.png'), 1)
 
-    original2 = cv2.imread(os.path.join(dir_path, 'PSNR-example-base.png'))
-    contrast2 = cv2.imread(os.path.join(dir_path, 'PSNR-example-comp-10.jpg'), 1)
+    original2 = cv2.imread(os.path.join(dir_path, 'image_data/PSNR-example-base.png'))
+    contrast2 = cv2.imread(os.path.join(dir_path, 'image_data/PSNR-example-comp-10.jpg'), 1)
 
     # Value expected: 29.73dB
     print("-- First Test --")
diff --git a/data_structures/__init__.py b/data_structures/__init__.py
deleted file mode 100644
index e69de29bb2d1..000000000000
diff --git a/data_structures/arrays.py b/data_structures/arrays.py
deleted file mode 100644
index feb061013556..000000000000
--- a/data_structures/arrays.py
+++ /dev/null
@@ -1,3 +0,0 @@
-arr = [10, 20, 30, 40]
-arr[1] = 30 # set element 1 (20) of array to 30
-print(arr)
diff --git a/data_structures/avl.py b/data_structures/avl.py
deleted file mode 100644
index d01e8f825368..000000000000
--- a/data_structures/avl.py
+++ /dev/null
@@ -1,181 +0,0 @@
-"""
-An AVL tree
-"""
-from __future__ import print_function
-
-
-class Node:
-
-    def __init__(self, label):
-        self.label = label
-        self._parent = None
-        self._left = None
-        self._right = None
-        self.height = 0
-
-    @property
-    def right(self):
-        return self._right
-
-    @right.setter
-    def right(self, node):
-        if node is not None:
-            node._parent = self
-            self._right = node
-
-    @property
-    def left(self):
-        return self._left
-
-    @left.setter
-    def left(self, node):
-        if node is not None:
-            node._parent = self
-            self._left = node
-
-    @property
-    def parent(self):
-        return self._parent
-
-    @parent.setter
-    def parent(self, node):
-        if node is not None:
-            self._parent = node
-            self.height = self.parent.height + 1
-        else:
-            self.height = 0
-
-
-class AVL:
-
-    def __init__(self):
-        self.root = None
-        self.size = 0
-
-    def insert(self, value):
-        node = Node(value)
-
-        if self.root is None:
-            self.root = node
-            self.root.height = 0
-            self.size = 1
-        else:
-            # Same as Binary Tree
-            dad_node = None
-            curr_node = self.root
-
-            while True:
-                if curr_node is not None:
-
-                    dad_node = curr_node
-
-                    if node.label < curr_node.label:
-                        curr_node = curr_node.left
-                    else:
-                        curr_node = curr_node.right
-                else:
-                    node.height = dad_node.height
-                    dad_node.height += 1
-                    if node.label < dad_node.label:
-                        dad_node.left = node
-                    else:
-                        dad_node.right = node
-                    self.rebalance(node)
-                    self.size += 1
-                    break
-
-    def rebalance(self, node):
-        n = node
-
-        while n is not None:
-            height_right = n.height
-            height_left = n.height
-
-            if n.right is not None:
-                height_right = n.right.height
-
-            if n.left is not None:
-                height_left = n.left.height
-
-            if abs(height_left - height_right) > 1:
-                if height_left > height_right:
-                    left_child = n.left
-                    if left_child is not None:
-                        h_right = (left_child.right.height
-                                    if (left_child.right is not None) else 0)
-                        h_left = (left_child.left.height
-                                    if (left_child.left is not None) else 0)
-                    if (h_left > h_right):
-                        self.rotate_left(n)
-                        break
-                    else:
-                        self.double_rotate_right(n)
-                        break
-                else:
-                    right_child = n.right
-                    if right_child is not None:
-                        h_right = (right_child.right.height
-                            if (right_child.right is not None) else 0)
-                        h_left = (right_child.left.height
-                            if (right_child.left is not None) else 0)
-                    if (h_left > h_right):
-                        self.double_rotate_left(n)
-                        break
-                    else:
-                        self.rotate_right(n)
-                        break
-            n = n.parent
-
-    def rotate_left(self, node):
-        aux = node.parent.label
-        node.parent.label = node.label
-        node.parent.right = Node(aux)
-        node.parent.right.height = node.parent.height + 1
-        node.parent.left = node.right
-
-
-    def rotate_right(self, node):
-        aux = node.parent.label
-        node.parent.label = node.label
-        node.parent.left = Node(aux)
-        node.parent.left.height = node.parent.height + 1
-        node.parent.right = node.right
-
-    def double_rotate_left(self, node):
-        self.rotate_right(node.getRight().getRight())
-        self.rotate_left(node)
-
-    def double_rotate_right(self, node):
-        self.rotate_left(node.getLeft().getLeft())
-        self.rotate_right(node)
-
-    def empty(self):
-        if self.root is None:
-            return True
-        return False
-
-    def preShow(self, curr_node):
-        if curr_node is not None:
-            self.preShow(curr_node.left)
-            print(curr_node.label, end=" ")
-            self.preShow(curr_node.right)
-
-    def preorder(self, curr_node):
-        if curr_node is not None:
-            self.preShow(curr_node.left)
-            self.preShow(curr_node.right)
-            print(curr_node.label, end=" ")
-
-    def getRoot(self):
-        return self.root
-
-t = AVL()
-t.insert(1)
-t.insert(2)
-t.insert(3)
-# t.preShow(t.root)
-# print("\n")
-# t.insert(4)
-# t.insert(5)
-# t.preShow(t.root)
-# t.preorden(t.root)
diff --git a/data_structures/LCA.py b/data_structures/binary_tree/LCA.py
similarity index 100%
rename from data_structures/LCA.py
rename to data_structures/binary_tree/LCA.py
diff --git a/binary_tree/basic_binary_tree.py b/data_structures/binary_tree/basic_binary_tree.py
similarity index 100%
rename from binary_tree/basic_binary_tree.py
rename to data_structures/binary_tree/basic_binary_tree.py
diff --git a/data_structures/hashing/__init__.py b/data_structures/hashing/__init__.py
deleted file mode 100644
index b96ddd478458..000000000000
--- a/data_structures/hashing/__init__.py
+++ /dev/null
@@ -1,6 +0,0 @@
-from .hash_table import HashTable
-
-class QuadraticProbing(HashTable):
-
-    def __init__(self):
-        super(self.__class__, self).__init__()
diff --git a/data_structures/hashing/number_theory/__init__.py b/data_structures/hashing/number_theory/__init__.py
deleted file mode 100644
index e69de29bb2d1..000000000000
diff --git a/data_structures/linked_list/swapNodes.py b/data_structures/linked_list/swap_nodes.py
similarity index 100%
rename from data_structures/linked_list/swapNodes.py
rename to data_structures/linked_list/swap_nodes.py
diff --git a/data_structures/queue/__init__.py b/data_structures/queue/__init__.py
deleted file mode 100644
index e69de29bb2d1..000000000000
diff --git a/data_structures/stacks/next.py b/data_structures/stacks/next_greater_element.py
similarity index 100%
rename from data_structures/stacks/next.py
rename to data_structures/stacks/next_greater_element.py
diff --git a/data_structures/union_find/__init__.py b/data_structures/union_find/__init__.py
deleted file mode 100644
index e69de29bb2d1..000000000000
diff --git a/data_structures/union_find/tests_union_find.py b/data_structures/union_find/tests_union_find.py
deleted file mode 100644
index b0708778ddbd..000000000000
--- a/data_structures/union_find/tests_union_find.py
+++ /dev/null
@@ -1,78 +0,0 @@
-from __future__ import absolute_import
-from .union_find import UnionFind
-import unittest
-
-
-class TestUnionFind(unittest.TestCase):
-    def test_init_with_valid_size(self):
-        uf = UnionFind(5)
-        self.assertEqual(uf.size, 5)
-
-    def test_init_with_invalid_size(self):
-        with self.assertRaises(ValueError):
-            uf = UnionFind(0)
-
-        with self.assertRaises(ValueError):
-            uf = UnionFind(-5)
-
-    def test_union_with_valid_values(self):
-        uf = UnionFind(10)
-
-        for i in range(11):
-            for j in range(11):
-                uf.union(i, j)
-
-    def test_union_with_invalid_values(self):
-        uf = UnionFind(10)
-
-        with self.assertRaises(ValueError):
-            uf.union(-1, 1)
-
-        with self.assertRaises(ValueError):
-            uf.union(11, 1)
-
-    def test_same_set_with_valid_values(self):
-        uf = UnionFind(10)
-
-        for i in range(11):
-            for j in range(11):
-                if i == j:
-                    self.assertTrue(uf.same_set(i, j))
-                else:
-                    self.assertFalse(uf.same_set(i, j))
-
-        uf.union(1, 2)
-        self.assertTrue(uf.same_set(1, 2))
-
-        uf.union(3, 4)
-        self.assertTrue(uf.same_set(3, 4))
-
-        self.assertFalse(uf.same_set(1, 3))
-        self.assertFalse(uf.same_set(1, 4))
-        self.assertFalse(uf.same_set(2, 3))
-        self.assertFalse(uf.same_set(2, 4))
-
-        uf.union(1, 3)
-        self.assertTrue(uf.same_set(1, 3))
-        self.assertTrue(uf.same_set(1, 4))
-        self.assertTrue(uf.same_set(2, 3))
-        self.assertTrue(uf.same_set(2, 4))
-
-        uf.union(4, 10)
-        self.assertTrue(uf.same_set(1, 10))
-        self.assertTrue(uf.same_set(2, 10))
-        self.assertTrue(uf.same_set(3, 10))
-        self.assertTrue(uf.same_set(4, 10))
-
-    def test_same_set_with_invalid_values(self):
-        uf = UnionFind(10)
-
-        with self.assertRaises(ValueError):
-            uf.same_set(-1, 1)
-
-        with self.assertRaises(ValueError):
-            uf.same_set(11, 0)
-
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/data_structures/union_find/union_find.py b/data_structures/union_find/union_find.py
deleted file mode 100644
index 40eea67ac944..000000000000
--- a/data_structures/union_find/union_find.py
+++ /dev/null
@@ -1,87 +0,0 @@
-class UnionFind():
-    """
-    https://en.wikipedia.org/wiki/Disjoint-set_data_structure
-
-    The union-find is a disjoint-set data structure
-
-    You can merge two sets and tell if one set belongs to
-    another one.
-
-    It's used on the Kruskal Algorithm
-    (https://en.wikipedia.org/wiki/Kruskal%27s_algorithm)
-
-    The elements are in range [0, size]
-    """
-    def __init__(self, size):
-        if size <= 0:
-            raise ValueError("size should be greater than 0")
-
-        self.size = size
-
-        # The below plus 1 is because we are using elements
-        # in range [0, size]. It makes more sense.
-
-        # Every set begins with only itself
-        self.root = [i for i in range(size+1)]
-
-        # This is used for heuristic union by rank
-        self.weight = [0 for i in range(size+1)]
-
-    def union(self, u, v):
-        """
-        Union of the sets u and v.
-        Complexity: log(n).
-        Amortized complexity: < 5 (it's very fast).
-        """
-
-        self._validate_element_range(u, "u")
-        self._validate_element_range(v, "v")
-
-        if u == v:
-            return
-
-        # Using union by rank will guarantee the
-        # log(n) complexity
-        rootu = self._root(u)
-        rootv = self._root(v)
-        weight_u = self.weight[rootu]
-        weight_v = self.weight[rootv]
-        if weight_u >= weight_v:
-            self.root[rootv] = rootu
-            if weight_u == weight_v:
-                self.weight[rootu] += 1
-        else:
-            self.root[rootu] = rootv
-
-    def same_set(self, u, v):
-        """
-        Return true if the elements u and v belongs to
-        the same set
-        """
-
-        self._validate_element_range(u, "u")
-        self._validate_element_range(v, "v")
-
-        return self._root(u) == self._root(v)
-
-    def _root(self, u):
-        """
-        Get the element set root.
-        This uses the heuristic path compression
-        See wikipedia article for more details.
-        """
-
-        if u != self.root[u]:
-            self.root[u] = self._root(self.root[u])
-
-        return self.root[u]
-
-    def _validate_element_range(self, u, element_name):
-        """
-        Raises ValueError if element is not in range
-        """
-        if u < 0 or u > self.size:
-            msg = ("element {0} with value {1} "
-                   "should be in range [0~{2}]")\
-                  .format(element_name, u, self.size)
-            raise ValueError(msg)
diff --git a/machine_learning/Random Forest Classification/Social_Network_Ads.csv b/machine_learning/random_forest_classification/Social_Network_Ads.csv
similarity index 100%
rename from machine_learning/Random Forest Classification/Social_Network_Ads.csv
rename to machine_learning/random_forest_classification/Social_Network_Ads.csv
diff --git a/machine_learning/Random Forest Classification/random_forest_classification.py b/machine_learning/random_forest_classification/random_forest_classification.py
similarity index 100%
rename from machine_learning/Random Forest Classification/random_forest_classification.py
rename to machine_learning/random_forest_classification/random_forest_classification.py
diff --git a/machine_learning/Random Forest Classification/Random Forest Classifier.ipynb b/machine_learning/random_forest_classification/random_forest_classifier.ipynb
similarity index 100%
rename from machine_learning/Random Forest Classification/Random Forest Classifier.ipynb
rename to machine_learning/random_forest_classification/random_forest_classifier.ipynb
diff --git a/machine_learning/Random Forest Regression/Position_Salaries.csv b/machine_learning/random_forest_regression/Position_Salaries.csv
similarity index 100%
rename from machine_learning/Random Forest Regression/Position_Salaries.csv
rename to machine_learning/random_forest_regression/Position_Salaries.csv
diff --git a/machine_learning/Random Forest Regression/Random Forest Regression.ipynb b/machine_learning/random_forest_regression/random_forest_regression.ipynb
similarity index 100%
rename from machine_learning/Random Forest Regression/Random Forest Regression.ipynb
rename to machine_learning/random_forest_regression/random_forest_regression.ipynb
diff --git a/machine_learning/Random Forest Regression/random_forest_regression.py b/machine_learning/random_forest_regression/random_forest_regression.py
similarity index 100%
rename from machine_learning/Random Forest Regression/random_forest_regression.py
rename to machine_learning/random_forest_regression/random_forest_regression.py
diff --git a/maths/Hanoi.py b/maths/Hanoi.py
deleted file mode 100644
index c7b435a8fe3e..000000000000
--- a/maths/Hanoi.py
+++ /dev/null
@@ -1,29 +0,0 @@
-"""Tower of Hanoi."""
-
-# @author willx75
-# Tower of Hanoi recursion game algorithm is a game, it consists of three rods
-# and a number of disks of different sizes, which can slide onto any rod
-
-import logging
-
-log = logging.getLogger()
-logging.basicConfig(level=logging.DEBUG)
-
-
-def Tower_Of_Hanoi(n, source, dest, by, movement):
-    """Tower of Hanoi - Move plates to different rods."""
-    if n == 0:
-        return n
-    elif n == 1:
-        movement += 1
-        # no print statement
-        # (you could make it an optional flag for printing logs)
-        logging.debug('Move the plate from', source, 'to', dest)
-        return movement
-    else:
-
-        movement = movement + Tower_Of_Hanoi(n - 1, source, by, dest, 0)
-        logging.debug('Move the plate from', source, 'to', dest)
-
-        movement = movement + 1 + Tower_Of_Hanoi(n - 1, by, dest, source, 0)
-        return movement
diff --git a/maths/lucasSeries.py b/maths/lucas series.py
similarity index 100%
rename from maths/lucasSeries.py
rename to maths/lucas series.py
diff --git a/maths/tests/__init__.py b/maths/tests/__init__.py
deleted file mode 100644
index 2c4a6048556c..000000000000
--- a/maths/tests/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-from .. import fibonacci
diff --git a/maths/tests/test_fibonacci.py b/maths/tests/test_fibonacci.py
deleted file mode 100644
index 7d36c755e346..000000000000
--- a/maths/tests/test_fibonacci.py
+++ /dev/null
@@ -1,34 +0,0 @@
-"""
-To run with slash:
-1. run pip install slash (may need to install C++ builds from Visual Studio website)
-2. In the command prompt navigate to your project folder
-3. then type--> slash run -vv -k tags:fibonacci ..
-    -vv indicates the level of verbosity (how much stuff you want the test to spit out after running)
-    -k is a way to select the tests you want to run.  This becomes much more important in large scale projects.
-"""
-
-import slash
-from .. import fibonacci
-
-default_fib = [0, 1, 1, 2, 3, 5, 8]
-
-
-@slash.tag('fibonacci')
-@slash.parametrize(('n', 'seq'), [(2, [0, 1]), (3, [0, 1, 1]), (9, [0, 1, 1, 2, 3, 5, 8, 13, 21])])
-def test_different_sequence_lengths(n, seq):
-    """Test output of varying fibonacci sequence lengths"""
-    iterative = fibonacci.fib_iterative(n)
-    formula = fibonacci.fib_formula(n)
-    assert iterative == seq
-    assert formula == seq
-
-
-@slash.tag('fibonacci')
-@slash.parametrize('n', [7.3, 7.8, 7.0])
-def test_float_input_iterative(n):
-    """Test when user enters a float value"""
-    iterative = fibonacci.fib_iterative(n)
-    formula = fibonacci.fib_formula(n)
-    assert iterative == default_fib
-    assert formula == default_fib
-
diff --git a/matrix/spiralPrint.py b/matrix/spiral_print.py
similarity index 100%
rename from matrix/spiralPrint.py
rename to matrix/spiral_print.py
diff --git a/neural_network/bpnn.py b/neural_network/back_propagation_neural_network.py
similarity index 100%
rename from neural_network/bpnn.py
rename to neural_network/back_propagation_neural_network.py
diff --git a/neural_network/fcn.ipynb b/neural_network/fully_connected_neural_network.ipynb
similarity index 100%
rename from neural_network/fcn.ipynb
rename to neural_network/fully_connected_neural_network.ipynb
diff --git a/other/game_of_life/game_o_life.py b/other/game_of_life.py
similarity index 100%
rename from other/game_of_life/game_o_life.py
rename to other/game_of_life.py
diff --git a/other/game_of_life/sample.gif b/other/game_of_life/sample.gif
deleted file mode 100644
index 0bf2ae1f95e4604f6840d5804846924ed72ea966..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 228847
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

diff --git a/searches/test_interpolation_search.py b/searches/test_interpolation_search.py
deleted file mode 100644
index 60bb3af22e0f..000000000000
--- a/searches/test_interpolation_search.py
+++ /dev/null
@@ -1,93 +0,0 @@
-import unittest
-from interpolation_search import interpolation_search, interpolation_search_by_recursion
-
-class Test_interpolation_search(unittest.TestCase):
-    def setUp(self):
-        # un-sorted case
-        self.collection1 = [5,3,4,6,7]
-        self.item1 = 4
-        # sorted case, result exists
-        self.collection2 = [10,30,40,45,50,66,77,93]
-        self.item2 = 66
-        # sorted case, result doesn't exist
-        self.collection3 = [10,30,40,45,50,66,77,93]
-        self.item3 = 67
-        # equal elements case, result exists
-        self.collection4 = [10,10,10,10,10]
-        self.item4 = 10
-        # equal elements case, result doesn't exist
-        self.collection5 = [10,10,10,10,10]
-        self.item5 = 3
-        # 1 element case, result exists
-        self.collection6 = [10]
-        self.item6 = 10
-        # 1 element case, result doesn't exists
-        self.collection7 = [10]
-        self.item7 = 1
-
-    def tearDown(self):
-        pass
-
-    def test_interpolation_search(self):
-        self.assertEqual(interpolation_search(self.collection1, self.item1), None)
-        
-        self.assertEqual(interpolation_search(self.collection2, self.item2), self.collection2.index(self.item2))
-        
-        self.assertEqual(interpolation_search(self.collection3, self.item3), None)
-        
-        self.assertEqual(interpolation_search(self.collection4, self.item4), self.collection4.index(self.item4))
-
-        self.assertEqual(interpolation_search(self.collection5, self.item5), None)
-        
-        self.assertEqual(interpolation_search(self.collection6, self.item6), self.collection6.index(self.item6))
-        
-        self.assertEqual(interpolation_search(self.collection7, self.item7), None)
-        
-
-
-class Test_interpolation_search_by_recursion(unittest.TestCase):
-    def setUp(self):
-        # un-sorted case
-        self.collection1 = [5,3,4,6,7]
-        self.item1 = 4
-        # sorted case, result exists
-        self.collection2 = [10,30,40,45,50,66,77,93]
-        self.item2 = 66
-        # sorted case, result doesn't exist
-        self.collection3 = [10,30,40,45,50,66,77,93]
-        self.item3 = 67
-        # equal elements case, result exists
-        self.collection4 = [10,10,10,10,10]
-        self.item4 = 10
-        # equal elements case, result doesn't exist
-        self.collection5 = [10,10,10,10,10]
-        self.item5 = 3
-        # 1 element case, result exists
-        self.collection6 = [10]
-        self.item6 = 10
-        # 1 element case, result doesn't exists
-        self.collection7 = [10]
-        self.item7 = 1
-
-    def tearDown(self):
-        pass
-
-    def test_interpolation_search_by_recursion(self):
-        self.assertEqual(interpolation_search_by_recursion(self.collection1, self.item1, 0, len(self.collection1)-1), None)
-        
-        self.assertEqual(interpolation_search_by_recursion(self.collection2, self.item2, 0, len(self.collection2)-1), self.collection2.index(self.item2))
-        
-        self.assertEqual(interpolation_search_by_recursion(self.collection3, self.item3, 0, len(self.collection3)-1), None)
-        
-        self.assertEqual(interpolation_search_by_recursion(self.collection4, self.item4, 0, len(self.collection4)-1), self.collection4.index(self.item4))
-
-        self.assertEqual(interpolation_search_by_recursion(self.collection5, self.item5, 0, len(self.collection5)-1), None)
-        
-        self.assertEqual(interpolation_search_by_recursion(self.collection6, self.item6, 0, len(self.collection6)-1), self.collection6.index(self.item6))
-        
-        self.assertEqual(interpolation_search_by_recursion(self.collection7, self.item7, 0, len(self.collection7)-1), None)
- 
-
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/searches/test_tabu_search.py b/searches/test_tabu_search.py
deleted file mode 100644
index e6f73e6a9002..000000000000
--- a/searches/test_tabu_search.py
+++ /dev/null
@@ -1,46 +0,0 @@
-import unittest
-import os
-from tabu_search import generate_neighbours, generate_first_solution, find_neighborhood, tabu_search
-
-TEST_FILE = os.path.join(os.path.dirname(__file__), './tabu_test_data.txt')
-
-NEIGHBOURS_DICT = {'a': [['b', '20'], ['c', '18'], ['d', '22'], ['e', '26']],
-                   'c': [['a', '18'], ['b', '10'], ['d', '23'], ['e', '24']],
-                   'b': [['a', '20'], ['c', '10'], ['d', '11'], ['e', '12']],
-                   'e': [['a', '26'], ['b', '12'], ['c', '24'], ['d', '40']],
-                   'd': [['a', '22'], ['b', '11'], ['c', '23'], ['e', '40']]}
-
-FIRST_SOLUTION = ['a', 'c', 'b', 'd', 'e', 'a']
-
-DISTANCE = 105
-
-NEIGHBOURHOOD_OF_SOLUTIONS = [['a', 'e', 'b', 'd', 'c', 'a', 90],
-                              ['a', 'c', 'd', 'b', 'e', 'a', 90],
-                              ['a', 'd', 'b', 'c', 'e', 'a', 93],
-                              ['a', 'c', 'b', 'e', 'd', 'a', 102],
-                              ['a', 'c', 'e', 'd', 'b', 'a', 113],
-                              ['a', 'b', 'c', 'd', 'e', 'a', 119]]
-
-
-class TestClass(unittest.TestCase):
-    def test_generate_neighbours(self):
-        neighbours = generate_neighbours(TEST_FILE)
-
-        self.assertEqual(NEIGHBOURS_DICT, neighbours)
-
-    def test_generate_first_solutions(self):
-        first_solution, distance = generate_first_solution(TEST_FILE, NEIGHBOURS_DICT)
-
-        self.assertEqual(FIRST_SOLUTION, first_solution)
-        self.assertEqual(DISTANCE, distance)
-
-    def test_find_neighbours(self):
-        neighbour_of_solutions = find_neighborhood(FIRST_SOLUTION, NEIGHBOURS_DICT)
-
-        self.assertEqual(NEIGHBOURHOOD_OF_SOLUTIONS, neighbour_of_solutions)
-
-    def test_tabu_search(self):
-        best_sol, best_cost = tabu_search(FIRST_SOLUTION, DISTANCE, NEIGHBOURS_DICT, 4, 3)
-
-        self.assertEqual(['a', 'd', 'b', 'e', 'c', 'a'], best_sol)
-        self.assertEqual(87, best_cost)
diff --git a/simple_client/README.md b/simple_client/README.md
deleted file mode 100644
index f51947f2105a..000000000000
--- a/simple_client/README.md
+++ /dev/null
@@ -1,6 +0,0 @@
-# simple client server
-
-#### Note:
-- Run **`server.py`** first.
-- Now, run **`client.py`**.
-- verify the output.
diff --git a/simple_client/client.py b/simple_client/client.py
deleted file mode 100644
index db162f43c78a..000000000000
--- a/simple_client/client.py
+++ /dev/null
@@ -1,29 +0,0 @@
-# client.py
-
-import socket
-
-HOST, PORT = '127.0.0.1', 1400
-
-s = socket.socket(
-
-            socket.AF_INET,     #           ADDRESS FAMILIES
-                                #Name                   Purpose
-                                #AF_UNIX, AF_LOCAL      Local communication
-                                #AF_INET                IPv4 Internet protocols
-                                #AF_INET6               IPv6 Internet protocols
-                                #AF_APPLETALK           Appletalk
-                                #AF_BLUETOOTH           Bluetooth
-
-
-            socket.SOCK_STREAM  #           SOCKET TYPES
-                                #Name           Way of Interaction
-                                #SOCK_STREAM    TCP
-                                #SOCK_DGRAM     UDP
-)
-s.connect((HOST, PORT))
-
-s.send('Hello World'.encode('ascii'))#in UDP use sendto()
-data = s.recv(1024)#in UDP use recvfrom()
-
-s.close()#end the connection
-print(repr(data.decode('ascii')))
diff --git a/simple_client/server.py b/simple_client/server.py
deleted file mode 100644
index c23075608a90..000000000000
--- a/simple_client/server.py
+++ /dev/null
@@ -1,21 +0,0 @@
-# server.py
-
-import socket
-
-HOST, PORT = '127.0.0.1', 1400
-
-s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)#refer to client.py
-s.bind((HOST, PORT))
-s.listen(1)#listen for 1 connection
-
-conn, addr = s.accept()#start the actual data flow
-
-print('connected to:', addr)
-
-while 1:
-    data = conn.recv(1024).decode('ascii')#receive 1024 bytes and decode using ascii
-    if not data:
-        break
-    conn.send((data + ' [ addition by server ]').encode('ascii'))
-
-conn.close()
diff --git a/sorts/sorting_graphs.png b/sorts/sorting_graphs.png
deleted file mode 100644
index 628245f3eb398f3617a994de89154630e1287402..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 10362
zcmb_?cT|(v*Dj&Sz#uYG98ijUHmWE^nka~fND)a0AOt~bkSM*wpooHi4oyKodP@i$
z36Ovef+C#+LRFBG1O%iLLhcF9e0SDe_q*%&$NeKK>pkx|`|NYh-p_vaKJQa=Q$v1U
zF<v${Hh!aPS1j1r*x_t!5FZ|H&@wd>P{YP{`m)iL%a(y7i{pIB$unWP%WL7r=_)$S
zn=0;ZmVdFqC{M2pzW!u#mb=DqfN)$L!iY(SnX(^$DfJ<0q%bf_ROP<u+u=X|dXnyz
z;rMJy<LX|zlyaP~^nb~Y&L{?mWDy8MO-W=jd7Mn<^7q%x_L+G9nU2@eTK!(JIzG3p
z)3aL6$#$tIIL(-iP09hn#sl<Y7uo+sMsn>p{SVEoo`3gd_57#z|D*XollybJ8U{z$
zP-FT%!iqTI#l^K8fr6fhy;aJ5U*56cvBP2Zwh|!=l`4VDU)J_E3Azj_cF$vHT6b^S
zw@uh8KMfJya0^QdAkfEsTe(DE56%r)5261Y@^8XhDKO;|hnU2}jMa_slCDiYb`iU?
z4#Ft)$xxsAU*HG^)yg(Bb18hYabRbiW;Pu2^=V*uJ53)wHk~yu@VR`iTBxE4ajE6E
ziuB!c7yK9CBaH#5owSJUG|!0Llp#BI7}mbIs(ow0RX0NoHSzkOg!W7OU`oMSWn!58
zXvD`8X|D$nRhf)k)4MI2eYl+-i<TeZ5QuS$EWOiV5+6q1n`DenV&-@I8QToE)TMzU
zGt%O4J!*0dg9<BK7=i}dS8k;bnCa@!)6aKbkkQ#)eviSECU?6gKTAw+&t;>kba6b6
z%#ca?#7Vlk=kW8Z@nR|AOPk?J&2u_SAH#oP_AqzN$aCxK*a#h3@DUX^b28yixxR_H
zArcL{ksd}Loit_8H_ZrpG(uMM_r!?Z>FA;Hex%%H^N0^4E983vnm!v4J{M56IX1~;
zOcpJU)(?H|Ifv_?>(0#B11BNdSVv&e3E7H`3sp7FovEevw7kTN=?vW`?XgVJ6(1z3
zrF4znwumfmILX+~W(N7&<!L+YtWn&Vdkkpvq-;aD4uiqY4imW7I?@~xu=7q7|9nxG
zzEG_tR1rR76<+XBDdR13ZNSVb%>H|f?(Q9!;msXYu;NXdP)zpLU#F^8r)YcMm-ZCt
zkr#aD&B;CyI|JD+1Qp{5>%CUV-OFTwuH9{cW12NoMAc$YcuLcrM>$y_eEFe^Zrre9
z^IE?@7ka~<u+^)m6Y%+^vg&H}?vyA2zA?t9)KoE!RrLrA-%g8YAorAvL=s7xaZ)$G
zH!$Dp?&?FA>aUk0%pwSpk;I4WFyqnjfXVTkNWVS<(SjjFgboAPh1@QCY#1>st#S89
zXEmL<BFTKAx*0JoKIv9n!i-m+xW?F7NB-EE*u-xZAhFGA%^M>~lkRxJ{B)pD*#{-!
zaPEmy8}X95c=GDbT9Iz1AI59!Z6(z!YD1fF-9AEfNd97|<0R1vky&?dG*u#aKIdJG
zF>>jT{;<X7@IJAXPjcA&V_N?C;$ClamPe2?uCD?vW8js?k6jGCfU#>-Ym~%DE{0*=
z#|ZRn@QbU-)0yVG5xMF63!OVc$1@pAt~pMW{sJ;XmocD=p)z0}*J+d`(L)uS=(ST3
zKTcVfU9E-CfCl$SM<pYU!9wi6D=~j4bzYpT^Y|bpE?zCrDkyVR2*>Y8$4u^E)&_5x
z33tZ{qzy~@i8Y*l)P*&otd^FQm7RW4SI|Fa^^u01O`n;&GK^V!*ffR*2Q&3OZJzox
zjId@*u)L+)IS)%reG#$S9`PC1dmW))fK^55oVlpP)V*oa;z6T_t>sB}Z7|vpy9Vj!
zoUhw7csq|&yP74nd-c#Uf70eyrk3~%ykY+Mvyr&10_C6|-xh`&=CVc?b}uN2My%JZ
zb?WSmbRD~J|4nZbVlk+}+m16x^ishTwtMTW#!}O26;_9auI6pe-8;R}=5r>@p0I%=
zkQRd4ocuPF$fPX92`nKUnHsTNGZ<z;Ip7k4MXYSb1s8&qBr&RYmzaA?X#1jC#oX%%
z<X&i8PiHnt6;g&-5>>b?x!qxyu00p1PzJ-4{%fa$9a>}=aoS8ipx}uQ_~L<228Tn8
z31e|Fx`tof7UJ~2c=X6I<f?OWa;AoMS_Q(-($l9z8Y+C|x;-Nv#f@b%$l0oNIW@0#
z{Aq5*F#CelXy~eOolXz-&mlyYYG=0ovl{BP7LTQMWDmVcZcjdB^Lu8d&$!=^GZ$5N
z`=go7u5KR**<~9SYkM_(cUscwScPnJ9g>7LQlAKP+8HG<Mi;gYTwMO6bOM!fn~=2!
zP_8V78@&}R*!BIqYqzI}ucNQ!LdJPlQyBA*-+`d6YYm9+%2g+E%sQ{}bk(kQyjd9a
z7BoAplg}sbvExv=T{P|m3zWQ8YG)O^U9*B*)Y4DebmhKLm5|vmtT$EUb#X!r+9#9l
z{54&(-l?L*lhB?>vwZsBZgCaghBrz&={%>s_2nU%F<`2NAr8TInl*zNBRkKj9=e@J
zx<ux#^aa$ojXh{T7TvDp{q0(#J<@(j<!;CGg@&vAu)(9pu#qYC!}18cHuCq_H_#CS
zL>Ik_UhsoSmvZo%jwFuw_vma2btiu9opA|AQPM(GO49t#2-U-CH=D-J_h{epud)60
zm6y?@dfnaky7F|fJm>N)q|8Fw@{+geshej<NlN6V`G&WL-eLs)_(%1HXi@vqA>C>C
zwF3X<x&(VdcN46A+SOW?nfE5J6It?O=N&Men$+ZkVYxkK9~pvNo9}bRIt@DcePhfr
z`Wse}(hhz6?66($L~{Hzwwb;}Abi|j5hbTs*}v)%Uu7MaHNXBYabiRpesfYV;zWDs
zMdfyjh9v|gs13i}g>sR3c>Ifj+^7})M~WH(HJEXwb6AqmC+Unme~~lK@5|FuS#JJb
zzMX#|zOUF!2miGgns07PxSNNUnLQj^9<xQO?=OD{)>CI6Q9C5>ftpg<*|NSebp7*^
z<!v7;3X;~bPFp|{$-12uDEzhyX-BlyxYFRlN4~t(7p{vzn3cUm=7DWy%)Gz0Jw%Ro
z#EHF|hkHdV4|#v2#@+hqCBsS7gp%Z@^utK5cH2RWfz@w-o%9;bc4fE<!r3_G=Wp~y
z3)u<$o8<h5v}K><z`BM3WZ(c~XDl-N62p^Enq|FK#Lefb_)!O0LGE3pNrqZMrBi$1
zo%fFm&fF@@$Kf<Ze*-hWGXv2_{)%1T*XXVUyRda4h3uMbazH@hMrWFmS@!m4SKfA@
zW*Q6)f3fj>JVQjmCV93yljg`C8ENo#p{ldLp1@eFf|L#a!EvC!<An_0X5P97@CWiD
z#<sq2WxBobC0LfA|HAMK#we_%6pQV_vHJ+tv5<B&MnKY3=IXQi%8*Mfxo}$ul3e9X
zp%i5+j!B-od+qB6(769g>%+1gJaVYKmh7o!8;|0FTMAa#hb-3mZjJ}2lhuRQ=6%0)
zywKx=J=m0H^EHs%>5btXEh)-MS8Vw9=UTt95_GpVGwenSwG|?V<6e3@ogjZjIOD<t
zM-Ml*)348aja?8Gj8v4Y@TPArnemA#qTe34+LAlK4!bdM*6G7DbW8JK6c=BAe}Qqe
zlX0rN(dt}JfFPv!Riv<E1q`qvTW$MLU9a{z$K;M@zn?EW+gtXhQ^QLU$_Nr`0-|N-
z)n&pu$(9{v_AA`VKFGO_5ZHNdxI#MQF#j=474e%#RvjUiFq~-pn1cm?znmJC<%g?}
z-Pa$fM<IfLd^|OPwyu`Fn99N;HPqc35o^ou1&T(!8ckZ**)-d&lSmRnnA%7vE^I~)
zQF6gy=CGIHQdj%Mjmp@>nQooUF+IkQzC6PLz`m3Kg{}qb?2D=mUZ<`BL#dgH6jm?`
zx}dpOGXUm@V-!Sh03vKYaGk?a2p929M)FKZD1BqGi=E`tqhqy&TkY1uPB}IBbZZom
z-zY=)*yhzBa@bZJwX}?vZmKbpytXx+=qgP~we@lrsbH}?1;Nd1=5{uPWQ)RV!M$cb
zzoN{fA-eGapOu0r1!=r+wo8i#(4ldC4=ZQAR-`aIR)SSKn@id8$x8fi!34(^E3~JD
zHhTresUcG<pb$W00gGDNg|4(w06qv-u(9FJ14S-@?KlJ;IOTu-K$Dd3%rE*}@@!uo
zk(+{i)HaF0va-6hS3j$OWA*gz_4rjn8xDp&A(NIGm+<nI_eSd!y3$qU#(f7&pgJ&0
zl@{2HUYRz>&Nc;D<z17SyEBf3>%Sa6dAGXB?DYlZ#gW=Fqc=EOc_Yj6Gd}aMc35ZR
z+sCA8SXqjkRbjlix|-I-kd1|!z?CWaM>@+b9OQ;Jh+Jw98BoWs;Q=yWz+#<KdxGzD
zyt)g<yg7LN6SbIxMIbI*bnAViR|c(d;Xitz!l)(It8I!7)VcJ6#{wAX4Zwhu7UC5D
z$}>!KsTT*%6rCN%K?Dv1HXzawaAcIl!&=v#EP2bB+%{QV35*>F_pffs=D&c<2o?9e
zRcoo~ysC=I-C9dv&pn0rPG6K*w+2Vu=}}Q=l0kBO6HCGb9%Y?yU#_1A;J@UK)`{j2
zR~arEjmFmwNPpIcM9FOMB8dz8cG99HUDMA)Ej#sp&bAi4mt;`+8KNj}X>d?)^6V%5
zPn+PJ^fi(FBc5fWRg(snTi7E#FgDc+nGuXQ>x$TjZ0zWCF37nqsctMFZ>Y<M*7ka=
zn<2tgM-N~$LbocwWHVRfh#kMvcrmcPScAo3aL{#}rt%LCcg_HAocD362Sb^k>V9}Y
z;CoH`Zxz5^bD!&=YH^O;iB&st9-YNE^ZLU!$J3%q!QmHJSGyEsc;P6IIML-|rC=vb
zV^7~^4vzjID`2&W4jwlsxmlFyZ<8ca2E5f-!MZ^wWFwzNgV$+8N+wy_8qL7dojEL!
zbN5DS&anJDGi-zGzD^}ZW4r46+eaFFT+`3q(W8#mqw2QS%IzA{LwgQL1WIKFOaxJq
zZ<!jIX|Ftr<hrzIyO+76Cry7sp$SzDz2(vG^QiTn`Bd{@`h!dR+~-$GR4TQ<_2Gem
z_X4`Fy&4zm00P&p9uG8-Bd_-8W-Gq^5><sjgaXSWyRS^OSue+(74E@qHD#di8XzT7
z(%IXZw(bD?QEXihy`bElqPNk#O4V4>Ew?phLA6)Y$_EwiZykeWR#>#62Y|8Y>A9>B
zFHJx?{OKUkrR=WuD2d0~Xf2_uyFcM1jcbJ}xcS8_-D+b=Xb=k2G_YHh2?6SPkz6eg
z4r46a29&h7r%Xi)GC0wWf*vA@w_iRMkhC8bwR_Sw9#oVS>_NUiFcKuWw;XfJ$;k=$
zh=iP;%@eGgSAi_QC9r!{N<ze>g<CCdc0)6IVf+Tj#xe#S3>2W8ug5gzUJp$9^0s{~
ztX<{)^~m$uWT;pLu=)to6~C2rFnBylZzD?@cL31g?!n&P=l)9*nX^6F*(RgUGc<f$
zg12YVs;4$Vpe!&}YOe8o>%Q1j+`2=xBBZlY%9E<_zH`Ep^=p+=8U`ltL2CnkQjPln
zFb@xeP?e||!J#4JyPQpIp;>lT{LzK+#sD=BEFO=)ukG>Xq)B>m_l4<azAJ5_MF9Q_
z_JtoYxZpWlfj&X~cq&_dA)DnnOc=%K-XvZJ<W3jYDFdhYLLMMm*x$Gq^aZbIM%C-S
zHIUZQNe8A8bLA^e&mVZuJZGOC)TX1H$O|+n6{>}{(RdW;rp<BeV8ujPJ4176EkF+}
z&&*cJD%?H5>SSrt;dSh?<}KsH@c?*zjSFZzdjn|*XosoG>TDPJ_AO;e=;vrv0FNin
zH`W`XolZO4Oo2O`b4iXjP(}gc_9QOfzLBp6OvLkCE#MJ%%VIfRd-h$2-tNGAbg79(
zN8QZ3T0sBasKf_d`CT0_ZUCj~&~<owNWU4ROq><Pf)^^=`&n#(N-V2Bv+Dz9HkN~-
zJ0|kuL=>)r9Kf$NGO4uY`M73Oa;)EhI9s%1Nrv0UPi?<09zJ>FS{Qw!%Oxn0D+j=x
zUBGyXs-}?An!LkJXn*4U6v8h~vdr5x_A{s^KtI$pxbGh~cwUttmGV+M$eZLLjAY&e
z=_q-HT<u!a7ANW|EiWcKH8vGl>r3hP<bS`*LgY-TwA<cBIZu=(%wLT7JZP+3$xMHI
z!S$~vf{I7(ziZQs3i{hG2TDPvdN)q4-4)KNt7w)26c9}i5K}4c4LpRg<~VTB^S6pz
z+sZ9`qyf~ic9~VUA!jV`A-43AqVUrCkA=J>wfxakM?x)fXata(#`-0Ub;ili2lsM_
z9=n*O1)qDS-LSah*A#BQJ<Bh7v8h4{cPLRpCw)BO>Z4nx8U;pgVtce8aR)<IyVM8#
zhV0U6?}jmG2-J_0M|FaIS<afnRrc18?@M4TOqRxD5x>WvtCzI05=@a&?>@&A$wX2)
zgoC^0NHM3prol6@Ccq&9gWJO9<VZK#ArRRg;>G8VL)z^qno+!D_r!S#;6Yl|J=oJ>
zuXH2A)$Zx9tQ7aKs0!?%unfhP*Rl_n5^<0hUSr%u$qJf%wFcsT!AxhG`tN7nI<!Wi
zhm~T#q{&<V*=z(!NP~}DmDV~YjJX90Nj+B&0)DB5lz(zHYHVY1wED7b*v{I=iyYJ8
z#t<ZRu!J0H!!EM8F%_p&SXPdcrR_D&q}o;$4vszM7w><m?9|_zqhBo;-S>{`zV;RA
z5D9cH%Ys1gFfVu+*6e%i^7$%2zb~a+9}=|eI0#$>8Y@!Tujh|}?f2=|+i;#N3AhP(
z#2Xvn7qWK`K=>kM+q7W-AORT%1Nq1p8J_)tx$7W|$=28~_ML|%j2H_meQ};7Y=aT1
z8pv$3X$EcWP<QD@KTeH4(>3-k5P>ebPujMy&(9veW^MR9>qv!%v?Ykfs&2&ed(nCu
zaF)N?op5Md{67Q2m9N9oiMm;f^yL`ceOkZ9Sc)LrmnY4zsxP+);f#JjIR<P|&BSlY
zOMs4e@=w0aL={YifTEZCyGOs2peFI;sDVcR#nSm8Fs06IA<SgOGBkR@mlEj*Y^Mk~
zl`uP0(M!n=r=qH+R)`9t*;1w@nSo!2Uu*bS*xA`>1}-}UZ+(p!xK}?;`ldWh0~l(z
zL7#Ey$;uQ_vVYA=4x&py0EMnKamq(Z$lH_zk7-85OoYdWsBM3>qD}-Ho5Z|}tOaql
zs=XXAMs$h?AX}iUR+u!wf>{dSP~=6xX9__GBjmQr<8}T`fpXgc<^>n``*DU`k)}UB
zaYljuMN3>&xWYzL1Ty!dQ^|}KMX11(Z0f!2z7D$=Ws>sgO5JC|p8<YVyUmzVKK?q|
z?F5J@9*g_Ca03{%4xj@9u<e+g($!i=zXvJY=-a*=7eNY6LG8_=c<J3BwulrV+!mGN
zP=;|(UxCN0>J)GpfUGLDyISieyyQlPW>kiRhZs6F?91Y#hGFp>aV|7)?|ehaFcliF
zJmz8g-$7;|M?a>&%DJ<@AkBVc%IU)pU|=d*{($=x0=nqp2fO)D_1=gIFuZ^(`?#;H
z6;iKwH-hmo8D=L1UyqDjf5)eEH}8Ox(49y5Jk|}xuhLcAEi|W}o$qfGMZC5Tnn@9n
z^a0*N0R>2uzb7Dc?z>wn)|=C;lH0gw1)E!4f&&n##1D&`l!Nyv0CPBHRAZhZQWY=?
zD=RLN<%c0r;jVv4fd%?L243OSnBc%!cB-8h23n3HfNS`7>TUEp2#==Ixa2@o(X{&P
z1n@tc{?HbONORyUuFXb?p|hGslKEIN@GKei2@Voy5rSC-JB07c7I3_m-Z`V?GH^wB
z+kfSZ+ONGYa#S!;lXZaf-WY_%zpgCr^&l?tk~_Qb5(8&@WjrUEG%^BYXA3n~Kc61}
zSr+g4()uBg83J}cLc;Kox#T9)JO+z>C&M<Kb7V>4uT_yS9HlU$G#GtY15zBxW&SYt
zc{7;N&00M6ujBiCer%u5r)~f~pN|it7d}0Fs?e^{U-cKufN?)7F%9p#No`qRf^_Rz
z7uzI1&PEgIM(2B{oql}#Xk7+HbG+RrV}N4s+kbQgT;^=I!a=xknxaW#z>?zFk{9rU
zgR!~m;v)DF1}|9wsV~RkRthyo{}ZCmwI5X_F!0*!BkI<q$No>HYVUu2rxLog{0={_
zryacJ=HFOZscbvnaKRiH<qZH_4Zu6{_DW|Tra0d#HvdVH7RlA8_@E7Lm7fv~kwcLX
z4x3+De5#8ih~C!o?;J6Y{t4>0^!4>&#;Or}yPhMDr>1Xa*8<c)b0a|oLxH>0Z9KLe
z<XXYSGm|AKiw^sN0VO!;@xdpg63Rf4tIPpb1uk9)jb*moMgekbHr<|R#=`F?t1;9W
z2a`-q)eJLZ0DgA>iaPmkq$}L5NAm;oIAsf*@Bv|zQ?7FapezX2d;m2=y6S9Rg&hO?
zmxQT#-t00YD1-*UJkJXbadt?sW`C&N<<Cxl74k>l_XDQqfi>=}QUg%#E3As>P=x;x
z$<+(J!Uw(4U|vn*u_18-VdekjQ5HKSh%RBR8_d>A9HV!L*IIYjds&OO0vZ*WbcUB4
zSA=+?w~_8(Ee-$&mkUMKsahK@Z{u`o52NLg9PA>OtSoQ|4kkiX^)={t2QGGzmX9KU
z;YKg?#S&-s)t2=EC9X9Ta|7iLN)zrN6QQtf0=^D|)T)2D(rKXL&inr4Gq(V+X7X`o
zzNvYxL&b8+U236TWtGHznT*XMKp*k}qRH}EHw3ND76{A1@|#083k~8#3L1Roa1Ol?
z;EEH~)b(=4qfQ0nVLBTmj${|XSa*N_nBO_kfJOxAMb)Tny_X3%jDXfR*DDho9!Q6z
zWrepc(4-vtl(Togof=@F(TTL%f0j3X$F0p~phOZ3>hCyBYjM^8Q=Dmillk+|6m9qS
z)nM+3cHn*7=0wN<pcB=K?_QmE6-nU#{apTiI#?UIfe3H($8?co>Yd9-g+96rQ;^9m
zF>QuIvy^n`*G8%r(0UafP0Vr1I&>&sG&`ifrw=xKsKPDg>-!j2RalT56eQYL6D2Ye
zj%rw302QZ8&KOw0E<IJRjHp^a<k$7{_}W&K!QFx-g4wO<8guZN$8QxUO<%th6BDZ%
zePH^UucjPWj`6<7AF8;3cl7=8W2UoOq?A}@^*0%*VUfN^U;jK|+`qfMYIoMnK&UE!
z;>W1~4ms8MzT;8tz_S?%Uk_(*T~W)uKU#;l;eRBL&uQc_KyeotUMG9`Hx2W@z4mQ?
zd=h}-zEOeeNprc}a#;_|4~pp2<SE30-neIKEre744NMQ}%Ox^o?f21-vkQNa2Y$&)
zq?Pi*wO;jAk1VP(HVA{WEK70V`uU<n#c~D%wUf2v>Kp+=dsFnGHP>hSplvxGfG*gf
zMEt9<z!ZCh+kAO%qAz-Xz@5yIEwp(OgvNdQube1h;0Sh#*}F~fW);gez0b;BdTGBx
zrLVGy9FW@|c;BM>BmP5`3|pSoSv_c4#*rEoxHXCUP(@_<Z>1hCoDL^iKUJv#A9*c*
zPq-`~=;s>bo+#qIb7W(Qjo)}$NKpV~*dTltUgea|US)%cvAlx^-tx4+-&=K?r$x~Y
zZJ$6Mf`A^s|8QJ43h+E_i?;X4xn9A}DgWi}8Fluvb?HYS!@upX@P00F%v&|(99<Kr
ze#*igZSTeDAXGNwS^OKCHAzl`(`b$_s30WUmCt5Du|wTFEvfK*jSmZ#;)vksAAQP$
z@<?fAC2D^!s5@1(EG>cUnd7?G;nJv|DraS3M{oIaegWo0+~8^PK7L7u{`=3J-o|wS
zJz{VEVHR5D9`|#J^Y=e&1yu$&2u9vSPb`9i<Vfvq%BqLo3+WSQ2YW{S)<!L0?PbO2
zGd9nSTy@nY?q@-0q5UK3Gbb(@vZcm)we$=A(Z}x=We%XMlz1<#%-z_RBOF8Ux&#_D
z4UwHhUz)k_c%*Vy)Xye;p}aJ4$dNYcxHqRmk|^`;s#i-2!<Pdjc;<G+)QwJJO<{po
z3(swq*_AZG!}^bje-bHc=gb+WvwM0>@V~?gy6wpV=_4|+L}Np?4<w8sn@HT0?|38_
z;(N82`a*^+&OrT3DIbu^12=D$sK0HZv7Ou5R*j)?a~`UAqjOwk9Dt;=AsY*8vII-@
z8oXLwx=7<7Ce@&@d)YQO1Z$YcCJ!qYUtR(0VM(zDayyC10~YFE(rJFIrrtVWiN2f;
z_UMUfi`l{e9K_hwc8H&6UqBpojHd<Zg{5f#W$x`1dR+nsUdjj63FmaEbbDd5Sup$e
zrhs;v{^_)`Geuz8e#}zwLzh~jM1H*Qi6a{8LxFG^edy^S{<qZK`c2($CLBO~&{ein
zK?RHbJq5#Mog30ct^@{eoX0_cSGp0V98yHfHiylH9S0{5XAkbHwC-4vE}_9*0S8MB
z?VEv5aD$P>=EmcZmGf2m+PTG~;vi0Ser%lREXRRD6L&zl+_#p$k_onTp6=eB3&WM}
z!xeYjKP8_jDKGEl%4?eE-nEI?-}XCzKu}nBMf(LDb^J=a{N0)VTa7(xg|CnQNSxyS
zLAa4wV4I2t$t@^5$~89o(MT%cyMdxl!Dc$utxu6k_f3Nbo~(KQ%O#tpzz69%A^vwJ
z0js_R@O*&xD7Zq6Kcf6Dn)=a(%3U*mPG@HG8(&X;vzZQ6Ps-uuE06>fu+nz`Z-uHz
zlF)|0KbY>m{G}BNt{H2Q_f&DsYYQ@zc*B!LALx^}c%bo{1g&N~HGSbF@-D4>Q~<xd
z<UXE8cuDGc`JAe#rPUnVO|Mq)+8jhiMH-}lFAy@z-%iE8V}PP`k&I!2kWEFdL7c?#
z*a1I|e*L54)pCnr)XJLay&%duP0<v~zvm!rE{w7*7fTk~^LxzqIMRTAg`Z>~YG?UY
z_rcU(ta8qHITmX+{UP4x1+H<PTi(vsT3u@VhVS}f@bY)dh)$+ShT*!Lc%fP%HDh9T
zff+<^igsr*Lq-hrTXMs4pECd(|725~6-+Hr0i5MsB^RGaet~hC%ewVH_5M~|-jNm2
zJczNVT|!@^h+W}_V?ooW+<TllZ@o|R`fOA5DY|4h+<&p7Cag~v#IO}r5MZTs_f`@I
z@{N+Jz7u-FzWY!jn41w1eJ?BT=!>0qxdF=%zAQi6mMeZ{i2n$<gHeCuE>e8Ck0^?{
zmEyZj>}gP34Dz+sthtlP7Zb_l8|6J7nTW_0f1ZB$>**!x=(*XZsyozLKHcYj>jt#s
z@{7P(lXRcj%yZxNY4*D0q31hlART<dF6`!$@-hKV`3vF4wGGrAD4sMNgfjJ`9Ivh$
z;GFTlU+<}f-BOoQm3enlD7T(SOcTvDv_cHpLfA!KN1Bynp25&90Q|gkxvVZ_cV&Y0
z9`q88p2zI~A3Tix+aaGPDQ5e~;&yB@d}NoXx1NC9`1S1>9K<S<xv>{>Tii6ZsZ5Et
zPmV&3)AO|p0}d*>#W}j&t-^<cXnY)LY<i|q1mu;UdN)v=-N)Zy<P`KfSQ!1u%?Ptl
z3w5be$urL2{r95V>JIpMZ+R3)X2*|nK+Gn|Lft_ghZcX{{b?yR4Md&bM?ZaZo~^SJ
zpq-A{-(ag5KjRFzQq~#ZH+|0Ik-pDa&wRP!XI*TSyf8LoGj%E9%BEj|&`Kad0e3@A
zUI_#?b5q|<;Q)>go-_dBb$-_;Wx+H6LSl~mQY`-b`2NHEX#<*0*1o(q9Q&i#pr6uG
zpQe^*->|j^;gwBR=(4O$!AR+=D%K2;8o_*<(lpucvvI606e<T`3hkeYt{ln-D!qx7
zN->K$l;l^ZLa=;*v7BfYZJVPOfH#NoInRJUx9s`!IL#6s3ygx-ZS8u?6<?kxArQ2q
z274Y_B3F%4xJzF0w$AH-uAFBs^Rfa#kxr7gh?2)q+OoAKH)yzA`tY)>1PAC5oF8h@
zeLc$ZVp_5k7f|iv!YtS}scR4^ht{X0J|hh-)|8xQsxw%)N*C%m0X2Fa+wfD9YbR$o
zS<-kx7gLq}F0DqtTI{z*9T$B0+3O(CEAzBovXKS^Y{S3rX~5lIk|(H_#~;&DV|~+M
z^6K0PB9Yi|8pM}A!N1Fc*Fc70@=t;ACb;g&mC0pYGzQGNj^O-|V!Gi?aqK|fW6G?u
z_3-e^@r$8b_r;VQAN}17Zpq&*f=WOED4ScYUvSOzOYL&0CVPYe5J-9^p`&?B!#lq>
zN?5@Ld@g2i;0CzgVcn0^gX@j~km}tQ0@q9PPyU96LKZteVVs)3y*k(UQ%`X<&ugG?
zY6NZux~>X+XoBy5bp{sw?^|7<;D3LN2DbR0Z`A&WX4c?;3jq1jKRy553}pV(%#!*4
pP42&@`_JV5TMO1;-wx)1HEY#83w)so_@<D}$iVbUxt>GR{{l7)3!wl2

diff --git a/sorts/tests.py b/sorts/tests.py
deleted file mode 100644
index ec8c8361912f..000000000000
--- a/sorts/tests.py
+++ /dev/null
@@ -1,76 +0,0 @@
-"""Test Sort Algorithms for Errors."""
-
-from bogo_sort import bogo_sort
-from bubble_sort import bubble_sort
-from bucket_sort import bucket_sort
-from cocktail_shaker_sort import cocktail_shaker_sort
-from comb_sort import comb_sort
-from counting_sort import counting_sort
-from cycle_sort import cycle_sort
-from gnome_sort import gnome_sort
-from heap_sort import heap_sort
-from insertion_sort import insertion_sort
-from merge_sort_fastest import merge_sort as merge_sort_fastest
-from merge_sort import merge_sort
-from pancake_sort import pancake_sort
-from quick_sort_3_partition import quick_sort_3partition
-from quick_sort import quick_sort
-from radix_sort import radix_sort
-from random_pivot_quick_sort import quick_sort_random
-from selection_sort import selection_sort
-from shell_sort import shell_sort
-from tim_sort import tim_sort
-from topological_sort import topological_sort
-from tree_sort import tree_sort
-from wiggle_sort import wiggle_sort
-
-
-TEST_CASES = [
-    {'input': [8, 7, 6, 5, 4, 3, -2, -5], 'expected': [-5, -2, 3, 4, 5, 6, 7, 8]},
-    {'input': [-5, -2, 3, 4, 5, 6, 7, 8], 'expected': [-5, -2, 3, 4, 5, 6, 7, 8]},
-    {'input': [5, 6, 1, 4, 0, 1, -2, -5, 3, 7], 'expected': [-5, -2, 0, 1, 1, 3, 4, 5, 6, 7]},
-    {'input': [2, -2], 'expected': [-2, 2]},
-    {'input': [1], 'expected': [1]},
-    {'input': [], 'expected': []},
-]
-
-'''
-    TODO:
-    - Fix some broken tests in particular cases (as [] for example),
-    - Unify the input format: should always be function(input_collection) (no additional args)
-    - Unify the output format: should always be a collection instead of
-    updating input elements and returning None
-    - Rewrite some algorithms in function format (in case there is no function definition)
-'''
-
-TEST_FUNCTIONS = [
-    bogo_sort,
-    bubble_sort,
-    bucket_sort,
-    cocktail_shaker_sort,
-    comb_sort,
-    counting_sort,
-    cycle_sort,
-    gnome_sort,
-    heap_sort,
-    insertion_sort,
-    merge_sort_fastest,
-    merge_sort,
-    pancake_sort,
-    quick_sort_3partition,
-    quick_sort,
-    radix_sort,
-    quick_sort_random,
-    selection_sort,
-    shell_sort,
-    tim_sort,
-    topological_sort,
-    tree_sort,
-    wiggle_sort,
-]
-
-
-for function in TEST_FUNCTIONS:
-    for case in TEST_CASES:
-        result = function(case['input'])
-        assert result == case['expected'], 'Executed function: {}, {} != {}'.format(function.__name__, result, case['expected'])

From f30f8493e6ef91f9d95ae88b0d2b59ef1f102681 Mon Sep 17 00:00:00 2001
From: Anup Kumar Panwar <1anuppanwar@gmail.com>
Date: Sat, 6 Jul 2019 11:12:26 +0530
Subject: [PATCH 079/348] Updated README

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 9edddb60552a..a609dc077a77 100644
--- a/README.md
+++ b/README.md
@@ -129,7 +129,7 @@ We're on [Gitter](https://gitter.im/TheAlgorithms)! Please join us.
 
 ## Compression
 
-- [Peak Signal To Noise Ratio](./compression_analysis/peak_signal_to_noise_ratio.py)
+- [Peak Signal To Noise Ratio](./compression/peak_signal_to_noise_ratio.py)
 - [Huffman](./compression/huffman.py)
 
 ## Graphs

From b23834062c5a78e2aeda70336eb66c07c7209181 Mon Sep 17 00:00:00 2001
From: Anup Kumar Panwar <1anuppanwar@gmail.com>
Date: Sat, 6 Jul 2019 11:14:55 +0530
Subject: [PATCH 080/348] refactor

---
 DIRECTORY.py | 50 --------------------------------------------------
 1 file changed, 50 deletions(-)
 delete mode 100644 DIRECTORY.py

diff --git a/DIRECTORY.py b/DIRECTORY.py
deleted file mode 100644
index 434b2a3dd3ed..000000000000
--- a/DIRECTORY.py
+++ /dev/null
@@ -1,50 +0,0 @@
-import os
-
-def getListOfFiles(dirName):
-    # create a list of file and sub directories 
-    # names in the given directory 
-    listOfFile = os.listdir(dirName)
-    allFiles = list()
-    # Iterate over all the entries
-    for entry in listOfFile:
-        # if entry == listOfFile[len(listOfFile)-1]:
-        #     continue
-        if entry=='.git':
-            continue
-        # Create full path
-        fullPath = os.path.join(dirName, entry)
-        entryName = entry.split('_')
-        # print(entryName)
-        ffname = ''
-        try:
-            for word in entryName:
-                temp = word[0].upper() + word[1:]
-                ffname = ffname + ' ' + temp
-                # print(temp)
-            final_fn = ffname.replace('.py', '')
-            final_fn = final_fn.strip()
-            print('* ['+final_fn+']('+fullPath+')')
-                # pass    
-        except:
-            pass
-        # If entry is a directory then get the list of files in this directory 
-        if os.path.isdir(fullPath):
-            print ('\n## '+entry)
-            filesInCurrDir = getListOfFiles(fullPath)
-            for file in filesInCurrDir:
-                fileName = file.split('/')
-                fileName = fileName[len(fileName)-1]
-
-                # print (fileName)
-            allFiles = allFiles + filesInCurrDir
-        else:
-            allFiles.append(fullPath)
-                
-    return allFiles
-
-
-dirName = './';
- 
-# Get the list of all files in directory tree at given path
-listOfFiles = getListOfFiles(dirName)
-# print (listOfFiles)
\ No newline at end of file

From 1161393b39516f97b359a14dc9043d298bc897be Mon Sep 17 00:00:00 2001
From: Anup Kumar Panwar <1anuppanwar@gmail.com>
Date: Sat, 6 Jul 2019 11:21:08 +0530
Subject: [PATCH 081/348] updated CONTRIBUTING.md

---
 CONTRIBUTING.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index ac632574e870..03de387a8acd 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -107,6 +107,8 @@ We want your work to be readable by others; therefore, we encourage you to note
 
 - If you have modified/added documentation work, make sure your language is concise and contains no grammar mistake.
 
+- Update the README file if you have added any new algorithm. Only entry corresponding to the algorithm is to be made, not need to add sample data, test files or solutions to problems like Project Euler, in the README.
+
 - Add a corresponding explanation to [Algorithms-Explanation](https://github.com/TheAlgorithms/Algorithms-Explanation) (Optional but recommended).
 
 - Most importantly,

From aa663037f6f5d09b9cb47baa34c61aa1d7d2cbe1 Mon Sep 17 00:00:00 2001
From: Anup Kumar Panwar <1anuppanwar@gmail.com>
Date: Sat, 6 Jul 2019 13:47:56 +0530
Subject: [PATCH 082/348] Create FUNDING.yml

---
 .github/FUNDING.yml | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 .github/FUNDING.yml

diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml
new file mode 100644
index 000000000000..f07cea8a90f8
--- /dev/null
+++ b/.github/FUNDING.yml
@@ -0,0 +1,12 @@
+# These are supported funding model platforms
+
+github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
+patreon: # Replace with a single Patreon username
+open_collective: # Replace with a single Open Collective username
+ko_fi: # Replace with a single Ko-fi username
+tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: TheAlgorithms
+issuehunt: # Replace with a single IssueHunt username
+otechie: # Replace with a single Otechie username
+custom: ['http://paypal.me/TheAlgorithms/1000']

From 1951b4ca79665ea34253cd845540a34cd656d2f1 Mon Sep 17 00:00:00 2001
From: Anup Kumar Panwar <1anuppanwar@gmail.com>
Date: Sat, 6 Jul 2019 14:04:27 +0530
Subject: [PATCH 083/348] Update FUNDING.yml

---
 .github/FUNDING.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml
index f07cea8a90f8..514c9327e231 100644
--- a/.github/FUNDING.yml
+++ b/.github/FUNDING.yml
@@ -9,4 +9,4 @@ community_bridge: # Replace with a single Community Bridge project-name e.g., cl
 liberapay: TheAlgorithms
 issuehunt: # Replace with a single IssueHunt username
 otechie: # Replace with a single Otechie username
-custom: ['http://paypal.me/TheAlgorithms/1000']
+custom: ['http://paypal.me/TheAlgorithms/1000', 'https://donorbox.org/thealgorithms']

From cc4cf3ece7e10f15435365ee331c3530f6c777f5 Mon Sep 17 00:00:00 2001
From: Erfan Alimohammadi <erfan.aa@gmail.com>
Date: Sat, 6 Jul 2019 17:43:50 +0430
Subject: [PATCH 084/348] Generate all subsequences using backtracking (#961)

* Add all_subsequences to backtracking directory
---
 backtracking/all_subsequences.py | 42 ++++++++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)
 create mode 100644 backtracking/all_subsequences.py

diff --git a/backtracking/all_subsequences.py b/backtracking/all_subsequences.py
new file mode 100644
index 000000000000..d868377234a8
--- /dev/null
+++ b/backtracking/all_subsequences.py
@@ -0,0 +1,42 @@
+'''
+	In this problem, we want to determine all possible subsequences
+	of the given sequence. We use backtracking to solve this problem.
+
+	Time complexity: O(2^n),
+	where n denotes the length of the given sequence.
+'''
+
+
+def generate_all_subsequences(sequence):
+	create_state_space_tree(sequence, [], 0)
+
+
+def create_state_space_tree(sequence, current_subsequence, index):
+	'''
+	Creates a state space tree to iterate through each branch using DFS.
+	We know that each state has exactly two children.
+	It terminates when it reaches the end of the given sequence.
+	'''
+
+	if index == len(sequence):
+		print(current_subsequence)
+		return
+
+	create_state_space_tree(sequence, current_subsequence, index + 1)
+	current_subsequence.append(sequence[index])
+	create_state_space_tree(sequence, current_subsequence, index + 1)
+	current_subsequence.pop()
+
+
+'''
+remove the comment to take an input from the user 
+
+print("Enter the elements")
+sequence = list(map(int, input().split()))
+'''
+
+sequence = [3, 1, 2, 4]
+generate_all_subsequences(sequence)
+
+sequence = ["A", "B", "C"]
+generate_all_subsequences(sequence)

From 839160f83a46413b94ba9817edc2ec37bcad36fc Mon Sep 17 00:00:00 2001
From: Erfan Alimohammadi <erfan.aa@gmail.com>
Date: Sat, 6 Jul 2019 17:49:36 +0430
Subject: [PATCH 085/348] Generate all permutations of a sequence, using
 backtracking (#962)

* Fix typo

* Add all_permutations algorithm to backtracking directory
---
 backtracking/all_permutations.py | 45 ++++++++++++++++++++++++++++++++
 1 file changed, 45 insertions(+)
 create mode 100644 backtracking/all_permutations.py

diff --git a/backtracking/all_permutations.py b/backtracking/all_permutations.py
new file mode 100644
index 000000000000..8c332970ba53
--- /dev/null
+++ b/backtracking/all_permutations.py
@@ -0,0 +1,45 @@
+'''
+	In this problem, we want to determine all possible permutations
+	of the given sequence. We use backtracking to solve this problem.
+
+	Time complexity: O(n!),
+	where n denotes the length of the given sequence.
+'''
+
+
+def generate_all_permutations(sequence):
+	create_state_space_tree(sequence, [], 0, [0 for i in range(len(sequence))])
+
+
+def create_state_space_tree(sequence, current_sequence, index, index_used):
+	'''
+	Creates a state space tree to iterate through each branch using DFS.
+	We know that each state has exactly len(sequence) - index children.
+	It terminates when it reaches the end of the given sequence.
+	'''
+
+	if index == len(sequence):
+		print(current_sequence)
+		return
+
+	for i in range(len(sequence)):
+		if not index_used[i]:
+			current_sequence.append(sequence[i])
+			index_used[i] = True
+			create_state_space_tree(sequence, current_sequence, index + 1, index_used)
+			current_sequence.pop()
+			index_used[i] = False
+
+
+'''
+remove the comment to take an input from the user 
+
+print("Enter the elements")
+sequence = list(map(int, input().split()))
+'''
+
+sequence = [3, 1, 2, 4]
+generate_all_permutations(sequence)
+
+sequence = ["A", "B", "C"]
+generate_all_permutations(sequence)

From 781b7f86e720b9c5164047e46f2dedd807b9165b Mon Sep 17 00:00:00 2001
From: Erfan Alimohammadi <erfan.aa@gmail.com>
Date: Sat, 6 Jul 2019 19:02:06 +0430
Subject: [PATCH 086/348] Fix readme and duplicate (#967)

* Fix typo

* Add all_permutations algorithm to backtracking directory

* Update backtracking and D&C algorithms in README

Update backtracking and divide_and_conquer algorithms in README

* Remove the duplicated file
---
 README.md                               |  3 +-
 divide_and_conquer/max_sub_array_sum.py | 72 -------------------------
 2 files changed, 2 insertions(+), 73 deletions(-)
 delete mode 100644 divide_and_conquer/max_sub_array_sum.py

diff --git a/README.md b/README.md
index a609dc077a77..a28475791432 100644
--- a/README.md
+++ b/README.md
@@ -45,6 +45,8 @@ We're on [Gitter](https://gitter.im/TheAlgorithms)! Please join us.
 
 - [N Queens](./backtracking/n_queens.py)
 - [Sum Of Subsets](./backtracking/sum_of_subsets.py)
+- [All Subsequences](./backtracking/all_subsequences.py)
+- [All Permutations](./backtracking/all_permutations.py)
 
 ## Ciphers
 
@@ -220,7 +222,6 @@ We're on [Gitter](https://gitter.im/TheAlgorithms)! Please join us.
 ## Divide And Conquer
 
 - [Max Subarray Sum](./divide_and_conquer/max_subarray_sum.py)
-- [Max Sub Array Sum](./divide_and_conquer/max_sub_array_sum.py)
 - [Closest Pair Of Points](./divide_and_conquer/closest_pair_of_points.py)
 
 ## Strings
diff --git a/divide_and_conquer/max_sub_array_sum.py b/divide_and_conquer/max_sub_array_sum.py
deleted file mode 100644
index 531a45abca6f..000000000000
--- a/divide_and_conquer/max_sub_array_sum.py
+++ /dev/null
@@ -1,72 +0,0 @@
-""" 
-Given a array of length n, max_sub_array_sum() finds the maximum of sum of contiguous sub-array using divide and conquer method.
-
-Time complexity : O(n log n)
-
-Ref : INTRODUCTION TO ALGORITHMS THIRD EDITION (section : 4, sub-section : 4.1, page : 70)
-
-"""
-
-
-def max_sum_from_start(array):
-    """ This function finds the maximum contiguous sum of array from 0 index
-
-    Parameters : 
-    array (list[int]) : given array
-    
-    Returns : 
-    max_sum (int) : maximum contiguous sum of array from 0 index
-
-    """
-    array_sum = 0
-    max_sum = float("-inf")
-    for num in array:
-        array_sum += num
-        if array_sum > max_sum:
-            max_sum = array_sum
-    return max_sum
-
-
-def max_cross_array_sum(array, left, mid, right):
-    """ This function finds the maximum contiguous sum of left and right arrays
-
-    Parameters : 
-    array, left, mid, right (list[int], int, int, int) 
-    
-    Returns : 
-    (int) :  maximum of sum of contiguous sum of left and right arrays
-
-    """
-
-    max_sum_of_left = max_sum_from_start(array[left:mid+1][::-1])
-    max_sum_of_right = max_sum_from_start(array[mid+1: right+1])
-    return max_sum_of_left + max_sum_of_right
-
-
-def max_sub_array_sum(array, left, right):
-    """ This function finds the maximum of sum of contiguous sub-array using divide and conquer method
-
-    Parameters : 
-    array, left, right (list[int], int, int) : given array, current left index and current right index
-    
-    Returns : 
-    int :  maximum of sum of contiguous sub-array
-
-    """
-
-    # base case: array has only one element
-    if left == right:
-        return array[right]
-    
-    # Recursion
-    mid = (left + right) // 2
-    left_half_sum = max_sub_array_sum(array, left, mid)
-    right_half_sum = max_sub_array_sum(array, mid + 1, right)
-    cross_sum = max_cross_array_sum(array, left, mid, right)
-    return max(left_half_sum, right_half_sum, cross_sum)
-
-
-array = [-2, -5, 6, -2, -3, 1, 5, -6]
-array_length = len(array)
-print("Maximum sum of contiguous subarray:", max_sub_array_sum(array, 0, array_length - 1))
-

From 69bed590368a10479a9ad225402aa540628a0457 Mon Sep 17 00:00:00 2001
From: Erfan Alimohammadi <erfan.aa@gmail.com>
Date: Sat, 6 Jul 2019 20:01:52 +0430
Subject: [PATCH 087/348] Fix backtrack time complexity (#965)

* Update backtracking/all_permutations.py
---
 backtracking/all_permutations.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/backtracking/all_permutations.py b/backtracking/all_permutations.py
index 8c332970ba53..299b708fef4e 100644
--- a/backtracking/all_permutations.py
+++ b/backtracking/all_permutations.py
@@ -2,7 +2,7 @@
 	In this problem, we want to determine all possible permutations
 	of the given sequence. We use backtracking to solve this problem.
 
-	Time complexity: O(n!),
+	Time complexity: O(n! * n),
 	where n denotes the length of the given sequence.
 '''
 

From 26df2aab1ee79de5a4b288a64ad9c118bfccab73 Mon Sep 17 00:00:00 2001
From: PatOnTheBack <51241310+PatOnTheBack@users.noreply.github.com>
Date: Sat, 6 Jul 2019 11:35:12 -0400
Subject: [PATCH 088/348] Removed Unused `import sys` (#922)

I removed `import sys` because it is not used in the program.
This addresses a [recommendation from lgtm](https://lgtm.com/projects/g/TheAlgorithms/Python/snapshot/66c4afbd0f28f9989f35ddbeb5c9263390c5d192/files/ciphers/caesar_cipher.py?sort=name&dir=ASC&mode=heatmap)
---
 ciphers/caesar_cipher.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/ciphers/caesar_cipher.py b/ciphers/caesar_cipher.py
index 39c069c95a7c..e22f19b4851d 100644
--- a/ciphers/caesar_cipher.py
+++ b/ciphers/caesar_cipher.py
@@ -1,4 +1,3 @@
-import sys
 def encrypt(strng, key):
     encrypted = ''
     for x in strng:

From 4ff2a9dd4e1a517cb0526ff51233bb6f1fc3fc8d Mon Sep 17 00:00:00 2001
From: Aditi Agarwal <31546143+aditiagarwal34550@users.noreply.github.com>
Date: Sat, 6 Jul 2019 21:59:58 -0700
Subject: [PATCH 089/348] minimax (#947)

* minimax.py

minimax algorithm is used for game like tic tac toe. It traces the path and selects the optimal move.

* minimax.py

Minimax is used in decision making and game theory to find the optimal move for a player, when your opponent also plays optimally. It is widely used in games like Tic-Tac-Toe, Chess.

* Delete minimax.py

* Update minimax.py

* Minimax is a backtracking algorithm that is used in game theory to find the optimal move for a player, assuming that your opponent also plays optimally
---
 backtracking/minimax.py | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 backtracking/minimax.py

diff --git a/backtracking/minimax.py b/backtracking/minimax.py
new file mode 100644
index 000000000000..5168306e71fc
--- /dev/null
+++ b/backtracking/minimax.py
@@ -0,0 +1,28 @@
+import math 
+
+''' Minimax helps to achieve maximum score in a game by checking all possible moves
+    depth is current depth in game tree. 
+    nodeIndex is index of current node in scores[].
+    if move is of maximizer return true else false
+    leaves of game tree is stored in scores[]  
+    height is maximum height of Game tree
+'''
+
+def minimax (Depth, nodeIndex, isMax, scores, height):  
+
+    if Depth == height:  
+        return scores[nodeIndex] 
+
+    if isMax: 
+        return (max(minimax(Depth + 1, nodeIndex * 2, False, scores, height),
+                    minimax(Depth + 1, nodeIndex * 2 + 1, False, scores, height))) 
+    return (min(minimax(Depth + 1, nodeIndex * 2, True, scores, height), 
+               minimax(Depth + 1, nodeIndex * 2 + 1, True, scores, height))) 
+
+if __name__ == "__main__": 
+ 
+    scores = [90, 23, 6, 33, 21, 65, 123, 34423] 
+    height = math.log(len(scores), 2) 
+
+    print("Optimal value : ", end = "") 
+    print(minimax(0, 0, True, scores, height)) 

From 95324927288135c740688d16db34381298139d66 Mon Sep 17 00:00:00 2001
From: Shahabaldin Mohammadi <45038855+stevelex-elex@users.noreply.github.com>
Date: Sun, 7 Jul 2019 11:19:15 +0430
Subject: [PATCH 090/348] added enigma machine algorithm (#932)

---
 hashes/enigma_machine.py | 61 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 61 insertions(+)
 create mode 100644 hashes/enigma_machine.py

diff --git a/hashes/enigma_machine.py b/hashes/enigma_machine.py
new file mode 100644
index 000000000000..bd410c5cb21d
--- /dev/null
+++ b/hashes/enigma_machine.py
@@ -0,0 +1,61 @@
+from __future__ import print_function
+
+alphabets = [chr(i) for i in range(32, 126)]
+gear_one = [i for i in range(len(alphabets))]
+gear_two = [i for i in range(len(alphabets))]
+gear_three = [i for i in range(len(alphabets))]
+reflector = [i for i in reversed(range(len(alphabets)))]
+code = []
+gear_one_pos = gear_two_pos = gear_three_pos = 0
+
+
+def rotator():
+    global gear_one_pos
+    global gear_two_pos
+    global gear_three_pos
+    i = gear_one[0]
+    gear_one.append(i)
+    del gear_one[0]
+    gear_one_pos += 1
+    if gear_one_pos % int(len(alphabets)) == 0:
+        i = gear_two[0]
+        gear_two.append(i)
+        del gear_two[0]
+        gear_two_pos += 1
+        if gear_two_pos % int(len(alphabets)) == 0:
+            i = gear_three[0]
+            gear_three.append(i)
+            del gear_three[0]
+            gear_three_pos += 1
+
+
+def engine(input_character):
+    target = alphabets.index(input_character)
+    target = gear_one[target]
+    target = gear_two[target]
+    target = gear_three[target]
+    target = reflector[target]
+    target = gear_three.index(target)
+    target = gear_two.index(target)
+    target = gear_one.index(target)
+    code.append(alphabets[target])
+    rotator()
+
+
+if __name__ == '__main__':
+    decode = input("Type your message:\n")
+    decode = list(decode)
+    while True:
+        try:
+            token = int(input("Please set token:(must be only digits)\n"))
+            break
+        except Exception as error:
+            print(error)
+    for i in range(token):
+        rotator()
+    for i in decode:
+        engine(i)
+    print("\n" + "".join(code))
+    print(
+        f"\nYour Token is {token} please write it down.\nIf you want to decode "
+        f"this message again you should input same digits as token!")

From 234b0a77c4d6186c9f0326233af84a8f75b35b6e Mon Sep 17 00:00:00 2001
From: Hector S <hfsam88@gmail.com>
Date: Sun, 7 Jul 2019 11:17:38 -0400
Subject: [PATCH 091/348] Simplied password_generator.py (#968)

* Added print function into matrix_multiplication_addition.py and removed blank space in data_structures/binary tree directory

* Removed .vs/ folder per #893

* Rename matrix_multiplication_addition.py to matrix_operation.py

* Added main() function and simplified password generation.

* Modified password_generator.py file according to suggestions in #968
---
 other/password_generator.py | 66 +++++++++++++++++++++++--------------
 1 file changed, 42 insertions(+), 24 deletions(-)

diff --git a/other/password_generator.py b/other/password_generator.py
index 8916079fc758..fd0701041240 100644
--- a/other/password_generator.py
+++ b/other/password_generator.py
@@ -1,35 +1,53 @@
+"""Password generator allows you to generate a random password of length N."""
 from __future__ import print_function
-import string
-import random
-
-letters = [letter for letter in string.ascii_letters]
-digits = [digit for digit in string.digits]
-symbols = [symbol for symbol in string.punctuation]
-chars = letters + digits + symbols
-random.shuffle(chars)
-
-min_length = 8
-max_length = 16
-password = ''.join(random.choice(chars) for x in range(random.randint(min_length, max_length)))
-print('Password: ' + password)
-print('[ If you are thinking of using this passsword, You better save it. ]')
-
-
-# ALTERNATIVE METHODS  
+from random import choice
+from string import ascii_letters, digits, punctuation
+
+
+def password_generator(length=8):
+    """
+    >>> len(password_generator())
+    8
+    >>> len(password_generator(length=16))
+    16
+    >>> len(password_generator(257))
+    257
+    >>> len(password_generator(length=0))
+    0
+    >>> len(password_generator(-1))
+    0
+    """
+    chars = tuple(ascii_letters) + tuple(digits) + tuple(punctuation)
+    return ''.join(choice(chars) for x in range(length))
+
+
+# ALTERNATIVE METHODS
 # ctbi= characters that must be in password
-# i= how many letters or characters the password length will be 
-def password_generator(ctbi, i):
-  # Password generator = full boot with random_number, random_letters, and random_character FUNCTIONS
-  pass  # Put your code here...
+# i= how many letters or characters the password length will be
+def alternative_password_generator(ctbi, i):
+    # Password generator = full boot with random_number, random_letters, and
+    # random_character FUNCTIONS
+    pass  # Put your code here...
 
 
 def random_number(ctbi, i):
-  pass  # Put your code here...
+    pass  # Put your code here...
 
 
 def random_letters(ctbi, i):
-  pass  # Put your code here...
+    pass  # Put your code here...
 
 
 def random_characters(ctbi, i):
-  pass  # Put your code here...
+    pass  # Put your code here...
+
+
+def main():
+    length = int(
+        input('Please indicate the max length of your password: ').strip())
+    print('Password generated:', password_generator(length))
+    print('[If you are thinking of using this passsword, You better save it.]')
+
+
+if __name__ == '__main__':
+    main()

From 2b365284c80bbc2c7e5676481ed56308a5b1d888 Mon Sep 17 00:00:00 2001
From: PatOnTheBack <51241310+PatOnTheBack@users.noreply.github.com>
Date: Sun, 7 Jul 2019 11:45:42 -0400
Subject: [PATCH 092/348] Removed Unnecessary Assignment for 'error' Var (#920)

`error = abs(f(a))` was declared on line 24 and line 32. It is unnecessary to have in both places.
I removed the second instance since it wastes resources to keep redefining the variable inside the for loop.
This fixes an [issue found by lgtm](https://lgtm.com/projects/g/TheAlgorithms/Python/snapshot/66c4afbd0f28f9989f35ddbeb5c9263390c5d192/files/maths/newton_raphson.py?sort=name&dir=ASC&mode=heatmap)
---
 maths/newton_raphson.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/maths/newton_raphson.py b/maths/newton_raphson.py
index cc6c92734fd4..d89f264acdd8 100644
--- a/maths/newton_raphson.py
+++ b/maths/newton_raphson.py
@@ -29,7 +29,6 @@ def newton_raphson(f, x0=0, maxiter=100, step=0.0001, maxerror=1e-6,logsteps=Fal
         a = a - f(a)/f1(a) #Calculate the next estimate
         if logsteps:
             steps.append(a)
-        error = abs(f(a))
         if error < maxerror:
             break
     else:

From b7f13d991cccd370d8ff5b27c1bdc36237a13473 Mon Sep 17 00:00:00 2001
From: cclauss <cclauss@me.com>
Date: Mon, 8 Jul 2019 17:27:51 +0200
Subject: [PATCH 093/348] Travis CI: Run black, doctest, flake8, mypy, and
 pytest (#964)

* Travis CI: Add type checking with mypy

* Create requirements.txt

* script: mypy --ignore-missing-stubs=cv2,numpy .

* Delete requirements.txt

* script: mypy --ignore-missing-imports .

* Run doctests

* Disable doctest -v other/detecting_english_programmatically.py

* Pytest

* No |

* pytest || true

* Run black doctest flake8 mypy pytest

* after_success: Build Directory.md

* Typo in filename: Dictionary.txt --> dictionary.txt'

Discovered via doctest run in #964

* python -m doctest -v

* pip install black flake8 mypy pytest

* pytest --doctest-glob='*.py'

* pytest --doctest-modules

* pytest --doctest-modules ./sorts

* pytest --doctest-modules ./ciphers ./other ./searches ./sorts ./strings || true

* if __name__ == "__main__":

* if __name__ == "__main__":

* if __name__ == '__main__':

* if __name__ == '__main__':

* if __name__ == '__main__':

* Create requirements.txt

* Update requirements.txt

* if __name__ == "__main__":

* Lose the doctests

* if __name__ == '__main__':

* Remove print-a-tuple

* doctest: Added missing spaces

* Update tabu_search.py

* The >>> are not doctests so change to >>)

* Travis CI: Run black, doctest, flake8, mypy, and pytest

* Link to the separate DIRECTORY.md file

* Update README.md
---
 .travis.yml                                 |  13 +-
 README.md                                   | 339 +-------------------
 ciphers/Atbash.py                           |   4 +-
 ciphers/caesar_cipher.py                    |   5 +-
 other/detecting_english_programmatically.py |   2 +-
 other/sierpinski_triangle.py                |  17 +-
 other/tower_of_hanoi.py                     |   4 +-
 requirements.txt                            |   6 +
 searches/tabu_search.py                     |   4 +-
 sorts/Bitonic_Sort.py                       |  25 +-
 sorts/bubble_sort.py                        |   2 +-
 11 files changed, 56 insertions(+), 365 deletions(-)
 create mode 100644 requirements.txt

diff --git a/.travis.yml b/.travis.yml
index 8676e5127334..e67bd431a7c1 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,5 +1,14 @@
 language: python
 dist: xenial  # required for Python >= 3.7
 python: 3.7
-install: pip install flake8
-script: flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
+cache: pip
+install: pip install -r requirements.txt
+before_script:
+  - black --check . || true
+  - flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
+script:
+  - mypy --ignore-missing-imports .
+  - pytest --doctest-modules ./ciphers ./other ./searches ./sorts ./strings
+after_success:
+  - python ./~script.py
+  - cat DIRECTORY.md
diff --git a/README.md b/README.md
index a28475791432..30eccd361673 100644
--- a/README.md
+++ b/README.md
@@ -12,12 +12,12 @@ These implementations are for learning purposes. They may be less efficient than
 
 Anup Kumar Panwar
 &nbsp; [[Gmail](mailto:1anuppanwar@gmail.com?Subject=The%20Algorithms%20-%20Python)
-&nbsp; [Gihub](https://github.com/anupkumarpanwar)
+&nbsp; [GitHub](https://github.com/anupkumarpanwar)
 &nbsp; [LinkedIn](https://www.linkedin.com/in/anupkumarpanwar/)]
 
 Chetan Kaushik
 &nbsp; [[Gmail](mailto:dynamitechetan@gmail.com?Subject=The%20Algorithms%20-%20Python)
-&nbsp; [Gihub](https://github.com/dynamitechetan)
+&nbsp; [GitHub](https://github.com/dynamitechetan)
 &nbsp; [LinkedIn](https://www.linkedin.com/in/chetankaushik/)]
 
 ## Contribution Guidelines
@@ -28,337 +28,6 @@ Read our [Contribution Guidelines](CONTRIBUTING.md) before you contribute.
 
 We're on [Gitter](https://gitter.im/TheAlgorithms)! Please join us.
 
-# Algorithms
+## Algorithms
 
-## Hashes
-
-- [Md5](./hashes/md5.py)
-- [Chaos Machine](./hashes/chaos_machine.py)
-- [Sha1](./hashes/sha1.py)
-
-## File Transfer Protocol
-
-- [Ftp Client Server](./file_transfer_protocol/ftp_client_server.py)
-- [Ftp Send Receive](./file_transfer_protocol/ftp_send_receive.py)
-
-## Backtracking
-
-- [N Queens](./backtracking/n_queens.py)
-- [Sum Of Subsets](./backtracking/sum_of_subsets.py)
-- [All Subsequences](./backtracking/all_subsequences.py)
-- [All Permutations](./backtracking/all_permutations.py)
-
-## Ciphers
-
-- [Transposition Cipher](./ciphers/transposition_cipher.py)
-- [Atbash](./ciphers/Atbash.py)
-- [Rot13](./ciphers/rot13.py)
-- [Rabin Miller](./ciphers/rabin_miller.py)
-- [Transposition Cipher Encrypt Decrypt File](./ciphers/transposition_cipher_encrypt_decrypt_file.py)
-- [Affine Cipher](./ciphers/affine_cipher.py)
-- [Trafid Cipher](./ciphers/trafid_cipher.py)
-- [Base16](./ciphers/base16.py)
-- [Elgamal Key Generator](./ciphers/elgamal_key_generator.py)
-- [Rsa Cipher](./ciphers/rsa_cipher.py)
-- [Prehistoric Men.txt](./ciphers/prehistoric_men.txt)
-- [Vigenere Cipher](./ciphers/vigenere_cipher.py)
-- [Xor Cipher](./ciphers/xor_cipher.py)
-- [Brute Force Caesar Cipher](./ciphers/brute_force_caesar_cipher.py)
-- [Rsa Key Generator](./ciphers/rsa_key_generator.py)
-- [Simple Substitution Cipher](./ciphers/simple_substitution_cipher.py)
-- [Playfair Cipher](./ciphers/playfair_cipher.py)
-- [Morse Code Implementation](./ciphers/morse_Code_implementation.py)
-- [Base32](./ciphers/base32.py)
-- [Base85](./ciphers/base85.py)
-- [Base64 Cipher](./ciphers/base64_cipher.py)
-- [Onepad Cipher](./ciphers/onepad_cipher.py)
-- [Caesar Cipher](./ciphers/caesar_cipher.py)
-- [Hill Cipher](./ciphers/hill_cipher.py)
-- [Cryptomath Module](./ciphers/cryptomath_module.py)
-
-## Arithmetic Analysis
-
-- [Bisection](./arithmetic_analysis/bisection.py)
-- [Newton Method](./arithmetic_analysis/newton_method.py)
-- [Newton Raphson Method](./arithmetic_analysis/newton_raphson_method.py)
-- [Intersection](./arithmetic_analysis/intersection.py)
-- [Lu Decomposition](./arithmetic_analysis/lu_decomposition.py)
-
-## Boolean Algebra
-
-- [Quine Mc Cluskey](./boolean_algebra/quine_mc_cluskey.py)
-
-## Traversals
-
-- [Binary Tree Traversals](./traversals/binary_tree_traversals.py)
-
-## Maths
-
-- [Average](./maths/average.py)
-- [Abs Max](./maths/abs_Max.py)
-- [Average Median](./maths/average_median.py)
-- [Trapezoidal Rule](./maths/trapezoidal_rule.py)
-- [Prime Check](./maths/Prime_Check.py)
-- [Modular Exponential](./maths/modular_exponential.py)
-- [Newton Raphson](./maths/newton_raphson.py)
-- [Factorial Recursive](./maths/factorial_recursive.py)
-- [Extended Euclidean Algorithm](./maths/extended_euclidean_algorithm.py)
-- [Greater Common Divisor](./maths/greater_common_divisor.py)
-- [Fibonacci](./maths/fibonacci.py)
-- [Find Lcm](./maths/find_lcm.py)
-- [Find Max](./maths/Find_Max.py)
-- [Fermat Little Theorem](./maths/fermat_little_theorem.py)
-- [Factorial Python](./maths/factorial_python.py)
-- [Fibonacci Sequence Recursion](./maths/fibonacci_sequence_recursion.py)
-- [Sieve Of Eratosthenes](./maths/sieve_of_eratosthenes.py)
-- [Abs Min](./maths/abs_Min.py)
-- [Lucas Series](./maths/lucasSeries.py)
-- [Segmented Sieve](./maths/segmented_sieve.py)
-- [Find Min](./maths/Find_Min.py)
-- [Abs](./maths/abs.py)
-- [Simpson Rule](./maths/simpson_rule.py)
-- [Basic Maths](./maths/basic_maths.py)
-- [3n+1](./maths/3n+1.py)
-- [Binary Exponentiation](./maths/Binary_Exponentiation.py)
-
-## Digital Image Processing
-
-- ## Filters
-
-  - [Median Filter](./digital_image_processing/filters/median_filter.py)
-  - [Gaussian Filter](./digital_image_processing/filters/gaussian_filter.py)
-
-
-## Compression
-
-- [Peak Signal To Noise Ratio](./compression/peak_signal_to_noise_ratio.py)
-- [Huffman](./compression/huffman.py)
-
-## Graphs
-
-- [BFS Shortest Path](./graphs/bfs_shortest_path.py)
-- [Directed And Undirected (Weighted) Graph](<./graphs/Directed_and_Undirected_(Weighted)_Graph.py>)
-- [Minimum Spanning Tree Prims](./graphs/minimum_spanning_tree_prims.py)
-- [Graph Matrix](./graphs/graph_matrix.py)
-- [Basic Graphs](./graphs/basic_graphs.py)
-- [Dijkstra 2](./graphs/dijkstra_2.py)
-- [Tarjans Strongly Connected Components](./graphs/tarjans_scc.py)
-- [Check Bipartite Graph BFS](./graphs/check_bipartite_graph_bfs.py)
-- [Depth First Search](./graphs/depth_first_search.py)
-- [Kahns Algorithm Long](./graphs/kahns_algorithm_long.py)
-- [Breadth First Search](./graphs/breadth_first_search.py)
-- [Dijkstra](./graphs/dijkstra.py)
-- [Articulation Points](./graphs/articulation_points.py)
-- [Bellman Ford](./graphs/bellman_ford.py)
-- [Check Bipartite Graph Dfs](./graphs/check_bipartite_graph_dfs.py)
-- [Strongly Connected Components Kosaraju](./graphs/scc_kosaraju.py)
-- [Multi Hueristic Astar](./graphs/multi_hueristic_astar.py)
-- [Page Rank](./graphs/page_rank.py)
-- [Eulerian Path And Circuit For Undirected Graph](./graphs/Eulerian_path_and_circuit_for_undirected_graph.py)
-- [Edmonds Karp Multiple Source And Sink](./graphs/edmonds_karp_multiple_source_and_sink.py)
-- [Floyd Warshall](./graphs/floyd_warshall.py)
-- [Minimum Spanning Tree Kruskal](./graphs/minimum_spanning_tree_kruskal.py)
-- [Prim](./graphs/prim.py)
-- [Kahns Algorithm Topo](./graphs/kahns_algorithm_topo.py)
-- [BFS](./graphs/BFS.py)
-- [Finding Bridges](./graphs/finding_bridges.py)
-- [Graph List](./graphs/graph_list.py)
-- [Dijkstra Algorithm](./graphs/dijkstra_algorithm.py)
-- [A Star](./graphs/a_star.py)
-- [Even Tree](./graphs/even_tree.py)
-- [DFS](./graphs/DFS.py)
-
-## Networking Flow
-
-- [Minimum Cut](./networking_flow/minimum_cut.py)
-- [Ford Fulkerson](./networking_flow/ford_fulkerson.py)
-
-## Matrix
-
-- [Matrix Operation](./matrix/matrix_operation.py)
-- [Searching In Sorted Matrix](./matrix/searching_in_sorted_matrix.py)
-- [Spiral Print](./matrix/spiral_print.py)
-
-## Searches
-
-- [Quick Select](./searches/quick_select.py)
-- [Binary Search](./searches/binary_search.py)
-- [Interpolation Search](./searches/interpolation_search.py)
-- [Jump Search](./searches/jump_search.py)
-- [Linear Search](./searches/linear_search.py)
-- [Ternary Search](./searches/ternary_search.py)
-- [Tabu Search](./searches/tabu_search.py)
-- [Sentinel Linear Search](./searches/sentinel_linear_search.py)
-
-## Conversions
-
-- [Decimal To Binary](./conversions/decimal_to_binary.py)
-- [Decimal To Octal](./conversions/decimal_to_octal.py)
-
-## Dynamic Programming
-
-- [Fractional Knapsack](./dynamic_programming/Fractional_Knapsack.py)
-- [Sum Of Subset](./dynamic_programming/sum_of_subset.py)
-- [Fast Fibonacci](./dynamic_programming/fast_fibonacci.py)
-- [Bitmask](./dynamic_programming/bitmask.py)
-- [Abbreviation](./dynamic_programming/abbreviation.py)
-- [Rod Cutting](./dynamic_programming/rod_cutting.py)
-- [Knapsack](./dynamic_programming/knapsack.py)
-- [Max Sub Array](./dynamic_programming/max_sub_array.py)
-- [Fibonacci](./dynamic_programming/fibonacci.py)
-- [Minimum Partition](./dynamic_programming/minimum_partition.py)
-- [K Means Clustering Tensorflow](./dynamic_programming/k_means_clustering_tensorflow.py)
-- [Coin Change](./dynamic_programming/coin_change.py)
-- [Subset Generation](./dynamic_programming/subset_generation.py)
-- [Floyd Warshall](./dynamic_programming/floyd_warshall.py)
-- [Longest Sub Array](./dynamic_programming/longest_sub_array.py)
-- [Integer Partition](./dynamic_programming/integer_partition.py)
-- [Matrix Chain Order](./dynamic_programming/matrix_chain_order.py)
-- [Edit Distance](./dynamic_programming/edit_distance.py)
-- [Longest Common Subsequence](./dynamic_programming/longest_common_subsequence.py)
-- [Longest Increasing Subsequence O(nlogn)](<./dynamic_programming/longest_increasing_subsequence_O(nlogn).py>)
-- [Longest Increasing Subsequence](./dynamic_programming/longest_increasing_subsequence.py)
-
-## Divide And Conquer
-
-- [Max Subarray Sum](./divide_and_conquer/max_subarray_sum.py)
-- [Closest Pair Of Points](./divide_and_conquer/closest_pair_of_points.py)
-
-## Strings
-
-- [Knuth Morris Pratt](./strings/knuth_morris_pratt.py)
-- [Rabin Karp](./strings/rabin_karp.py)
-- [Naive String Search](./strings/naive_String_Search.py)
-- [Levenshtein Distance](./strings/levenshtein_distance.py)
-- [Min Cost String Conversion](./strings/min_cost_string_conversion.py)
-- [Boyer Moore Search](./strings/Boyer_Moore_Search.py)
-- [Manacher](./strings/manacher.py)
-
-## Sorts
-
-- [Quick Sort](./sorts/quick_sort.py)
-- [Selection Sort](./sorts/selection_sort.py)
-- [Bitonic Sort](./sorts/Bitonic_Sort.py)
-- [Cycle Sort](./sorts/cycle_sort.py)
-- [Comb Sort](./sorts/comb_sort.py)
-- [Topological Sort](./sorts/topological_sort.py)
-- [Merge Sort Fastest](./sorts/merge_sort_fastest.py)
-- [Random Pivot Quick Sort](./sorts/random_pivot_quick_sort.py)
-- [Heap Sort](./sorts/heap_sort.py)
-- [Insertion Sort](./sorts/insertion_sort.py)
-- [Counting Sort](./sorts/counting_sort.py)
-- [Bucket Sort](./sorts/bucket_sort.py)
-- [Quick Sort 3 Partition](./sorts/quick_sort_3_partition.py)
-- [Bogo Sort](./sorts/bogo_sort.py)
-- [Shell Sort](./sorts/shell_sort.py)
-- [Pigeon Sort](./sorts/pigeon_sort.py)
-- [Odd-Even Transposition Parallel](./sorts/Odd-Even_transposition_parallel.py)
-- [Tree Sort](./sorts/tree_sort.py)
-- [Cocktail Shaker Sort](./sorts/cocktail_shaker_sort.py)
-- [Random Normal Distribution Quicksort](./sorts/random_normal_distribution_quicksort.py)
-- [Wiggle Sort](./sorts/wiggle_sort.py)
-- [Pancake Sort](./sorts/pancake_sort.py)
-- [External Sort](./sorts/external_sort.py)
-- [Tim Sort](./sorts/tim_sort.py)
-- [Sorting Graphs.png](./sorts/sorting_graphs.png)
-- [Radix Sort](./sorts/radix_sort.py)
-- [Odd-Even Transposition Single-threaded](./sorts/Odd-Even_transposition_single-threaded.py)
-- [Bubble Sort](./sorts/bubble_sort.py)
-- [Gnome Sort](./sorts/gnome_sort.py)
-- [Merge Sort](./sorts/merge_sort.py)
-
-## Machine Learning
-
-- [Perceptron](./machine_learning/perceptron.py)
-- [Random Forest Classifier](./machine_learning/random_forest_classification/random_forest_classifier.ipynb)
-- [NaiveBayes.ipynb](./machine_learning/NaiveBayes.ipynb)
-- [Scoring Functions](./machine_learning/scoring_functions.py)
-- [Logistic Regression](./machine_learning/logistic_regression.py)
-- [Gradient Descent](./machine_learning/gradient_descent.py)
-- [Linear Regression](./machine_learning/linear_regression.py)
-- [Random Forest Regression](./machine_learning/random_forest_regression/random_forest_regression.py)
-- [Random Forest Regression](./machine_learning/random_forest_regression/random_forest_regression.ipynb)
-- [Reuters One Vs Rest Classifier.ipynb](./machine_learning/reuters_one_vs_rest_classifier.ipynb)
-- [Decision Tree](./machine_learning/decision_tree.py)
-- [Knn Sklearn](./machine_learning/knn_sklearn.py)
-- [K Means Clust](./machine_learning/k_means_clust.py)
-
-## Neural Network
-
-- [Perceptron](./neural_network/perceptron.py)
-- [Fully Connected Neural Network](./neural_network/fully_connected_neural_network.ipynb)
-- [Convolution Neural Network](./neural_network/convolution_neural_network.py)
-- [Back Propagation Neural Network](./neural_network/back_propagation_neural_network.py)
-
-## Data Structures
-
-- ## Binary Tree
-
-   - [Basic Binary Tree](./data_structures/binary_tree/basic_binary_tree.py)
-  - [Red Black Tree](./data_structures/binary_tree/red_black_tree.py)
-  - [Fenwick Tree](./data_structures/binary_tree/fenwick_tree.py)
-  - [Treap](./data_structures/binary_tree/treap.py)
-  - [AVL Tree](./data_structures/binary_tree/AVL_tree.py)
-  - [Segment Tree](./data_structures/binary_tree/segment_tree.py)
-  - [Lazy Segment Tree](./data_structures/binary_tree/lazy_segment_tree.py)
-  - [Binary Search Tree](./data_structures/binary_tree/binary_search_tree.py)
-
-- ## Trie
-
-  - [Trie](./data_structures/trie/trie.py)
-
-- ## Linked List
-
-  - [Swap Nodes](./data_structures/linked_list/swap_nodes.py)
-  - [Doubly Linked List](./data_structures/linked_list/doubly_linked_list.py)
-  - [Singly Linked List](./data_structures/linked_list/singly_linked_list.py)
-  - [Is Palindrome](./data_structures/linked_list/is_Palindrome.py)
-
-- ## Stacks
-
-  - [Postfix Evaluation](./data_structures/stacks/postfix_evaluation.py)
-  - [Balanced Parentheses](./data_structures/stacks/balanced_parentheses.py)
-  - [Infix To Prefix Conversion](./data_structures/stacks/infix_to_prefix_conversion.py)
-  - [Stack](./data_structures/stacks/stack.py)
-  - [Infix To Postfix Conversion](./data_structures/stacks/infix_to_postfix_conversion.py)
-  - [Next Greater Element](./data_structures/stacks/next_greater_element.py)
-  - [Stock Span Problem](./data_structures/stacks/stock_span_problem.py)
-
-- ## Queue
-
-  - [Queue On Pseudo Stack](./data_structures/queue/queue_on_pseudo_stack.py)
-  - [Double Ended Queue](./data_structures/queue/double_ended_queue.py)
-  - [Queue On List](./data_structures/queue/queue_on_list.py)
-
-- ## Heap
-
-  - [Heap](./data_structures/heap/heap.py)
-
-- ## Hashing
-
-  - [Hash Table With Linked List](./data_structures/hashing/hash_table_with_linked_list.py)
-  - [Quadratic Probing](./data_structures/hashing/quadratic_probing.py)
-  - [Hash Table](./data_structures/hashing/hash_table.py)
-  - [Double Hash](./data_structures/hashing/double_hash.py)
-
-
-## Other
-
-- [Detecting English Programmatically](./other/detecting_english_programmatically.py)
-- [Fischer Yates Shuffle](./other/fischer_yates_shuffle.py)
-- [Primelib](./other/primelib.py)
-- [Binary Exponentiation 2](./other/binary_exponentiation_2.py)
-- [Anagrams](./other/anagrams.py)
-- [Palindrome](./other/palindrome.py)
-- [Finding Primes](./other/finding_Primes.py)
-- [Two Sum](./other/two_sum.py)
-- [Password Generator](./other/password_generator.py)
-- [Linear Congruential Generator](./other/linear_congruential_generator.py)
-- [Frequency Finder](./other/frequency_finder.py)
-- [Euclidean Gcd](./other/euclidean_gcd.py)
-- [Word Patterns](./other/word_patterns.py)
-- [Nested Brackets](./other/nested_brackets.py)
-- [Binary Exponentiation](./other/binary_exponentiation.py)
-- [Sierpinski Triangle](./other/sierpinski_triangle.py)
-- [Game Of Life](./other/game_of_life.py)
-- [Tower Of Hanoi](./other/tower_of_hanoi.py)
+See our [directory](DIRECTORY.md).
diff --git a/ciphers/Atbash.py b/ciphers/Atbash.py
index 162614c727ee..5653f0213745 100644
--- a/ciphers/Atbash.py
+++ b/ciphers/Atbash.py
@@ -18,4 +18,6 @@ def Atbash():
             output+=i
     print(output)
 
-Atbash()
+
+if __name__ == '__main__':
+    Atbash()
diff --git a/ciphers/caesar_cipher.py b/ciphers/caesar_cipher.py
index e22f19b4851d..872b5d8195c1 100644
--- a/ciphers/caesar_cipher.py
+++ b/ciphers/caesar_cipher.py
@@ -59,4 +59,7 @@ def main():
         elif choice == '4':
             print ("Goodbye.")
             break
-main()
+
+
+if __name__ == '__main__':
+    main()
diff --git a/other/detecting_english_programmatically.py b/other/detecting_english_programmatically.py
index 005fd3c10ca3..8b73ff6cf0c3 100644
--- a/other/detecting_english_programmatically.py
+++ b/other/detecting_english_programmatically.py
@@ -6,7 +6,7 @@
 def loadDictionary():
     path = os.path.split(os.path.realpath(__file__))
     englishWords = {}
-    with open(path[0] + '/Dictionary.txt') as dictionaryFile:
+    with open(path[0] + '/dictionary.txt') as dictionaryFile:
         for word in dictionaryFile.read().split('\n'):
             englishWords[word] = None
     return englishWords
diff --git a/other/sierpinski_triangle.py b/other/sierpinski_triangle.py
index 329a8ce5c43f..fc22aad96059 100644
--- a/other/sierpinski_triangle.py
+++ b/other/sierpinski_triangle.py
@@ -27,13 +27,6 @@
 import turtle
 import sys
 PROGNAME = 'Sierpinski Triangle'
-if len(sys.argv) !=2: 
-    raise Exception('right format for using this script: $python fractals.py <int:depth_for_fractal>')
-
-myPen = turtle.Turtle()
-myPen.ht()
-myPen.speed(5)
-myPen.pencolor('red')
 
 points = [[-175,-125],[0,175],[175,-125]] #size of triangle
 
@@ -64,4 +57,12 @@ def triangle(points,depth):
                    depth-1)
 
 
-triangle(points,int(sys.argv[1]))
+if __name__ == '__main__':
+    if len(sys.argv) !=2: 
+        raise ValueError('right format for using this script: '
+                         '$python fractals.py <int:depth_for_fractal>')
+    myPen = turtle.Turtle()
+    myPen.ht()
+    myPen.speed(5)
+    myPen.pencolor('red')
+    triangle(points,int(sys.argv[1]))
diff --git a/other/tower_of_hanoi.py b/other/tower_of_hanoi.py
index dc15b2ce8e58..9cc5b9e40543 100644
--- a/other/tower_of_hanoi.py
+++ b/other/tower_of_hanoi.py
@@ -16,10 +16,10 @@ def moveTower(height, fromPole, toPole, withPole):
         moveTower(height-1, withPole, toPole, fromPole)
 
 def moveDisk(fp,tp):
-    print(('moving disk from', fp, 'to', tp))
+    print('moving disk from', fp, 'to', tp)
 
 def main():
-    height = int(input('Height of hanoi: '))
+    height = int(input('Height of hanoi: ').strip())
     moveTower(height, 'A', 'B', 'C')
 
 if __name__ == '__main__':
diff --git a/requirements.txt b/requirements.txt
new file mode 100644
index 000000000000..30179ac345b3
--- /dev/null
+++ b/requirements.txt
@@ -0,0 +1,6 @@
+black
+flake8
+matplotlib
+mypy
+numpy
+pytest
diff --git a/searches/tabu_search.py b/searches/tabu_search.py
index e21ddd53cc78..ffd84f8ac031 100644
--- a/searches/tabu_search.py
+++ b/searches/tabu_search.py
@@ -38,7 +38,7 @@ def generate_neighbours(path):
     and the cost (distance) for each neighbor.
 
     Example of dict_of_neighbours:
-    >>> dict_of_neighbours[a]
+    >>) dict_of_neighbours[a]
     [[b,20],[c,18],[d,22],[e,26]]
 
     This indicates the neighbors of node (city) 'a', which has neighbor the node 'b' with distance 20,
@@ -130,7 +130,7 @@ def find_neighborhood(solution, dict_of_neighbours):
 
 
     Example:
-    >>> find_neighborhood(['a','c','b','d','e','a'])
+    >>) find_neighborhood(['a','c','b','d','e','a'])
     [['a','e','b','d','c','a',90], [['a','c','d','b','e','a',90],['a','d','b','c','e','a',93],
     ['a','c','b','e','d','a',102], ['a','c','e','d','b','a',113], ['a','b','c','d','e','a',93]]
 
diff --git a/sorts/Bitonic_Sort.py b/sorts/Bitonic_Sort.py
index bae95b4346f6..ba40a1f698ee 100644
--- a/sorts/Bitonic_Sort.py
+++ b/sorts/Bitonic_Sort.py
@@ -42,15 +42,16 @@ def sort(a, N, up):
     bitonicSort(a, 0, N, up)
 
 
-# Driver code to test above
-a = []
-
-n = int(input())
-for i in range(n):
-    a.append(int(input()))
-up = 1
-
-sort(a, n, up)
-print("\n\nSorted array is")
-for i in range(n):
-    print("%d" % a[i])
+if __name__ == "__main__":
+    # Driver code to test above
+    a = []
+
+    n = int(input().strip())
+    for i in range(n):
+        a.append(int(input().strip()))
+    up = 1
+
+    sort(a, n, up)
+    print("\n\nSorted array is")
+    for i in range(n):
+        print("%d" % a[i])
diff --git a/sorts/bubble_sort.py b/sorts/bubble_sort.py
index e17fc3358d53..4e2c19b65e02 100644
--- a/sorts/bubble_sort.py
+++ b/sorts/bubble_sort.py
@@ -19,7 +19,7 @@ def bubble_sort(collection):
     [-45, -5, -2]
     
     >>> bubble_sort([-23,0,6,-4,34])
-    [-23,-4,0,6,34]
+    [-23, -4, 0, 6, 34]
     """
     length = len(collection)
     for i in range(length-1):

From 78cd3df3fc5935922f13db36c61c3b2680f138d7 Mon Sep 17 00:00:00 2001
From: cclauss <cclauss@me.com>
Date: Mon, 8 Jul 2019 17:38:47 +0200
Subject: [PATCH 094/348] Update CONTRIBUTING.md to match #964 (#969)

* Update CONTRIBUTING.md to match #964

Blocked by #964

* Do not modify README or DIRECTORY file.

* Update CONTRIBUTING.md
---
 CONTRIBUTING.md | 27 ++++++++++++++++++++++-----
 1 file changed, 22 insertions(+), 5 deletions(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 03de387a8acd..02235ee89973 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -28,6 +28,13 @@ We appreciate any contribution, from fixing a grammar mistake in a comment to im
 We want your work to be readable by others; therefore, we encourage you to note the following:
 
 - Please write in Python 3.x.
+- Please consider running [__python/black__](https://github.com/python/black) on your Python file(s) before submitting your pull request.  This is not a requirement but it does make your code more readable.  There are other code formatters (autopep8, yapf) but the __black__ style is now the recommendation of the Python core team. To use it,
+    ```bash
+    pip3 install black  # only required the first time
+    black my-submission.py
+    ```
+
+- All submissions will need to pass the test __flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics__ before they will be accepted so if possible, try this test locally on your Python file(s) before submitting your pull request.
 
 - If you know [PEP 8](https://www.python.org/dev/peps/pep-0008/) already, you will have no problem in coding style, though we do not follow it strictly. Read the remaining section and have fun coding!
 
@@ -74,11 +81,17 @@ We want your work to be readable by others; therefore, we encourage you to note
 
   The following "testing" approaches are **not** encouraged:
 
-  ```python*
+  ```python
   input('Enter your input:') 
   # Or even worse...
   input = eval(raw_input("Enter your input: "))
   ```
+  
+  However, if your code uses __input()__ then we encourage you to gracefully deal with leading and trailing whitespace in user input by adding __.strip()__ to the end as in:
+  
+  ```python
+  starting_value = int(input("Please enter a starting value: ").strip())
+  ```
 
   Please write down your test case, like the following:
 
@@ -92,8 +105,10 @@ We want your work to be readable by others; therefore, we encourage you to note
   print("1 + 2 = ", sumab(1,2))	# 1+2 = 3
   print("6 + 4 = ", sumab(6,4))	# 6+4 = 10
   ```
+  
+  Better yet, if you know how to write [__doctests__](https://docs.python.org/3/library/doctest.html), please consider adding them.
 
-- Avoid importing external libraries for basic algorithms. Use those libraries for complicated algorithms.
+- Avoid importing external libraries for basic algorithms. Only use those libraries for complicated algorithms.
 
 #### Other Standard While Submitting Your Work
 
@@ -105,15 +120,17 @@ We want your work to be readable by others; therefore, we encourage you to note
 
 - If you have modified/added code work, make sure the code compiles before submitting.
 
-- If you have modified/added documentation work, make sure your language is concise and contains no grammar mistake.
+- If you have modified/added documentation work, ensure your language is concise and contains no grammar errors.
 
-- Update the README file if you have added any new algorithm. Only entry corresponding to the algorithm is to be made, not need to add sample data, test files or solutions to problems like Project Euler, in the README.
+- Do not update the README.md or DIRECTORY.md file which will be periodically autogenerated by our Travis CI processes.
 
 - Add a corresponding explanation to [Algorithms-Explanation](https://github.com/TheAlgorithms/Algorithms-Explanation) (Optional but recommended).
 
+- All submissions will be tested with [__mypy__](http://www.mypy-lang.org) so we encourage to add [__Python type hints__](https://docs.python.org/3/library/typing.html) where it makes sense to do so.
+
 - Most importantly,
 
-  - **Be consistent with this guidelines while submitting.**
+  - **Be consistent in the use of these guidelines when submitting.**
   - **Join** [Gitter](https://gitter.im/TheAlgorithms) **now!**
   - Happy coding!
 

From 32d5c1a9b270dec417bb93ecf0e5d9a25170224f Mon Sep 17 00:00:00 2001
From: Animesh Singh <46104817+Blues1998@users.noreply.github.com>
Date: Mon, 8 Jul 2019 22:28:58 +0530
Subject: [PATCH 095/348] Project Euler Problem #13 Python Solution (#935)

* Create text file for numbers

* Create sol2.py

* Pythonic version of Problem #16 solution

* Update sol2.py

* Valid Python code for Python version 2-3

* Update sol2.py
---
 project_euler/problem_13/num.txt | 100 +++++++++++++++++++++++++++++++
 project_euler/problem_13/sol2.py |   5 ++
 project_euler/problem_16/sol2.py |   6 ++
 3 files changed, 111 insertions(+)
 create mode 100644 project_euler/problem_13/num.txt
 create mode 100644 project_euler/problem_13/sol2.py
 create mode 100644 project_euler/problem_16/sol2.py

diff --git a/project_euler/problem_13/num.txt b/project_euler/problem_13/num.txt
new file mode 100644
index 000000000000..43b568e812a8
--- /dev/null
+++ b/project_euler/problem_13/num.txt
@@ -0,0 +1,100 @@
+37107287533902102798797998220837590246510135740250
+46376937677490009712648124896970078050417018260538
+74324986199524741059474233309513058123726617309629
+91942213363574161572522430563301811072406154908250
+23067588207539346171171980310421047513778063246676
+89261670696623633820136378418383684178734361726757
+28112879812849979408065481931592621691275889832738
+44274228917432520321923589422876796487670272189318
+47451445736001306439091167216856844588711603153276
+70386486105843025439939619828917593665686757934951
+62176457141856560629502157223196586755079324193331
+64906352462741904929101432445813822663347944758178
+92575867718337217661963751590579239728245598838407
+58203565325359399008402633568948830189458628227828
+80181199384826282014278194139940567587151170094390
+35398664372827112653829987240784473053190104293586
+86515506006295864861532075273371959191420517255829
+71693888707715466499115593487603532921714970056938
+54370070576826684624621495650076471787294438377604
+53282654108756828443191190634694037855217779295145
+36123272525000296071075082563815656710885258350721
+45876576172410976447339110607218265236877223636045
+17423706905851860660448207621209813287860733969412
+81142660418086830619328460811191061556940512689692
+51934325451728388641918047049293215058642563049483
+62467221648435076201727918039944693004732956340691
+15732444386908125794514089057706229429197107928209
+55037687525678773091862540744969844508330393682126
+18336384825330154686196124348767681297534375946515
+80386287592878490201521685554828717201219257766954
+78182833757993103614740356856449095527097864797581
+16726320100436897842553539920931837441497806860984
+48403098129077791799088218795327364475675590848030
+87086987551392711854517078544161852424320693150332
+59959406895756536782107074926966537676326235447210
+69793950679652694742597709739166693763042633987085
+41052684708299085211399427365734116182760315001271
+65378607361501080857009149939512557028198746004375
+35829035317434717326932123578154982629742552737307
+94953759765105305946966067683156574377167401875275
+88902802571733229619176668713819931811048770190271
+25267680276078003013678680992525463401061632866526
+36270218540497705585629946580636237993140746255962
+24074486908231174977792365466257246923322810917141
+91430288197103288597806669760892938638285025333403
+34413065578016127815921815005561868836468420090470
+23053081172816430487623791969842487255036638784583
+11487696932154902810424020138335124462181441773470
+63783299490636259666498587618221225225512486764533
+67720186971698544312419572409913959008952310058822
+95548255300263520781532296796249481641953868218774
+76085327132285723110424803456124867697064507995236
+37774242535411291684276865538926205024910326572967
+23701913275725675285653248258265463092207058596522
+29798860272258331913126375147341994889534765745501
+18495701454879288984856827726077713721403798879715
+38298203783031473527721580348144513491373226651381
+34829543829199918180278916522431027392251122869539
+40957953066405232632538044100059654939159879593635
+29746152185502371307642255121183693803580388584903
+41698116222072977186158236678424689157993532961922
+62467957194401269043877107275048102390895523597457
+23189706772547915061505504953922979530901129967519
+86188088225875314529584099251203829009407770775672
+11306739708304724483816533873502340845647058077308
+82959174767140363198008187129011875491310547126581
+97623331044818386269515456334926366572897563400500
+42846280183517070527831839425882145521227251250327
+55121603546981200581762165212827652751691296897789
+32238195734329339946437501907836945765883352399886
+75506164965184775180738168837861091527357929701337
+62177842752192623401942399639168044983993173312731
+32924185707147349566916674687634660915035914677504
+99518671430235219628894890102423325116913619626622
+73267460800591547471830798392868535206946944540724
+76841822524674417161514036427982273348055556214818
+97142617910342598647204516893989422179826088076852
+87783646182799346313767754307809363333018982642090
+10848802521674670883215120185883543223812876952786
+71329612474782464538636993009049310363619763878039
+62184073572399794223406235393808339651327408011116
+66627891981488087797941876876144230030984490851411
+60661826293682836764744779239180335110989069790714
+85786944089552990653640447425576083659976645795096
+66024396409905389607120198219976047599490197230297
+64913982680032973156037120041377903785566085089252
+16730939319872750275468906903707539413042652315011
+94809377245048795150954100921645863754710598436791
+78639167021187492431995700641917969777599028300699
+15368713711936614952811305876380278410754449733078
+40789923115535562561142322423255033685442488917353
+44889911501440648020369068063960672322193204149535
+41503128880339536053299340368006977710650566631954
+81234880673210146739058568557934581403627822703280
+82616570773948327592232845941706525094512325230608
+22918802058777319719839450180888072429661980811197
+77158542502016545090413245809786882778948721859617
+72107838435069186155435662884062257473692284509516
+20849603980134001723930671666823555245252804609722
+53503534226472524250874054075591789781264330331690
diff --git a/project_euler/problem_13/sol2.py b/project_euler/problem_13/sol2.py
new file mode 100644
index 000000000000..c1416bcd6e7d
--- /dev/null
+++ b/project_euler/problem_13/sol2.py
@@ -0,0 +1,5 @@
+sum = 0
+with open("num.txt",'r') as f:
+    for line in f:
+        sum += int(line)
+print(str(sum)[:10])
diff --git a/project_euler/problem_16/sol2.py b/project_euler/problem_16/sol2.py
new file mode 100644
index 000000000000..cce3d2354bb1
--- /dev/null
+++ b/project_euler/problem_16/sol2.py
@@ -0,0 +1,6 @@
+from __future__ import print_function
+n = 2**1000
+r = 0
+while n:
+    r, n = r + n % 10, n // 10
+print(r)

From e2d9953952053130c63c51ce62c5ceb6cb084e91 Mon Sep 17 00:00:00 2001
From: Shoujue Xu <lightxusj@126.com>
Date: Tue, 9 Jul 2019 01:26:26 +0800
Subject: [PATCH 096/348] convolve and sobel (#971)

* add gaussian filter algorithm and lena.jpg

* add img_convolve algorithm and sobel_filter
---
 digital_image_processing/filters/convolve.py  | 49 +++++++++++++++++++
 .../filters/sobel_filter.py                   | 31 ++++++++++++
 2 files changed, 80 insertions(+)
 create mode 100644 digital_image_processing/filters/convolve.py
 create mode 100644 digital_image_processing/filters/sobel_filter.py

diff --git a/digital_image_processing/filters/convolve.py b/digital_image_processing/filters/convolve.py
new file mode 100644
index 000000000000..b7600d74c294
--- /dev/null
+++ b/digital_image_processing/filters/convolve.py
@@ -0,0 +1,49 @@
+# @Author  : lightXu
+# @File    : convolve.py
+# @Time    : 2019/7/8 0008 下午 16:13
+from cv2 import imread, cvtColor, COLOR_BGR2GRAY, imshow, waitKey
+from numpy import array, zeros, ravel, pad, dot, uint8
+
+
+def im2col(image, block_size):
+    rows, cols = image.shape
+    dst_height = cols - block_size[1] + 1
+    dst_width = rows - block_size[0] + 1
+    image_array = zeros((dst_height * dst_width, block_size[1] * block_size[0]))
+    row = 0
+    for i in range(0, dst_height):
+        for j in range(0, dst_width):
+            window = ravel(image[i:i + block_size[0], j:j + block_size[1]])
+            image_array[row, :] = window
+            row += 1
+
+    return image_array
+
+
+def img_convolve(image, filter_kernel):
+    height, width = image.shape[0], image.shape[1]
+    k_size = filter_kernel.shape[0]
+    pad_size = k_size//2
+    # Pads image with the edge values of array.
+    image_tmp = pad(image, pad_size, mode='edge')
+
+    # im2col, turn the k_size*k_size pixels into a row and np.vstack all rows
+    image_array = im2col(image_tmp, (k_size, k_size))
+
+    #  turn the kernel into shape(k*k, 1)
+    kernel_array = ravel(filter_kernel)
+    # reshape and get the dst image
+    dst = dot(image_array, kernel_array).reshape(height, width)
+    return dst
+
+
+if __name__ == '__main__':
+    # read original image
+    img = imread(r'../image_data/lena.jpg')
+    # turn image in gray scale value
+    gray = cvtColor(img, COLOR_BGR2GRAY)
+    # Laplace operator
+    Laplace_kernel = array([[0, 1, 0], [1, -4, 1], [0, 1, 0]])
+    out = img_convolve(gray, Laplace_kernel).astype(uint8)
+    imshow('Laplacian', out)
+    waitKey(0)
diff --git a/digital_image_processing/filters/sobel_filter.py b/digital_image_processing/filters/sobel_filter.py
new file mode 100644
index 000000000000..0c797320a110
--- /dev/null
+++ b/digital_image_processing/filters/sobel_filter.py
@@ -0,0 +1,31 @@
+# @Author  : lightXu
+# @File    : sobel_filter.py
+# @Time    : 2019/7/8 0008 下午 16:26
+import numpy as np
+from cv2 import imread, cvtColor, COLOR_BGR2GRAY, imshow, waitKey
+from digital_image_processing.filters.convolve import img_convolve
+
+
+def sobel_filter(image):
+    kernel_x = np.array([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]])
+    kernel_y = np.array([[1, 2, 1], [0, 0, 0], [-1, -2, -1]])
+
+    dst_x = img_convolve(image, kernel_x)
+    dst_y = img_convolve(image, kernel_y)
+    dst = np.sqrt((np.square(dst_x)) + (np.square(dst_y))).astype(np.uint8)
+    degree = np.arctan2(dst_y, dst_x)
+    return dst, degree
+
+
+if __name__ == '__main__':
+    # read original image
+    img = imread('../image_data/lena.jpg')
+    # turn image in gray scale value
+    gray = cvtColor(img, COLOR_BGR2GRAY)
+
+    sobel, d = sobel_filter(gray)
+
+    # show result images
+    imshow('sobel filter', sobel)
+    imshow('sobel degree', d)
+    waitKey(0)

From 8b2d1b7f509a1124abdd037803db32880402da19 Mon Sep 17 00:00:00 2001
From: Jasper <46252815+jasper256@users.noreply.github.com>
Date: Tue, 9 Jul 2019 03:03:18 -0400
Subject: [PATCH 097/348] added decimal to hexadecimal conversion (#977)

* added decimal to hexadecimal conversion

* fixed error occuring as more digits were needed
---
 conversions/decimal_to_hexadecimal.py | 43 +++++++++++++++++++++++++++
 1 file changed, 43 insertions(+)
 create mode 100644 conversions/decimal_to_hexadecimal.py

diff --git a/conversions/decimal_to_hexadecimal.py b/conversions/decimal_to_hexadecimal.py
new file mode 100644
index 000000000000..f91fac063adc
--- /dev/null
+++ b/conversions/decimal_to_hexadecimal.py
@@ -0,0 +1,43 @@
+""" Convert Base 10 (Decimal) Values to Hexadecimal Representations """
+
+# set decimal value for each hexadecimal digit
+values = {
+    0:'0',
+    1:'1',
+    2:'2',
+    3:'3',
+    4:'4',
+    5:'5',
+    6:'6',
+    7:'7',
+    8:'8',
+    9:'9',
+    10:'a',
+    11:'b',
+    12:'c',
+    13:'d',
+    14:'e',
+    15:'f'
+}
+
+def decimal_to_hexadecimal(decimal):
+    """ take decimal value, return hexadecimal representation as str """
+    hexadecimal = ''
+    while decimal > 0:
+        remainder = decimal % 16
+        decimal -= remainder
+        hexadecimal = values[remainder] + hexadecimal
+        decimal /= 16
+    return hexadecimal
+
+def main():
+    """ print test cases """
+    print("5 in hexadecimal is", decimal_to_hexadecimal(5))
+    print("15 in hexadecimal is", decimal_to_hexadecimal(15))
+    print("37 in hexadecimal is", decimal_to_hexadecimal(37))
+    print("255 in hexadecimal is", decimal_to_hexadecimal(255))
+    print("4096 in hexadecimal is", decimal_to_hexadecimal(4096))
+    print("999098 in hexadecimal is", decimal_to_hexadecimal(999098))
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file

From c85312da89dcc5bb1ad397feffc0e055dc576e85 Mon Sep 17 00:00:00 2001
From: Dharni0607 <30770547+Dharni0607@users.noreply.github.com>
Date: Tue, 9 Jul 2019 20:50:43 +0530
Subject: [PATCH 098/348] updates in closest pair of points algorithm (#979)

* updated closest pair of points (n*(logn)^2) to (n*logn)
---
 divide_and_conquer/closest_pair_of_points.py | 49 +++++++++++---------
 1 file changed, 28 insertions(+), 21 deletions(-)

diff --git a/divide_and_conquer/closest_pair_of_points.py b/divide_and_conquer/closest_pair_of_points.py
index cc5be428db79..ee06d27063df 100644
--- a/divide_and_conquer/closest_pair_of_points.py
+++ b/divide_and_conquer/closest_pair_of_points.py
@@ -1,27 +1,27 @@
 """
-The algorithm finds distance btw closest pair of points in the given n points.
+The algorithm finds distance between closest pair of points 
+in the given n points.
 Approach used -> Divide and conquer 
-The points are sorted based on Xco-ords 
-& by applying divide and conquer approach, 
+The points are sorted based on Xco-ords and 
+then based on Yco-ords separately.
+And by applying divide and conquer approach, 
 minimum distance is obtained recursively.
 
->> closest points lie on different sides of partition
+>> Closest points can lie on different sides of partition.
 This case handled by forming a strip of points 
 whose Xco-ords distance is less than closest_pair_dis
-from mid-point's Xco-ords.
+from mid-point's Xco-ords. Points sorted based on Yco-ords 
+are used in this step to reduce sorting time.
 Closest pair distance is found in the strip of points. (closest_in_strip)
 
 min(closest_pair_dis, closest_in_strip) would be the final answer.
  
-Time complexity: O(n * (logn)^2)
+Time complexity: O(n * log n)
 """
 
 
-import math 
-
-
 def euclidean_distance_sqr(point1, point2):
-    return pow(point1[0] - point2[0], 2) + pow(point1[1] - point2[1], 2)
+    return (point1[0] - point2[0]) ** 2 + (point1[1] - point2[1]) ** 2
 
 
 def column_based_sort(array, column = 0):
@@ -66,7 +66,7 @@ def dis_between_closest_in_strip(points, points_counts, min_dis = float("inf")):
     return min_dis
 
 
-def closest_pair_of_points_sqr(points, points_counts):
+def closest_pair_of_points_sqr(points_sorted_on_x, points_sorted_on_y, points_counts):
     """ divide and conquer approach
 
     Parameters : 
@@ -79,12 +79,16 @@ def closest_pair_of_points_sqr(points, points_counts):
 
     # base case
     if points_counts <= 3:
-        return dis_between_closest_pair(points, points_counts)
+        return dis_between_closest_pair(points_sorted_on_x, points_counts)
     
     # recursion
     mid = points_counts//2
-    closest_in_left = closest_pair_of_points(points[:mid], mid)
-    closest_in_right = closest_pair_of_points(points[mid:], points_counts - mid)
+    closest_in_left = closest_pair_of_points_sqr(points_sorted_on_x, 
+                                                 points_sorted_on_y[:mid], 
+                                                 mid)
+    closest_in_right = closest_pair_of_points_sqr(points_sorted_on_y, 
+                                                  points_sorted_on_y[mid:], 
+                                                  points_counts - mid)
     closest_pair_dis = min(closest_in_left, closest_in_right)
     
     """ cross_strip contains the points, whose Xcoords are at a 
@@ -92,22 +96,25 @@ def closest_pair_of_points_sqr(points, points_counts):
     """
 
     cross_strip = []
-    for point in points:
-        if abs(point[0] - points[mid][0]) < closest_pair_dis:
+    for point in points_sorted_on_x:
+        if abs(point[0] - points_sorted_on_x[mid][0]) < closest_pair_dis:
             cross_strip.append(point)
 
-    cross_strip = column_based_sort(cross_strip, 1)
     closest_in_strip = dis_between_closest_in_strip(cross_strip, 
                      len(cross_strip), closest_pair_dis)
     return min(closest_pair_dis, closest_in_strip)
 
     
 def closest_pair_of_points(points, points_counts):
-    return math.sqrt(closest_pair_of_points_sqr(points, points_counts))
+    points_sorted_on_x = column_based_sort(points, column = 0)
+    points_sorted_on_y = column_based_sort(points, column = 1)
+    return (closest_pair_of_points_sqr(points_sorted_on_x, 
+                                       points_sorted_on_y, 
+                                       points_counts)) ** 0.5
 
 
-points = [(2, 3), (12, 30), (40, 50), (5, 1), (12, 10), (0, 2), (5, 6), (1, 2)]
-points = column_based_sort(points)
-print("Distance:", closest_pair_of_points(points, len(points)))
+if __name__ == "__main__":
+    points = [(2, 3), (12, 30), (40, 50), (5, 1), (12, 10), (3, 4)] 
+    print("Distance:", closest_pair_of_points(points, len(points)))
 
 

From e6eaa078e292dc856f1027331e8de30b43a918f9 Mon Sep 17 00:00:00 2001
From: cclauss <cclauss@me.com>
Date: Wed, 10 Jul 2019 06:59:39 +0200
Subject: [PATCH 099/348] Pytest the entire repo (#980)

* Pytest the entire repo

* Do each directory for now...

* YAML files hate tabs

* Add more requirements

* pip install opencv-python

* Comment out FTP

* Add pandas and sklearn to requirements

* Comment out FTP, graphs, machine_learning, maths, neural_network, project_euler

* Update .travis.yml

* Comment out Data structures

* if __name__ == "__main__":

* pytest --ignore=

* pytest .

* Update .travis.yml

* pytest . --doctest-modules --ignore=${IGNORE}

* Ignore --ignore because it just hangs
---
 .travis.yml                                   | 24 ++++++++++++++++++-
 ...longest_increasing_subsequence_O(nlogn).py |  5 ++--
 requirements.txt                              |  5 ++++
 3 files changed, 31 insertions(+), 3 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index e67bd431a7c1..0e35fd084268 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -2,13 +2,35 @@ language: python
 dist: xenial  # required for Python >= 3.7
 python: 3.7
 cache: pip
+before_install: pip install --upgrade pip setuptools
 install: pip install -r requirements.txt
 before_script:
   - black --check . || true
   - flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
 script:
   - mypy --ignore-missing-imports .
-  - pytest --doctest-modules ./ciphers ./other ./searches ./sorts ./strings
+  #- IGNORE="data_structures,file_transfer_protocol,graphs,machine_learning,maths,neural_network,project_euler"
+  #- pytest . --doctest-modules --ignore=${IGNORE}
+  - pytest --doctest-modules
+      arithmetic_analysis
+      backtracking
+      boolean_algebra
+      ciphers
+      compression
+      conversions
+      digital_image_processing
+      divide_and_conquer
+      dynamic_programming
+      hashes
+      linear_algebra_python
+      matrix
+      networking_flow
+      other
+      searches
+      sorts
+      strings
+      traversals
+
 after_success:
   - python ./~script.py
   - cat DIRECTORY.md
diff --git a/dynamic_programming/longest_increasing_subsequence_O(nlogn).py b/dynamic_programming/longest_increasing_subsequence_O(nlogn).py
index 21122a04d69f..86bec089adc7 100644
--- a/dynamic_programming/longest_increasing_subsequence_O(nlogn).py
+++ b/dynamic_programming/longest_increasing_subsequence_O(nlogn).py
@@ -37,5 +37,6 @@ def LongestIncreasingSubsequenceLength(v):
 	return length
 	
 
-v = [2, 5, 3, 7, 11, 8, 10, 13, 6]
-print(LongestIncreasingSubsequenceLength(v))
+if __name__ == "__main__":
+	v = [2, 5, 3, 7, 11, 8, 10, 13, 6]
+	print(LongestIncreasingSubsequenceLength(v))
diff --git a/requirements.txt b/requirements.txt
index 30179ac345b3..91d3df33323d 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -3,4 +3,9 @@ flake8
 matplotlib
 mypy
 numpy
+opencv-python
+pandas
 pytest
+sklearn
+sympy
+tensorflow

From add1aef0645790f2688c8ad44ddfdf6638ab8cb1 Mon Sep 17 00:00:00 2001
From: PatOnTheBack <51241310+PatOnTheBack@users.noreply.github.com>
Date: Wed, 10 Jul 2019 01:21:04 -0400
Subject: [PATCH 100/348] Rename average.py to average_mean.py (#939)

'average.py' is ambiguous. There are several kinds of averages, so 'average_mean.py' is a more precise name.
---
 maths/{average.py => average_mean.py} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename maths/{average.py => average_mean.py} (100%)

diff --git a/maths/average.py b/maths/average_mean.py
similarity index 100%
rename from maths/average.py
rename to maths/average_mean.py

From 34dee749a725b0d47811161b0598b9f806ce88cd Mon Sep 17 00:00:00 2001
From: Shoujue Xu <lightxusj@126.com>
Date: Wed, 10 Jul 2019 22:41:05 +0800
Subject: [PATCH 101/348] add canny edge detection algorithm and modify
 sobel_filter (#991)

* add gaussian filter algorithm and lena.jpg

* add img_convolve algorithm and sobel_filter

* add canny edge detection algorithm and modify sobel_filter

* format to avoid the backslashes
---
 .../edge_detection/__init__.py                |   0
 .../edge_detection/canny.py                   | 107 ++++++++++++++++++
 .../filters/sobel_filter.py                   |  23 ++--
 3 files changed, 122 insertions(+), 8 deletions(-)
 create mode 100644 digital_image_processing/edge_detection/__init__.py
 create mode 100644 digital_image_processing/edge_detection/canny.py

diff --git a/digital_image_processing/edge_detection/__init__.py b/digital_image_processing/edge_detection/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/digital_image_processing/edge_detection/canny.py b/digital_image_processing/edge_detection/canny.py
new file mode 100644
index 000000000000..7fde75a90a48
--- /dev/null
+++ b/digital_image_processing/edge_detection/canny.py
@@ -0,0 +1,107 @@
+import cv2
+import numpy as np
+from digital_image_processing.filters.convolve import img_convolve
+from digital_image_processing.filters.sobel_filter import sobel_filter
+
+PI = 180
+
+
+def gen_gaussian_kernel(k_size, sigma):
+    center = k_size // 2
+    x, y = np.mgrid[0 - center:k_size - center, 0 - center:k_size - center]
+    g = 1 / (2 * np.pi * sigma) * np.exp(-(np.square(x) + np.square(y)) / (2 * np.square(sigma)))
+    return g
+
+
+def canny(image, threshold_low=15, threshold_high=30, weak=128, strong=255):
+    image_row, image_col = image.shape[0], image.shape[1]
+    # gaussian_filter
+    gaussian_out = img_convolve(image, gen_gaussian_kernel(9, sigma=1.4))
+    # get the gradient and degree by sobel_filter
+    sobel_grad, sobel_theta = sobel_filter(gaussian_out)
+    gradient_direction = np.rad2deg(sobel_theta)
+    gradient_direction += PI
+
+    dst = np.zeros((image_row, image_col))
+
+    """
+    Non-maximum suppression. If the edge strength of the current pixel is the largest compared to the other pixels 
+    in the mask with the same direction, the value will be preserved. Otherwise, the value will be suppressed. 
+    """
+    for row in range(1, image_row - 1):
+        for col in range(1, image_col - 1):
+            direction = gradient_direction[row, col]
+
+            if (
+                0 <= direction < 22.5
+                    or 15 * PI / 8 <= direction <= 2 * PI
+                    or 7 * PI / 8 <= direction <= 9 * PI / 8
+            ):
+                W = sobel_grad[row, col - 1]
+                E = sobel_grad[row, col + 1]
+                if sobel_grad[row, col] >= W and sobel_grad[row, col] >= E:
+                    dst[row, col] = sobel_grad[row, col]
+
+            elif (PI / 8 <= direction < 3 * PI / 8) or (9 * PI / 8 <= direction < 11 * PI / 8):
+                SW = sobel_grad[row + 1, col - 1]
+                NE = sobel_grad[row - 1, col + 1]
+                if sobel_grad[row, col] >= SW and sobel_grad[row, col] >= NE:
+                    dst[row, col] = sobel_grad[row, col]
+
+            elif (3 * PI / 8 <= direction < 5 * PI / 8) or (11 * PI / 8 <= direction < 13 * PI / 8):
+                N = sobel_grad[row - 1, col]
+                S = sobel_grad[row + 1, col]
+                if sobel_grad[row, col] >= N and sobel_grad[row, col] >= S:
+                    dst[row, col] = sobel_grad[row, col]
+
+            elif (5 * PI / 8 <= direction < 7 * PI / 8) or (13 * PI / 8 <= direction < 15 * PI / 8):
+                NW = sobel_grad[row - 1, col - 1]
+                SE = sobel_grad[row + 1, col + 1]
+                if sobel_grad[row, col] >= NW and sobel_grad[row, col] >= SE:
+                    dst[row, col] = sobel_grad[row, col]
+
+            """
+            High-Low threshold detection. If an edge pixel’s gradient value is higher than the high threshold
+            value, it is marked as a strong edge pixel. If an edge pixel’s gradient value is smaller than the high
+            threshold value and larger than the low threshold value, it is marked as a weak edge pixel. If an edge
+            pixel's value is smaller than the low threshold value, it will be suppressed.
+            """
+            if dst[row, col] >= threshold_high:
+                dst[row, col] = strong
+            elif dst[row, col] <= threshold_low:
+                dst[row, col] = 0
+            else:
+                dst[row, col] = weak
+
+    """
+    Edge tracking. Usually a weak edge pixel caused from true edges will be connected to a strong edge pixel while
+    noise responses are unconnected. As long as there is one strong edge pixel that is involved in its 8-connected
+    neighborhood, that weak edge point can be identified as one that should be preserved.
+    """
+    for row in range(1, image_row):
+        for col in range(1, image_col):
+            if dst[row, col] == weak:
+                if 255 in (
+                        dst[row, col + 1],
+                        dst[row, col - 1],
+                        dst[row - 1, col],
+                        dst[row + 1, col],
+                        dst[row - 1, col - 1],
+                        dst[row + 1, col - 1],
+                        dst[row - 1, col + 1],
+                        dst[row + 1, col + 1],
+                ):
+                    dst[row, col] = strong
+                else:
+                    dst[row, col] = 0
+
+    return dst
+
+
+if __name__ == '__main__':
+    # read original image in gray mode
+    lena = cv2.imread(r'../image_data/lena.jpg', 0)
+    # canny edge detection
+    canny_dst = canny(lena)
+    cv2.imshow('canny', canny_dst)
+    cv2.waitKey(0)
diff --git a/digital_image_processing/filters/sobel_filter.py b/digital_image_processing/filters/sobel_filter.py
index 0c797320a110..f3ef407d49e5 100644
--- a/digital_image_processing/filters/sobel_filter.py
+++ b/digital_image_processing/filters/sobel_filter.py
@@ -10,11 +10,18 @@ def sobel_filter(image):
     kernel_x = np.array([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]])
     kernel_y = np.array([[1, 2, 1], [0, 0, 0], [-1, -2, -1]])
 
-    dst_x = img_convolve(image, kernel_x)
-    dst_y = img_convolve(image, kernel_y)
-    dst = np.sqrt((np.square(dst_x)) + (np.square(dst_y))).astype(np.uint8)
-    degree = np.arctan2(dst_y, dst_x)
-    return dst, degree
+    dst_x = np.abs(img_convolve(image, kernel_x))
+    dst_y = np.abs(img_convolve(image, kernel_y))
+    # modify the pix within [0, 255]
+    dst_x = dst_x * 255/np.max(dst_x)
+    dst_y = dst_y * 255/np.max(dst_y)
+
+    dst_xy = np.sqrt((np.square(dst_x)) + (np.square(dst_y)))
+    dst_xy = dst_xy * 255/np.max(dst_xy)
+    dst = dst_xy.astype(np.uint8)
+
+    theta = np.arctan2(dst_y, dst_x)
+    return dst, theta
 
 
 if __name__ == '__main__':
@@ -23,9 +30,9 @@ def sobel_filter(image):
     # turn image in gray scale value
     gray = cvtColor(img, COLOR_BGR2GRAY)
 
-    sobel, d = sobel_filter(gray)
+    sobel_grad, sobel_theta = sobel_filter(gray)
 
     # show result images
-    imshow('sobel filter', sobel)
-    imshow('sobel degree', d)
+    imshow('sobel filter', sobel_grad)
+    imshow('sobel theta', sobel_theta)
     waitKey(0)

From 2ad5be99192ade89c26752fb9d6fb7c32bc0337f Mon Sep 17 00:00:00 2001
From: PatOnTheBack <51241310+PatOnTheBack@users.noreply.github.com>
Date: Wed, 10 Jul 2019 16:00:30 -0400
Subject: [PATCH 102/348] Modified Docstrings to Fix Errors (#975)

I modified the Docstrings at the beginning of the file to fix D400, W0105, and E402.
---
 graphs/BFS.py | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/graphs/BFS.py b/graphs/BFS.py
index bf9b572cec50..6bbdd9e25435 100644
--- a/graphs/BFS.py
+++ b/graphs/BFS.py
@@ -1,6 +1,8 @@
-"""pseudo-code"""
-
 """
+BFS.
+
+pseudo-code:
+
 BFS(graph G, start vertex s):
 // all nodes initially unexplored
 mark s as explored

From 897f1d0fb4c4f78dd8a7e82820e843f7f9f38738 Mon Sep 17 00:00:00 2001
From: PatOnTheBack <51241310+PatOnTheBack@users.noreply.github.com>
Date: Wed, 10 Jul 2019 16:09:24 -0400
Subject: [PATCH 103/348] Improved Formatting and Style of Math Algos (#960)

* Improved Formatting and Style

I improved formatting and style to make PyLama happier.

Linters used:

- mccabe
- pep257
- pydocstyle
- pep8
- pycodestyle
- pyflakes
- pylint
- isort

* Create volume.py

This script calculates the volumes of various shapes.

* Delete lucasSeries.py

* Revert "Delete lucasSeries.py"

This reverts commit 64c19f7a6c8b74e15bed07f0f0337598a001ceb4.

* Update lucasSeries.py
---
 maths/Binary_Exponentiation.py        |  26 +++----
 maths/Find_Min.py                     |  17 +++--
 maths/Prime_Check.py                  |  49 +++++++------
 maths/abs.py                          |  13 ++--
 maths/extended_euclidean_algorithm.py |  53 +++++++++-----
 maths/fermat_little_theorem.py        |   6 +-
 maths/greater_common_divisor.py       |  18 +++--
 maths/modular_exponential.py          |  31 ++++----
 maths/segmented_sieve.py              |  43 ++++++-----
 maths/sieve_of_eratosthenes.py        |  31 ++++----
 maths/simpson_rule.py                 |  60 ++++++++--------
 maths/trapezoidal_rule.py             |  24 +++----
 maths/volume.py                       | 100 ++++++++++++++++++++++++++
 13 files changed, 314 insertions(+), 157 deletions(-)
 create mode 100644 maths/volume.py

diff --git a/maths/Binary_Exponentiation.py b/maths/Binary_Exponentiation.py
index 2411cd58a76b..cf789afc6f22 100644
--- a/maths/Binary_Exponentiation.py
+++ b/maths/Binary_Exponentiation.py
@@ -1,25 +1,27 @@
-#Author : Junth Basnet
-#Time Complexity : O(logn)
+"""Binary Exponentiation."""
+
+# Author : Junth Basnet
+# Time Complexity : O(logn)
+
 
 def binary_exponentiation(a, n):
-    
+
     if (n == 0):
         return 1
-    
+
     elif (n % 2 == 1):
         return binary_exponentiation(a, n - 1) * a
-    
+
     else:
         b = binary_exponentiation(a, n / 2)
         return b * b
 
-    
+
 try:
-    base = int(input('Enter Base : '))
-    power = int(input("Enter Power : "))
+    BASE = int(input('Enter Base : '))
+    POWER = int(input("Enter Power : "))
 except ValueError:
-    print ("Invalid literal for integer")
+    print("Invalid literal for integer")
 
-result = binary_exponentiation(base, power)
-print("{}^({}) : {}".format(base, power, result))
-    
+RESULT = binary_exponentiation(BASE, POWER)
+print("{}^({}) : {}".format(BASE, POWER, RESULT))
diff --git a/maths/Find_Min.py b/maths/Find_Min.py
index 86207984e3da..c720da268a25 100644
--- a/maths/Find_Min.py
+++ b/maths/Find_Min.py
@@ -1,12 +1,17 @@
+"""Find Minimum Number in a List."""
+
+
 def main():
-    def findMin(x):
-        minNum = x[0]
+    """Find Minimum Number in a List."""
+    def find_min(x):
+        min_num = x[0]
         for i in x:
-            if minNum > i:
-                minNum = i
-        return minNum
+            if min_num > i:
+                min_num = i
+        return min_num
+
+    print(find_min([0, 1, 2, 3, 4, 5, -3, 24, -56]))  # = -56
 
-    print(findMin([0,1,2,3,4,5,-3,24,-56])) # = -56
 
 if __name__ == '__main__':
     main()
diff --git a/maths/Prime_Check.py b/maths/Prime_Check.py
index 8c5c181689dd..9249834dc069 100644
--- a/maths/Prime_Check.py
+++ b/maths/Prime_Check.py
@@ -1,9 +1,13 @@
+"""Prime Check."""
+
 import math
 import unittest
 
 
-def primeCheck(number):
+def prime_check(number):
     """
+    Check to See if a Number is Prime.
+
     A number is prime if it has exactly two dividers: 1 and itself.
     """
     if number < 2:
@@ -24,31 +28,30 @@ def primeCheck(number):
 
 class Test(unittest.TestCase):
     def test_primes(self):
-        self.assertTrue(primeCheck(2))
-        self.assertTrue(primeCheck(3))
-        self.assertTrue(primeCheck(5))
-        self.assertTrue(primeCheck(7))
-        self.assertTrue(primeCheck(11))
-        self.assertTrue(primeCheck(13))
-        self.assertTrue(primeCheck(17))
-        self.assertTrue(primeCheck(19))
-        self.assertTrue(primeCheck(23))
-        self.assertTrue(primeCheck(29))
+        self.assertTrue(prime_check(2))
+        self.assertTrue(prime_check(3))
+        self.assertTrue(prime_check(5))
+        self.assertTrue(prime_check(7))
+        self.assertTrue(prime_check(11))
+        self.assertTrue(prime_check(13))
+        self.assertTrue(prime_check(17))
+        self.assertTrue(prime_check(19))
+        self.assertTrue(prime_check(23))
+        self.assertTrue(prime_check(29))
 
     def test_not_primes(self):
-        self.assertFalse(primeCheck(-19),
-                "Negative numbers are not prime.")
-        self.assertFalse(primeCheck(0),
-                "Zero doesn't have any divider, primes must have two")
-        self.assertFalse(primeCheck(1),
-                "One just have 1 divider, primes must have two.")
-        self.assertFalse(primeCheck(2 * 2))
-        self.assertFalse(primeCheck(2 * 3))
-        self.assertFalse(primeCheck(3 * 3))
-        self.assertFalse(primeCheck(3 * 5))
-        self.assertFalse(primeCheck(3 * 5 * 7))
+        self.assertFalse(prime_check(-19),
+                         "Negative numbers are not prime.")
+        self.assertFalse(prime_check(0),
+                         "Zero doesn't have any divider, primes must have two")
+        self.assertFalse(prime_check(1),
+                         "One just have 1 divider, primes must have two.")
+        self.assertFalse(prime_check(2 * 2))
+        self.assertFalse(prime_check(2 * 3))
+        self.assertFalse(prime_check(3 * 3))
+        self.assertFalse(prime_check(3 * 5))
+        self.assertFalse(prime_check(3 * 5 * 7))
 
 
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/maths/abs.py b/maths/abs.py
index 624823fc183e..2734e58ceee6 100644
--- a/maths/abs.py
+++ b/maths/abs.py
@@ -1,24 +1,25 @@
 """Absolute Value."""
 
 
-def absVal(num):
+def abs_val(num):
     """
     Find the absolute value of a number.
 
-    >>absVal(-5)
+    >>abs_val(-5)
     5
-    >>absVal(0)
+    >>abs_val(0)
     0
     """
     if num < 0:
         return -num
-    else:
-        return num
+
+    # Returns if number is not < 0
+    return num
 
 
 def main():
     """Print absolute value of -34."""
-    print(absVal(-34))  # = 34
+    print(abs_val(-34))  # = 34
 
 
 if __name__ == '__main__':
diff --git a/maths/extended_euclidean_algorithm.py b/maths/extended_euclidean_algorithm.py
index f5a3cc88e474..fc3798e7e432 100644
--- a/maths/extended_euclidean_algorithm.py
+++ b/maths/extended_euclidean_algorithm.py
@@ -1,20 +1,38 @@
+"""
+Extended Euclidean Algorithm.
+
+Finds 2 numbers a and b such that it satisfies
+the equation am + bn = gcd(m, n) (a.k.a Bezout's Identity)
+"""
+
 # @Author: S. Sharma <silentcat>
 # @Date:   2019-02-25T12:08:53-06:00
 # @Email:  silentcat@protonmail.com
-# @Last modified by:   silentcat
-# @Last modified time: 2019-02-26T07:07:38-06:00
+# @Last modified by:   PatOnTheBack
+# @Last modified time: 2019-07-05
 
 import sys
 
-# Finds 2 numbers a and b such that it satisfies
-# the equation am + bn = gcd(m, n) (a.k.a Bezout's Identity)
+
 def extended_euclidean_algorithm(m, n):
-    a = 0; aprime = 1; b = 1; bprime = 0
-    q = 0; r = 0
+    """
+    Extended Euclidean Algorithm.
+
+    Finds 2 numbers a and b such that it satisfies
+    the equation am + bn = gcd(m, n) (a.k.a Bezout's Identity)
+    """
+    a = 0
+    a_prime = 1
+    b = 1
+    b_prime = 0
+    q = 0
+    r = 0
     if m > n:
-        c = m; d = n
+        c = m
+        d = n
     else:
-        c = n; d = m
+        c = n
+        d = m
 
     while True:
         q = int(c / d)
@@ -24,22 +42,24 @@ def extended_euclidean_algorithm(m, n):
         c = d
         d = r
 
-        t = aprime
-        aprime = a
-        a = t - q*a
+        t = a_prime
+        a_prime = a
+        a = t - q * a
 
-        t = bprime
-        bprime = b
-        b = t - q*b
+        t = b_prime
+        b_prime = b
+        b = t - q * b
 
     pair = None
     if m > n:
-        pair = (a,b)
+        pair = (a, b)
     else:
-        pair = (b,a)
+        pair = (b, a)
     return pair
 
+
 def main():
+    """Call Extended Euclidean Algorithm."""
     if len(sys.argv) < 3:
         print('2 integer arguments required')
         exit(1)
@@ -47,5 +67,6 @@ def main():
     n = int(sys.argv[2])
     print(extended_euclidean_algorithm(m, n))
 
+
 if __name__ == '__main__':
     main()
diff --git a/maths/fermat_little_theorem.py b/maths/fermat_little_theorem.py
index 93af98684894..8cf60dafe3ca 100644
--- a/maths/fermat_little_theorem.py
+++ b/maths/fermat_little_theorem.py
@@ -5,13 +5,13 @@
 
 
 def binary_exponentiation(a, n, mod):
-    
+
     if (n == 0):
         return 1
-    
+
     elif (n % 2 == 1):
         return (binary_exponentiation(a, n - 1, mod) * a) % mod
-    
+
     else:
         b = binary_exponentiation(a, n / 2, mod)
         return (b * b) % mod
diff --git a/maths/greater_common_divisor.py b/maths/greater_common_divisor.py
index 15adaca1fb8d..adc7811e8317 100644
--- a/maths/greater_common_divisor.py
+++ b/maths/greater_common_divisor.py
@@ -1,15 +1,25 @@
-# Greater Common Divisor - https://en.wikipedia.org/wiki/Greatest_common_divisor
+"""
+Greater Common Divisor.
+
+Wikipedia reference: https://en.wikipedia.org/wiki/Greatest_common_divisor
+"""
+
+
 def gcd(a, b):
+    """Calculate Greater Common Divisor (GCD)."""
     return b if a == 0 else gcd(b % a, a)
 
+
 def main():
+    """Call GCD Function."""
     try:
         nums = input("Enter two Integers separated by comma (,): ").split(',')
-        num1 = int(nums[0]); num2 = int(nums[1])
+        num_1 = int(nums[0])
+        num_2 = int(nums[1])
     except (IndexError, UnboundLocalError, ValueError):
         print("Wrong Input")
-    print(f"gcd({num1}, {num2}) = {gcd(num1, num2)}")
+    print(f"gcd({num_1}, {num_2}) = {gcd(num_1, num_2)}")
+
 
 if __name__ == '__main__':
     main()
-
diff --git a/maths/modular_exponential.py b/maths/modular_exponential.py
index b3f4c00bd5d8..750de7cba99e 100644
--- a/maths/modular_exponential.py
+++ b/maths/modular_exponential.py
@@ -1,20 +1,25 @@
-def modularExponential(base, power, mod):
-	if power < 0:
-		return -1
-	base %= mod
-	result = 1
+"""Modular Exponential."""
 
-	while power > 0:
-		if power & 1:
-			result = (result * base) % mod
-		power = power >> 1
-		base = (base * base) % mod
-	return result
+
+def modular_exponential(base, power, mod):
+    """Calculate Modular Exponential."""
+    if power < 0:
+        return -1
+    base %= mod
+    result = 1
+
+    while power > 0:
+        if power & 1:
+            result = (result * base) % mod
+        power = power >> 1
+        base = (base * base) % mod
+    return result
 
 
 def main():
-	print(modularExponential(3, 200, 13))
+    """Call Modular Exponential Function."""
+    print(modular_exponential(3, 200, 13))
 
 
 if __name__ == '__main__':
-	main()
+    main()
diff --git a/maths/segmented_sieve.py b/maths/segmented_sieve.py
index 52ca6fbe601d..b15ec2480678 100644
--- a/maths/segmented_sieve.py
+++ b/maths/segmented_sieve.py
@@ -1,46 +1,51 @@
+"""Segmented Sieve."""
+
 import math
 
+
 def sieve(n):
+    """Segmented Sieve."""
     in_prime = []
     start = 2
-    end   = int(math.sqrt(n)) # Size of every segment
+    end = int(math.sqrt(n))  # Size of every segment
     temp = [True] * (end + 1)
     prime = []
-    
-    while(start <= end):
-        if temp[start] == True:
+
+    while start <= end:
+        if temp[start] is True:
             in_prime.append(start)
-            for i in range(start*start, end+1, start):
-                if temp[i] == True:
+            for i in range(start * start, end + 1, start):
+                if temp[i] is True:
                     temp[i] = False
         start += 1
     prime += in_prime
-    
+
     low = end + 1
     high = low + end - 1
     if high > n:
         high = n
-    
-    while(low <= n):
-        temp = [True] * (high-low+1)
+
+    while low <= n:
+        temp = [True] * (high - low + 1)
         for each in in_prime:
-            
+
             t = math.floor(low / each) * each
             if t < low:
                 t += each
-            
-            for j in range(t, high+1, each):
+
+            for j in range(t, high + 1, each):
                 temp[j - low] = False
-                
+
         for j in range(len(temp)):
-            if temp[j] == True:
-                prime.append(j+low)
-        
+            if temp[j] is True:
+                prime.append(j + low)
+
         low = high + 1
         high = low + end - 1
         if high > n:
             high = n
-            
+
     return prime
 
-print(sieve(10**6))
\ No newline at end of file
+
+print(sieve(10**6))
diff --git a/maths/sieve_of_eratosthenes.py b/maths/sieve_of_eratosthenes.py
index 26c17fa6ffec..11c123693694 100644
--- a/maths/sieve_of_eratosthenes.py
+++ b/maths/sieve_of_eratosthenes.py
@@ -1,24 +1,29 @@
+"""Sieve of Eratosthones."""
+
 import math
-n = int(input("Enter n: "))
+
+N = int(input("Enter n: "))
+
 
 def sieve(n):
-    l = [True] * (n+1)
+    """Sieve of Eratosthones."""
+    l = [True] * (n + 1)
     prime = []
     start = 2
-    end   = int(math.sqrt(n))
-    while(start <= end):
-        if l[start] == True:
+    end = int(math.sqrt(n))
+    while start <= end:
+        if l[start] is True:
             prime.append(start)
-            for i in range(start*start, n+1, start):
-                if l[i] == True:
+            for i in range(start * start, n + 1, start):
+                if l[i] is True:
                     l[i] = False
         start += 1
-    
-    for j in range(end+1,n+1):
-        if l[j] == True:
+
+    for j in range(end + 1, n + 1):
+        if l[j] is True:
             prime.append(j)
-    
+
     return prime
 
-print(sieve(n))
-        
+
+print(sieve(N))
diff --git a/maths/simpson_rule.py b/maths/simpson_rule.py
index 091c86c17f1b..2b237d2e1a4e 100644
--- a/maths/simpson_rule.py
+++ b/maths/simpson_rule.py
@@ -1,49 +1,49 @@
 
-'''
+"""
 Numerical integration or quadrature for a smooth function f with known values at x_i
 
-This method is the classical approch of suming 'Equally Spaced Abscissas' 
+This method is the classical approch of suming 'Equally Spaced Abscissas'
 
-method 2: 
+method 2:
 "Simpson Rule"
 
-'''
+"""
 from __future__ import print_function
 
 
 def method_2(boundary, steps):
 # "Simpson Rule"
 # int(f) = delta_x/2 * (b-a)/3*(f1 + 4f2 + 2f_3 + ... + fn)
-	h = (boundary[1] - boundary[0]) / steps
-	a = boundary[0]
-	b = boundary[1]
-	x_i = makePoints(a,b,h)
-	y = 0.0
-	y += (h/3.0)*f(a)
-	cnt = 2
-	for i in x_i:
-		y += (h/3)*(4-2*(cnt%2))*f(i)	
-		cnt += 1
-	y += (h/3.0)*f(b)
-	return y
-
-def makePoints(a,b,h):
-	x = a + h
-	while x < (b-h):
-		yield x
-		x = x + h
+    h = (boundary[1] - boundary[0]) / steps
+    a = boundary[0]
+    b = boundary[1]
+    x_i = make_points(a,b,h)
+    y = 0.0
+    y += (h/3.0)*f(a)
+    cnt = 2
+    for i in x_i:
+        y += (h/3)*(4-2*(cnt%2))*f(i)
+        cnt += 1
+    y += (h/3.0)*f(b)
+    return y
+
+def make_points(a,b,h):
+    x = a + h
+    while x < (b-h):
+        yield x
+        x = x + h
 
 def f(x): #enter your function here
-	y = (x-0)*(x-0)
-	return y
+    y = (x-0)*(x-0)
+    return y
 
 def main():
-	a = 0.0 #Lower bound of integration
-	b = 1.0	#Upper bound of integration
-	steps = 10.0		#define number of steps or resolution
-	boundary = [a, b]	#define boundary of integration
-	y = method_2(boundary, steps)
-	print('y = {0}'.format(y))
+    a = 0.0 #Lower bound of integration
+    b = 1.0    #Upper bound of integration
+    steps = 10.0        #define number of steps or resolution
+    boundary = [a, b]    #define boundary of integration
+    y = method_2(boundary, steps)
+    print('y = {0}'.format(y))
 
 if __name__ == '__main__':
         main()
diff --git a/maths/trapezoidal_rule.py b/maths/trapezoidal_rule.py
index 52310c1ed3b0..789f263c6991 100644
--- a/maths/trapezoidal_rule.py
+++ b/maths/trapezoidal_rule.py
@@ -1,12 +1,12 @@
-'''
+"""
 Numerical integration or quadrature for a smooth function f with known values at x_i
 
-This method is the classical approch of suming 'Equally Spaced Abscissas' 
+This method is the classical approch of suming 'Equally Spaced Abscissas'
 
-method 1: 
+method 1:
 "extended trapezoidal rule"
 
-'''
+"""
 from __future__ import print_function
 
 def method_1(boundary, steps):
@@ -15,21 +15,21 @@ def method_1(boundary, steps):
 	h = (boundary[1] - boundary[0]) / steps
 	a = boundary[0]
 	b = boundary[1]
-	x_i = makePoints(a,b,h)
-	y = 0.0	
+	x_i = make_points(a,b,h)
+	y = 0.0
 	y += (h/2.0)*f(a)
 	for i in x_i:
 		#print(i)	
 		y += h*f(i)
-	y += (h/2.0)*f(b)	
-	return y	
+	y += (h/2.0)*f(b)
+	return y
 
-def makePoints(a,b,h):
-	x = a + h	
+def make_points(a,b,h):
+	x = a + h
 	while x < (b-h):
 		yield x
 		x = x + h
-		
+
 def f(x): #enter your function here
 	y = (x-0)*(x-0)
 	return y
@@ -37,7 +37,7 @@ def f(x): #enter your function here
 def main():
 	a = 0.0 #Lower bound of integration
 	b = 1.0	#Upper bound of integration
-	steps = 10.0		#define number of steps or resolution	
+	steps = 10.0		#define number of steps or resolution
 	boundary = [a, b]	#define boundary of integration
 	y = method_1(boundary, steps)
 	print('y = {0}'.format(y))
diff --git a/maths/volume.py b/maths/volume.py
new file mode 100644
index 000000000000..171bc538f5a4
--- /dev/null
+++ b/maths/volume.py
@@ -0,0 +1,100 @@
+"""
+Find Volumes of Various Shapes.
+
+Wikipedia reference: https://en.wikipedia.org/wiki/Volume
+"""
+
+from math import pi
+
+PI = pi
+
+
+def vol_cube(side_length):
+    """Calculate the Volume of a Cube."""
+    # Cube side_length.
+    return float(side_length ** 3)
+
+
+def vol_cuboid(width, height, length):
+    """Calculate the Volume of a Cuboid."""
+    # Multiply lengths together.
+    return float(width * height * length)
+
+
+def vol_cone(area_of_base, height):
+    """
+    Calculate the Volume of a Cone.
+
+    Wikipedia reference: https://en.wikipedia.org/wiki/Cone
+    volume = (1/3) * area_of_base * height
+    """
+    return (float(1) / 3) * area_of_base * height
+
+
+def vol_right_circ_cone(radius, height):
+    """
+    Calculate the Volume of a Right Circular Cone.
+
+    Wikipedia reference: https://en.wikipedia.org/wiki/Cone
+    volume = (1/3) * pi * radius^2 * height
+    """
+
+    import math
+
+    return (float(1) / 3) * PI * (radius ** 2) * height
+
+
+def vol_prism(area_of_base, height):
+    """
+    Calculate the Volume of a Prism.
+
+    V = Bh
+    Wikipedia reference: https://en.wikipedia.org/wiki/Prism_(geometry)
+    """
+    return float(area_of_base * height)
+
+
+def vol_pyramid(area_of_base, height):
+    """
+    Calculate the Volume of a Prism.
+
+    V = (1/3) * Bh
+    Wikipedia reference: https://en.wikipedia.org/wiki/Pyramid_(geometry)
+    """
+    return (float(1) / 3) * area_of_base * height
+
+
+def vol_sphere(radius):
+    """
+    Calculate the Volume of a Sphere.
+
+    V = (4/3) * pi * r^3
+    Wikipedia reference: https://en.wikipedia.org/wiki/Sphere
+    """
+    return (float(4) / 3) * PI * radius ** 3
+
+
+def vol_circular_cylinder(radius, height):
+    """Calculate the Volume of a Circular Cylinder.
+
+    Wikipedia reference: https://en.wikipedia.org/wiki/Cylinder
+    volume = pi * radius^2 * height
+    """
+    return PI * radius ** 2 * height
+
+
+def main():
+    """Print the Results of Various Volume Calculations."""
+    print("Volumes:")
+    print("Cube: " + str(vol_cube(2)))  # = 8
+    print("Cuboid: " + str(vol_cuboid(2, 2, 2)))  # = 8
+    print("Cone: " + str(vol_cone(2, 2)))  # ~= 1.33
+    print("Right Circular Cone: " + str(vol_right_circ_cone(2, 2)))  # ~= 8.38
+    print("Prism: " + str(vol_prism(2, 2)))  # = 4
+    print("Pyramid: " + str(vol_pyramid(2, 2)))  # ~= 1.33
+    print("Sphere: " + str(vol_sphere(2)))  # ~= 33.5
+    print("Circular Cylinder: " + str(vol_circular_cylinder(2, 2)))  # ~= 25.1
+
+
+if __name__ == "__main__":
+    main()

From 37fbd8ca2ed404767ad8514edd6e0330c0306a58 Mon Sep 17 00:00:00 2001
From: Sanders Lin <45224617+SandersLin@users.noreply.github.com>
Date: Thu, 11 Jul 2019 04:38:10 +0800
Subject: [PATCH 104/348] Update average_median.py (#998)

added doctest, fixed TypeError: list indices must be integers or slices, not float error due to number/2 producing float as index.
---
 maths/average_median.py | 43 +++++++++++++++++------------------------
 1 file changed, 18 insertions(+), 25 deletions(-)

diff --git a/maths/average_median.py b/maths/average_median.py
index 565bb4afd112..eab0107d8da8 100644
--- a/maths/average_median.py
+++ b/maths/average_median.py
@@ -1,41 +1,34 @@
-"""
-Find median of a list of numbers.
+def median(nums):
+    """
+    Find median of a list of numbers.
 
-Read more about medians:
-    https://en.wikipedia.org/wiki/Median
-"""
+    >>> median([0])
+    0
+    >>> median([4,1,3,2])
+    2.5
 
+    Args:
+        nums: List of nums
 
-def median(nums):
-    """Find median of a list of numbers."""
-    # Sort list
+    Returns:
+        Median.
+    """
     sorted_list = sorted(nums)
-    print("List of numbers:")
-    print(sorted_list)
-
-    # Is number of items in list even?
+    med = None
     if len(sorted_list) % 2 == 0:
-        # Find index for first middle value.
-        mid_index_1 = len(sorted_list) / 2
-        # Find index for second middle value.
-        mid_index_2 = -(len(sorted_list) / 2) - 1
-        # Divide middle values by 2 to get average (mean).
+        mid_index_1 = len(sorted_list) // 2
+        mid_index_2 = (len(sorted_list) // 2) - 1
         med = (sorted_list[mid_index_1] + sorted_list[mid_index_2]) / float(2)
-        return med  # Return makes `else:` unnecessary.
-    # Number of items is odd.
-    mid_index = (len(sorted_list) - 1) / 2
-    # Middle index is median.
-    med = sorted_list[mid_index]
+    else:
+        mid_index = (len(sorted_list) - 1) // 2
+        med = sorted_list[mid_index]
     return med
 
-
 def main():
-    """Call average module to find median of a specific list of numbers."""
     print("Odd number of numbers:")
     print(median([2, 4, 6, 8, 20, 50, 70]))
     print("Even number of numbers:")
     print(median([2, 4, 6, 8, 20, 50]))
 
-
 if __name__ == '__main__':
     main()

From b79a197e8c05251cf9443cbc5c15bb66ae23f3d8 Mon Sep 17 00:00:00 2001
From: Sanders Lin <45224617+SandersLin@users.noreply.github.com>
Date: Thu, 11 Jul 2019 12:43:03 +0800
Subject: [PATCH 105/348] Update abs_Max.py (#997)

* Update abs_Max.py

fix docstring for doctest to work properly (add space after >>>)

* Update abs_Max.py
---
 maths/abs_Max.py | 23 +++++++++++++++--------
 1 file changed, 15 insertions(+), 8 deletions(-)

diff --git a/maths/abs_Max.py b/maths/abs_Max.py
index 7ff9e4d3ca09..28f631f0100e 100644
--- a/maths/abs_Max.py
+++ b/maths/abs_Max.py
@@ -1,8 +1,10 @@
-def absMax(x):
+from typing import List 
+
+def abs_max(x: List[int]) -> int:
     """
-    #>>>absMax([0,5,1,11])
+    >>> abs_max([0,5,1,11])
     11
-    >>absMax([3,-10,-2])
+    >>> abs_max([3,-10,-2])
     -10
     """
     j =x[0]
@@ -11,15 +13,20 @@ def absMax(x):
             j = i
     return j
 
+def abs_max_sort(x):
+    """
+    >>> abs_max_sort([0,5,1,11])
+    11
+    >>> abs_max_sort([3,-10,-2])
+    -10
+    """
+    return sorted(x,key=abs)[-1]
 
 def main():
     a = [1,2,-11]
-    print(absMax(a)) # = -11
-
+    assert abs_max(a) == -11
+    assert abs_max_sort(a) == -11
 
 if __name__ == '__main__':
     main()
 
-"""
-print abs Max
-"""

From 5f991f7740f8bbb801d5442e07f6e2881e3a7e1d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alfonso=20Rodr=C3=ADguez=20Pereira?= <arodriguez@teltek.es>
Date: Thu, 11 Jul 2019 11:16:42 +0200
Subject: [PATCH 106/348] #315 Renamed all files to snake_case (#993)

---
 ciphers/{Atbash.py => atbash.py}                                  | 0
 ...{morse_Code_implementation.py => morse_code_implementation.py} | 0
 data_structures/binary_tree/{AVL_tree.py => avl_tree.py}          | 0
 data_structures/binary_tree/{LCA.py => lca.py}                    | 0
 .../linked_list/{is_Palindrome.py => is_palindrome.py}            | 0
 .../{Fractional_Knapsack.py => fractional_knapsack.py}            | 0
 ...nce_O(nlogn).py => longest_increasing_subsequence_o(nlogn).py} | 0
 graphs/{BFS.py => bfs.py}                                         | 0
 graphs/{DFS.py => dfs.py}                                         | 0
 ...hted)_Graph.py => directed_and_undirected_(weighted)_graph.py} | 0
 ...graph.py => eulerian_path_and_circuit_for_undirected_graph.py} | 0
 maths/{abs_Max.py => abs_max.py}                                  | 0
 maths/{abs_Min.py => abs_min.py}                                  | 0
 maths/{Binary_Exponentiation.py => binary_exponentiation.py}      | 0
 maths/{Find_Max.py => find_max.py}                                | 0
 maths/{Find_Min.py => find_min.py}                                | 0
 maths/{Prime_Check.py => prime_check.py}                          | 0
 other/{finding_Primes.py => finding_primes.py}                    | 0
 sorts/{Bitonic_Sort.py => bitonic_sort.py}                        | 0
 ...ansposition_parallel.py => odd_even_transposition_parallel.py} | 0
 ...ngle-threaded.py => odd_even_transposition_single_threaded.py} | 0
 strings/{Boyer_Moore_Search.py => boyer_moore_search.py}          | 0
 strings/{naive_String_Search.py => naive_string_search.py}        | 0
 23 files changed, 0 insertions(+), 0 deletions(-)
 rename ciphers/{Atbash.py => atbash.py} (100%)
 rename ciphers/{morse_Code_implementation.py => morse_code_implementation.py} (100%)
 rename data_structures/binary_tree/{AVL_tree.py => avl_tree.py} (100%)
 rename data_structures/binary_tree/{LCA.py => lca.py} (100%)
 rename data_structures/linked_list/{is_Palindrome.py => is_palindrome.py} (100%)
 rename dynamic_programming/{Fractional_Knapsack.py => fractional_knapsack.py} (100%)
 rename dynamic_programming/{longest_increasing_subsequence_O(nlogn).py => longest_increasing_subsequence_o(nlogn).py} (100%)
 rename graphs/{BFS.py => bfs.py} (100%)
 rename graphs/{DFS.py => dfs.py} (100%)
 rename graphs/{Directed_and_Undirected_(Weighted)_Graph.py => directed_and_undirected_(weighted)_graph.py} (100%)
 rename graphs/{Eulerian_path_and_circuit_for_undirected_graph.py => eulerian_path_and_circuit_for_undirected_graph.py} (100%)
 rename maths/{abs_Max.py => abs_max.py} (100%)
 rename maths/{abs_Min.py => abs_min.py} (100%)
 rename maths/{Binary_Exponentiation.py => binary_exponentiation.py} (100%)
 rename maths/{Find_Max.py => find_max.py} (100%)
 rename maths/{Find_Min.py => find_min.py} (100%)
 rename maths/{Prime_Check.py => prime_check.py} (100%)
 rename other/{finding_Primes.py => finding_primes.py} (100%)
 rename sorts/{Bitonic_Sort.py => bitonic_sort.py} (100%)
 rename sorts/{Odd-Even_transposition_parallel.py => odd_even_transposition_parallel.py} (100%)
 rename sorts/{Odd-Even_transposition_single-threaded.py => odd_even_transposition_single_threaded.py} (100%)
 rename strings/{Boyer_Moore_Search.py => boyer_moore_search.py} (100%)
 rename strings/{naive_String_Search.py => naive_string_search.py} (100%)

diff --git a/ciphers/Atbash.py b/ciphers/atbash.py
similarity index 100%
rename from ciphers/Atbash.py
rename to ciphers/atbash.py
diff --git a/ciphers/morse_Code_implementation.py b/ciphers/morse_code_implementation.py
similarity index 100%
rename from ciphers/morse_Code_implementation.py
rename to ciphers/morse_code_implementation.py
diff --git a/data_structures/binary_tree/AVL_tree.py b/data_structures/binary_tree/avl_tree.py
similarity index 100%
rename from data_structures/binary_tree/AVL_tree.py
rename to data_structures/binary_tree/avl_tree.py
diff --git a/data_structures/binary_tree/LCA.py b/data_structures/binary_tree/lca.py
similarity index 100%
rename from data_structures/binary_tree/LCA.py
rename to data_structures/binary_tree/lca.py
diff --git a/data_structures/linked_list/is_Palindrome.py b/data_structures/linked_list/is_palindrome.py
similarity index 100%
rename from data_structures/linked_list/is_Palindrome.py
rename to data_structures/linked_list/is_palindrome.py
diff --git a/dynamic_programming/Fractional_Knapsack.py b/dynamic_programming/fractional_knapsack.py
similarity index 100%
rename from dynamic_programming/Fractional_Knapsack.py
rename to dynamic_programming/fractional_knapsack.py
diff --git a/dynamic_programming/longest_increasing_subsequence_O(nlogn).py b/dynamic_programming/longest_increasing_subsequence_o(nlogn).py
similarity index 100%
rename from dynamic_programming/longest_increasing_subsequence_O(nlogn).py
rename to dynamic_programming/longest_increasing_subsequence_o(nlogn).py
diff --git a/graphs/BFS.py b/graphs/bfs.py
similarity index 100%
rename from graphs/BFS.py
rename to graphs/bfs.py
diff --git a/graphs/DFS.py b/graphs/dfs.py
similarity index 100%
rename from graphs/DFS.py
rename to graphs/dfs.py
diff --git a/graphs/Directed_and_Undirected_(Weighted)_Graph.py b/graphs/directed_and_undirected_(weighted)_graph.py
similarity index 100%
rename from graphs/Directed_and_Undirected_(Weighted)_Graph.py
rename to graphs/directed_and_undirected_(weighted)_graph.py
diff --git a/graphs/Eulerian_path_and_circuit_for_undirected_graph.py b/graphs/eulerian_path_and_circuit_for_undirected_graph.py
similarity index 100%
rename from graphs/Eulerian_path_and_circuit_for_undirected_graph.py
rename to graphs/eulerian_path_and_circuit_for_undirected_graph.py
diff --git a/maths/abs_Max.py b/maths/abs_max.py
similarity index 100%
rename from maths/abs_Max.py
rename to maths/abs_max.py
diff --git a/maths/abs_Min.py b/maths/abs_min.py
similarity index 100%
rename from maths/abs_Min.py
rename to maths/abs_min.py
diff --git a/maths/Binary_Exponentiation.py b/maths/binary_exponentiation.py
similarity index 100%
rename from maths/Binary_Exponentiation.py
rename to maths/binary_exponentiation.py
diff --git a/maths/Find_Max.py b/maths/find_max.py
similarity index 100%
rename from maths/Find_Max.py
rename to maths/find_max.py
diff --git a/maths/Find_Min.py b/maths/find_min.py
similarity index 100%
rename from maths/Find_Min.py
rename to maths/find_min.py
diff --git a/maths/Prime_Check.py b/maths/prime_check.py
similarity index 100%
rename from maths/Prime_Check.py
rename to maths/prime_check.py
diff --git a/other/finding_Primes.py b/other/finding_primes.py
similarity index 100%
rename from other/finding_Primes.py
rename to other/finding_primes.py
diff --git a/sorts/Bitonic_Sort.py b/sorts/bitonic_sort.py
similarity index 100%
rename from sorts/Bitonic_Sort.py
rename to sorts/bitonic_sort.py
diff --git a/sorts/Odd-Even_transposition_parallel.py b/sorts/odd_even_transposition_parallel.py
similarity index 100%
rename from sorts/Odd-Even_transposition_parallel.py
rename to sorts/odd_even_transposition_parallel.py
diff --git a/sorts/Odd-Even_transposition_single-threaded.py b/sorts/odd_even_transposition_single_threaded.py
similarity index 100%
rename from sorts/Odd-Even_transposition_single-threaded.py
rename to sorts/odd_even_transposition_single_threaded.py
diff --git a/strings/Boyer_Moore_Search.py b/strings/boyer_moore_search.py
similarity index 100%
rename from strings/Boyer_Moore_Search.py
rename to strings/boyer_moore_search.py
diff --git a/strings/naive_String_Search.py b/strings/naive_string_search.py
similarity index 100%
rename from strings/naive_String_Search.py
rename to strings/naive_string_search.py

From c2f2fa8b231999905564006cc3dd2db55de5ecc7 Mon Sep 17 00:00:00 2001
From: Sanders Lin <45224617+SandersLin@users.noreply.github.com>
Date: Fri, 12 Jul 2019 00:20:41 +0800
Subject: [PATCH 107/348] Update abs_Min.py (#1004)

* Update abs_Min.py

* Create __init__.py

* Rename abs_Min.py to abs_min.py

* Update abs_min.py
---
 maths/__init__.py | 1 +
 maths/abs_min.py  | 5 +++--
 2 files changed, 4 insertions(+), 2 deletions(-)
 create mode 100644 maths/__init__.py

diff --git a/maths/__init__.py b/maths/__init__.py
new file mode 100644
index 000000000000..8b137891791f
--- /dev/null
+++ b/maths/__init__.py
@@ -0,0 +1 @@
+
diff --git a/maths/abs_min.py b/maths/abs_min.py
index 67d510551907..d546196aa1b5 100644
--- a/maths/abs_min.py
+++ b/maths/abs_min.py
@@ -1,4 +1,5 @@
-from Maths.abs import absVal
+from abs import abs_val
+
 def absMin(x):
     """
     # >>>absMin([0,5,1,11])
@@ -8,7 +9,7 @@ def absMin(x):
     """
     j = x[0]
     for i in x:
-        if absVal(i) < absVal(j):
+        if abs_val(i) < abs_val(j):
             j = i
     return j
 

From f2eb965604ef704d1ffc1a79acaba8b8c58e204b Mon Sep 17 00:00:00 2001
From: FrogBattle <44649323+FrogBattle@users.noreply.github.com>
Date: Thu, 11 Jul 2019 17:21:48 +0100
Subject: [PATCH 108/348] Update ~script.py (#990)

Changing the boolean expression avoids the use of a continue statement.
This way the code becomes easier/faster to compute on lower level and it has a
better coding style.
---
 ~script.py | 19 +++++++++----------
 1 file changed, 9 insertions(+), 10 deletions(-)

diff --git a/~script.py b/~script.py
index c44f3436fcec..1fbb1e838c62 100644
--- a/~script.py
+++ b/~script.py
@@ -20,16 +20,15 @@ def _markdown(parent, ignores, ignores_ext, depth):
     for i in os.listdir(parent):
         full = os.path.join(parent, i)
         name, ext = os.path.splitext(i)
-        if i in ignores or ext in ignores_ext:
-            continue
-        if os.path.isfile(full):
-            # generate list
-            pre = parent.replace("./", "").replace(" ", "%20")
-            # replace all spaces to safe URL
-            child = i.replace(" ", "%20")
-            files.append((pre, child, name))
-        else:
-            dirs.append(i)
+        if i not in ignores and ext not in ignores_ext:
+            if os.path.isfile(full):
+                # generate list
+                pre = parent.replace("./", "").replace(" ", "%20")
+                # replace all spaces to safe URL
+                child = i.replace(" ", "%20")
+                files.append((pre, child, name))
+            else:
+                dirs.append(i)   
     # Sort files
     files.sort(key=lambda e: e[2].lower())
     for f in files:

From 1dc9ec8fb2c51372800762b8e3f734eb93ec1814 Mon Sep 17 00:00:00 2001
From: obelisk0114 <obelisk0114@gmail.com>
Date: Fri, 12 Jul 2019 08:16:14 -0700
Subject: [PATCH 109/348] Update Bucket Sort time complexity analysis (#918)

---
 sorts/bucket_sort.py | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/sorts/bucket_sort.py b/sorts/bucket_sort.py
index 5c4a71513ed3..0678b1194657 100644
--- a/sorts/bucket_sort.py
+++ b/sorts/bucket_sort.py
@@ -17,7 +17,12 @@
 # number of buckets.
 
 #  Time Complexity of Solution:
-#  Best Case O(n); Average Case O(n); Worst Case O(n)
+#  Worst case scenario occurs when all the elements are placed in a single bucket. The overall performance 
+#  would then be dominated by the algorithm used to sort each bucket. In this case, O(n log n), because of TimSort 
+#
+#  Average Case O(n + (n^2)/k + k), where k is the number of buckets
+#
+#  If k = O(n), time complexity is O(n)
 
 DEFAULT_BUCKET_SIZE = 5
 

From 1e0b33d3dd7eda32a97fe73df09df20e2004eb98 Mon Sep 17 00:00:00 2001
From: Sanders Lin <45224617+SandersLin@users.noreply.github.com>
Date: Sat, 13 Jul 2019 15:04:43 +0800
Subject: [PATCH 110/348] Update 3n+1.py (#996)

* Update 3n+1.py

Made variable names more meaningful and removed nested functions.

* Update 3n+1.py

* Update 3n+1.py

* Update 3n+1.py
---
 maths/3n+1.py | 41 ++++++++++++++++++++++++++---------------
 1 file changed, 26 insertions(+), 15 deletions(-)

diff --git a/maths/3n+1.py b/maths/3n+1.py
index 6424fe0d8f15..d6c14ff0f47d 100644
--- a/maths/3n+1.py
+++ b/maths/3n+1.py
@@ -1,19 +1,30 @@
-def main():
-    def n31(a):# a = initial number
-        c = 0
-        l = [a]
-        while a != 1:
-            if a % 2 == 0:#if even divide it by 2
-                a = a // 2
-            elif a % 2 == 1:#if odd 3n+1
-                a = 3*a +1
-            c += 1#counter
-            l += [a]
+from typing import Tuple, List
+
+def n31(a: int) -> Tuple[List[int], int]: 
+    """
+    Returns the Collatz sequence and its length of any postiver integer.
+    >>> n31(4)
+    ([4, 2, 1], 3)
+    """
 
-        return l , c
-    print(n31(43))
-    print(n31(98)[0][-1])# = a
-    print("It took {0} steps.".format(n31(13)[1]))#optional finish
+    if not isinstance(a, int):
+        raise TypeError('Must be int, not {0}'.format(type(a).__name__))
+    if a < 1: 
+        raise ValueError('Given integer must be greater than 1, not {0}'.format(a))
+    
+    path = [a]
+    while a != 1:
+        if a % 2 == 0:
+            a = a // 2
+        else:
+            a = 3*a +1
+        path += [a]
+    return path, len(path)
+
+def main():
+    num = 4
+    path , length = n31(num)
+    print("The Collatz sequence of {0} took {1} steps. \nPath: {2}".format(num,length, path))
 
 if __name__ == '__main__':
     main()

From 7a6ebb85a2e8eda43131803f2104cdbba07cb164 Mon Sep 17 00:00:00 2001
From: Sanders Lin <45224617+SandersLin@users.noreply.github.com>
Date: Sat, 13 Jul 2019 15:10:02 +0800
Subject: [PATCH 111/348] Update edit_distance.py (#1001)

added bottom up method.
---
 dynamic_programming/edit_distance.py | 34 ++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/dynamic_programming/edit_distance.py b/dynamic_programming/edit_distance.py
index 335e5196ed53..b71f80d68935 100644
--- a/dynamic_programming/edit_distance.py
+++ b/dynamic_programming/edit_distance.py
@@ -52,6 +52,35 @@ def solve(self, A, B):
 
         return self.__solveDP(len(A)-1, len(B)-1)
 
+
+def min_distance_bottom_up(word1: str, word2: str) -> int:
+    """
+    >>> min_distance_bottom_up("intention", "execution")
+    5
+    >>> min_distance_bottom_up("intention", "")
+    9
+    >>> min_distance_bottom_up("", "")
+    0
+    """
+    m = len(word1)
+    n = len(word2)
+    dp = [[0 for _ in range(n+1) ] for _ in range(m+1)]
+    for i in range(m+1):
+        for j in range(n+1):
+            
+            if i == 0:  #first string is empty
+                dp[i][j] = j
+            elif j == 0: #second string is empty 
+                dp[i][j] = i 
+            elif word1[i-1] == word2[j-1]: #last character of both substing is equal
+                dp[i][j] = dp[i-1][j-1]
+            else: 
+                insert = dp[i][j-1]
+                delete = dp[i-1][j]
+                replace = dp[i-1][j-1]
+                dp[i][j] = 1 + min(insert, delete, replace)
+    return dp[m][n]
+
 if __name__ == '__main__':
         try:
             raw_input          # Python 2
@@ -71,5 +100,10 @@ def solve(self, A, B):
 
         print()
         print("The minimum Edit Distance is: %d" % (solver.solve(S1, S2)))
+        print("The minimum Edit Distance is: %d" % (min_distance_bottom_up(S1, S2)))
         print()
         print("*************** End of Testing Edit Distance DP Algorithm ***************")
+
+
+
+ 

From 7271c0d64acf4881636f08c4c2dcb00cbe757798 Mon Sep 17 00:00:00 2001
From: Sanders Lin <45224617+SandersLin@users.noreply.github.com>
Date: Sat, 13 Jul 2019 15:12:54 +0800
Subject: [PATCH 112/348] Update rod_cutting.py (#995)

* Update rod_cutting.py

A hopefully clearer implementation without dependence on global variables.

* Update rod_cutting.py

added doctests

* Update rod_cutting.py

* Update rod_cutting.py
---
 dynamic_programming/rod_cutting.py | 115 ++++++++++++++---------------
 1 file changed, 57 insertions(+), 58 deletions(-)

diff --git a/dynamic_programming/rod_cutting.py b/dynamic_programming/rod_cutting.py
index 34350cb8202b..c3111dcfc8a1 100644
--- a/dynamic_programming/rod_cutting.py
+++ b/dynamic_programming/rod_cutting.py
@@ -1,58 +1,57 @@
-### PROBLEM ###
-"""
-We are given a rod of length n and we are given the array of prices, also of
-length n. This array contains the price for selling a rod at a certain length.
-For example, prices[5] shows the price we can sell a rod of length 5.
-Generalising, prices[x] shows the price a rod of length x can be sold.
-We are tasked to find the optimal solution to sell the given rod.
-"""
-
-### SOLUTION ###
-"""
-Profit(n) = max(1<i<n){Price(n),Price(i)+Profit(n-i)}
-
-When we receive a rod, we have two options:
-a) Don't cut it and sell it as is (receiving prices[length])
-b) Cut it and sell it in two parts. The length we cut it and the rod we are
-left with, which we have to try and sell separately in an efficient way.
-Choose the maximum price we can get.
-"""
-
-def CutRod(n):
-    if(n == 1):
-        #Cannot cut rod any further
-        return prices[1]
-
-    noCut = prices[n] #The price you get when you don't cut the rod
-    yesCut = [-1 for x in range(n)] #The prices for the different cutting options
-
-    for i in range(1,n):
-        if(solutions[i] == -1):
-            #We haven't calulated solution for length i yet.
-            #We know we sell the part of length i so we get prices[i].
-            #We just need to know how to sell rod of length n-i
-            yesCut[i] = prices[i] + CutRod(n-i)
-        else:
-            #We have calculated solution for length i.
-            #We add the two prices.
-            yesCut[i] = prices[i] + solutions[n-i]
-
-    #We need to find the highest price in order to sell more efficiently.
-    #We have to choose between noCut and the prices in yesCut.
-    m = noCut #Initialize max to noCut
-    for i in range(n):
-        if(yesCut[i] > m):
-            m = yesCut[i]
-
-    solutions[n] = m
-    return m
-
-
-
-### EXAMPLE ###
-length = 5
-#The first price, 0, is for when we have no rod.
-prices = [0, 1, 3, 7, 9, 11, 13, 17, 21, 21, 30]
-solutions = [-1 for x in range(length+1)]
-
-print(CutRod(length))
+from typing import List
+
+def rod_cutting(prices: List[int],length: int) -> int:
+	"""
+	Given a rod of length n and array of prices that indicate price at each length.
+	Determine the maximum value obtainable by cutting up the rod and selling the pieces
+	
+	>>> rod_cutting([1,5,8,9],4) 
+	10
+	>>> rod_cutting([1,1,1],3) 
+	3
+	>>> rod_cutting([1,2,3], -1)
+	Traceback (most recent call last):
+   	ValueError: Given integer must be greater than 1, not -1
+   	>>> rod_cutting([1,2,3], 3.2)
+	Traceback (most recent call last):
+   	TypeError: Must be int, not float
+   	>>> rod_cutting([], 3)
+	Traceback (most recent call last):
+   	AssertionError: prices list is shorted than length: 3
+	
+	
+
+	Args:
+		prices: list indicating price at each length, where prices[0] = 0 indicating rod of zero length has no value
+	    length: length of rod
+
+	Returns:
+	    Maximum revenue attainable by cutting up the rod in any way. 
+	"""
+
+	prices.insert(0, 0)
+	if not isinstance(length, int):
+	    raise TypeError('Must be int, not {0}'.format(type(length).__name__))
+	if length < 0: 
+	    raise ValueError('Given integer must be greater than 1, not {0}'.format(length))
+	assert len(prices) - 1 >= length, "prices list is shorted than length: {0}".format(length) 
+
+	return rod_cutting_recursive(prices, length)
+
+def rod_cutting_recursive(prices: List[int],length: int) -> int:
+	#base case 
+	if length == 0:
+		return 0
+	value = float('-inf')
+	for firstCutLocation in range(1,length+1):
+		value = max(value, prices[firstCutLocation]+rod_cutting_recursive(prices,length - firstCutLocation))
+	return value
+
+
+def main():
+	assert rod_cutting([1,5,8,9,10,17,17,20,24,30],10) == 30
+	# print(rod_cutting([],0))
+
+if __name__ == '__main__':
+	main()
+

From d72586c5f4164ed2b518d6badea9d9a89e756689 Mon Sep 17 00:00:00 2001
From: Hector S <hfsam88@gmail.com>
Date: Sat, 13 Jul 2019 15:50:37 -0400
Subject: [PATCH 113/348] Updated ~script.py per #978 (#1013)

* Added print function into matrix_multiplication_addition.py and removed blank space in data_structures/binary tree directory

* Removed .vs/ folder per #893

* Rename matrix_multiplication_addition.py to matrix_operation.py

* Moved and renamed ~script.py to scripts/build_directory_md.py
Updated DIRECTORY.MD file

* Modified .travis.yml per suggestion in #1013

* Fixed typo per suggestions in #1013
---
 .travis.yml                                 |   2 +-
 DIRECTORY.md                                | 123 +++++++++++---------
 ~script.py => scripts/build_directory_md.py |   4 +-
 3 files changed, 73 insertions(+), 56 deletions(-)
 rename ~script.py => scripts/build_directory_md.py (97%)

diff --git a/.travis.yml b/.travis.yml
index 0e35fd084268..9afc0c93a037 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -32,5 +32,5 @@ script:
       traversals
 
 after_success:
-  - python ./~script.py
+  - python scripts/build_directory_md.py
   - cat DIRECTORY.md
diff --git a/DIRECTORY.md b/DIRECTORY.md
index befd634c1eb0..66128228abc3 100644
--- a/DIRECTORY.md
+++ b/DIRECTORY.md
@@ -4,13 +4,17 @@
   * [lu decomposition](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/lu_decomposition.py)
   * [newton method](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/newton_method.py)
   * [newton raphson method](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/newton_raphson_method.py)
-## Binary Tree
-  * [basic binary tree](https://github.com/TheAlgorithms/Python/blob/master/binary_tree/basic_binary_tree.py)
+## Backtracking
+  * [all permutations](https://github.com/TheAlgorithms/Python/blob/master/backtracking/all_permutations.py)
+  * [all subsequences](https://github.com/TheAlgorithms/Python/blob/master/backtracking/all_subsequences.py)
+  * [minimax](https://github.com/TheAlgorithms/Python/blob/master/backtracking/minimax.py)
+  * [n queens](https://github.com/TheAlgorithms/Python/blob/master/backtracking/n_queens.py)
+  * [sum of subsets](https://github.com/TheAlgorithms/Python/blob/master/backtracking/sum_of_subsets.py)
 ## Boolean Algebra
   * [quine mc cluskey](https://github.com/TheAlgorithms/Python/blob/master/boolean_algebra/quine_mc_cluskey.py)
 ## Ciphers
   * [affine cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/affine_cipher.py)
-  * [Atbash](https://github.com/TheAlgorithms/Python/blob/master/ciphers/Atbash.py)
+  * [atbash](https://github.com/TheAlgorithms/Python/blob/master/ciphers/atbash.py)
   * [base16](https://github.com/TheAlgorithms/Python/blob/master/ciphers/base16.py)
   * [base32](https://github.com/TheAlgorithms/Python/blob/master/ciphers/base32.py)
   * [base64 cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/base64_cipher.py)
@@ -20,7 +24,7 @@
   * [cryptomath module](https://github.com/TheAlgorithms/Python/blob/master/ciphers/cryptomath_module.py)
   * [elgamal key generator](https://github.com/TheAlgorithms/Python/blob/master/ciphers/elgamal_key_generator.py)
   * [hill cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/hill_cipher.py)
-  * [morse Code implementation](https://github.com/TheAlgorithms/Python/blob/master/ciphers/morse_Code_implementation.py)
+  * [morse code implementation](https://github.com/TheAlgorithms/Python/blob/master/ciphers/morse_code_implementation.py)
   * [onepad cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/onepad_cipher.py)
   * [playfair cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/playfair_cipher.py)
   * [prehistoric men](https://github.com/TheAlgorithms/Python/blob/master/ciphers/prehistoric_men.txt)
@@ -36,17 +40,21 @@
   * [xor cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/xor_cipher.py)
 ## Compression
   * [huffman](https://github.com/TheAlgorithms/Python/blob/master/compression/huffman.py)
-## Compression Analysis
-  * [psnr](https://github.com/TheAlgorithms/Python/blob/master/compression_analysis/psnr.py)
+  * [peak signal to noise ratio](https://github.com/TheAlgorithms/Python/blob/master/compression/peak_signal_to_noise_ratio.py)
+  * Image Data
+## Conversions
+  * [decimal to binary](https://github.com/TheAlgorithms/Python/blob/master/conversions/decimal_to_binary.py)
+  * [decimal to hexadecimal](https://github.com/TheAlgorithms/Python/blob/master/conversions/decimal_to_hexadecimal.py)
+  * [decimal to octal](https://github.com/TheAlgorithms/Python/blob/master/conversions/decimal_to_octal.py)
 ## Data Structures
-  * [arrays](https://github.com/TheAlgorithms/Python/blob/master/data_structures/arrays.py)
-  * [avl](https://github.com/TheAlgorithms/Python/blob/master/data_structures/avl.py)
-  * [LCA](https://github.com/TheAlgorithms/Python/blob/master/data_structures/LCA.py)
   * Binary Tree
-    * [AVL tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/AVL_tree.py)
+    * [avl tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/avl_tree.py)
+    * [basic binary tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/basic_binary_tree.py)
     * [binary search tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/binary_search_tree.py)
     * [fenwick tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/fenwick_tree.py)
     * [lazy segment tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/lazy_segment_tree.py)
+    * [lca](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/lca.py)
+    * [red black tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/red_black_tree.py)
     * [segment tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/segment_tree.py)
     * [treap](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/treap.py)
   * Hashing
@@ -60,9 +68,9 @@
     * [heap](https://github.com/TheAlgorithms/Python/blob/master/data_structures/heap/heap.py)
   * Linked List
     * [doubly linked list](https://github.com/TheAlgorithms/Python/blob/master/data_structures/linked_list/doubly_linked_list.py)
-    * [is Palindrome](https://github.com/TheAlgorithms/Python/blob/master/data_structures/linked_list/is_Palindrome.py)
+    * [is palindrome](https://github.com/TheAlgorithms/Python/blob/master/data_structures/linked_list/is_palindrome.py)
     * [singly linked list](https://github.com/TheAlgorithms/Python/blob/master/data_structures/linked_list/singly_linked_list.py)
-    * [swapNodes](https://github.com/TheAlgorithms/Python/blob/master/data_structures/linked_list/swapNodes.py)
+    * [swap nodes](https://github.com/TheAlgorithms/Python/blob/master/data_structures/linked_list/swap_nodes.py)
   * Queue
     * [double ended queue](https://github.com/TheAlgorithms/Python/blob/master/data_structures/queue/double_ended_queue.py)
     * [queue on list](https://github.com/TheAlgorithms/Python/blob/master/data_structures/queue/queue_on_list.py)
@@ -71,18 +79,24 @@
     * [balanced parentheses](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stacks/balanced_parentheses.py)
     * [infix to postfix conversion](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stacks/infix_to_postfix_conversion.py)
     * [infix to prefix conversion](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stacks/infix_to_prefix_conversion.py)
-    * [next](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stacks/next.py)
+    * [next greater element](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stacks/next_greater_element.py)
     * [postfix evaluation](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stacks/postfix_evaluation.py)
     * [stack](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stacks/stack.py)
     * [stock span problem](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stacks/stock_span_problem.py)
   * Trie
     * [trie](https://github.com/TheAlgorithms/Python/blob/master/data_structures/trie/trie.py)
-  * Union Find
-    * [tests union find](https://github.com/TheAlgorithms/Python/blob/master/data_structures/union_find/tests_union_find.py)
-    * [union find](https://github.com/TheAlgorithms/Python/blob/master/data_structures/union_find/union_find.py)
 ## Digital Image Processing
+  * Edge Detection
+    * [canny](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/edge_detection/canny.py)
   * Filters
+    * [convolve](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/filters/convolve.py)
+    * [gaussian filter](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/filters/gaussian_filter.py)
     * [median filter](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/filters/median_filter.py)
+    * [sobel filter](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/filters/sobel_filter.py)
+  * Image Data
+## Divide And Conquer
+  * [closest pair of points](https://github.com/TheAlgorithms/Python/blob/master/divide_and_conquer/closest_pair_of_points.py)
+  * [max subarray sum](https://github.com/TheAlgorithms/Python/blob/master/divide_and_conquer/max_subarray_sum.py)
 ## Dynamic Programming
   * [abbreviation](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/abbreviation.py)
   * [bitmask](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/bitmask.py)
@@ -91,19 +105,20 @@
   * [fast fibonacci](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/fast_fibonacci.py)
   * [fibonacci](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/fibonacci.py)
   * [floyd warshall](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/floyd_warshall.py)
-  * [Fractional Knapsack](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/Fractional_Knapsack.py)
+  * [fractional knapsack](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/fractional_knapsack.py)
   * [integer partition](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/integer_partition.py)
   * [k means clustering tensorflow](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/k_means_clustering_tensorflow.py)
   * [knapsack](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/knapsack.py)
   * [longest common subsequence](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/longest_common_subsequence.py)
   * [longest increasing subsequence](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/longest_increasing_subsequence.py)
-  * [longest increasing subsequence O(nlogn)](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/longest_increasing_subsequence_O(nlogn).py)
+  * [longest increasing subsequence o(nlogn)](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/longest_increasing_subsequence_o(nlogn).py)
   * [longest sub array](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/longest_sub_array.py)
   * [matrix chain order](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/matrix_chain_order.py)
   * [max sub array](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/max_sub_array.py)
   * [minimum partition](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/minimum_partition.py)
   * [rod cutting](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/rod_cutting.py)
   * [subset generation](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/subset_generation.py)
+  * [sum of subset](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/sum_of_subset.py)
 ## File Transfer Protocol
   * [ftp client server](https://github.com/TheAlgorithms/Python/blob/master/file_transfer_protocol/ftp_client_server.py)
   * [ftp send receive](https://github.com/TheAlgorithms/Python/blob/master/file_transfer_protocol/ftp_send_receive.py)
@@ -112,19 +127,19 @@
   * [articulation points](https://github.com/TheAlgorithms/Python/blob/master/graphs/articulation_points.py)
   * [basic graphs](https://github.com/TheAlgorithms/Python/blob/master/graphs/basic_graphs.py)
   * [bellman ford](https://github.com/TheAlgorithms/Python/blob/master/graphs/bellman_ford.py)
-  * [BFS](https://github.com/TheAlgorithms/Python/blob/master/graphs/BFS.py)
+  * [bfs](https://github.com/TheAlgorithms/Python/blob/master/graphs/bfs.py)
   * [bfs shortest path](https://github.com/TheAlgorithms/Python/blob/master/graphs/bfs_shortest_path.py)
   * [breadth first search](https://github.com/TheAlgorithms/Python/blob/master/graphs/breadth_first_search.py)
   * [check bipartite graph bfs](https://github.com/TheAlgorithms/Python/blob/master/graphs/check_bipartite_graph_bfs.py)
   * [check bipartite graph dfs](https://github.com/TheAlgorithms/Python/blob/master/graphs/check_bipartite_graph_dfs.py)
   * [depth first search](https://github.com/TheAlgorithms/Python/blob/master/graphs/depth_first_search.py)
-  * [DFS](https://github.com/TheAlgorithms/Python/blob/master/graphs/DFS.py)
+  * [dfs](https://github.com/TheAlgorithms/Python/blob/master/graphs/dfs.py)
   * [dijkstra](https://github.com/TheAlgorithms/Python/blob/master/graphs/dijkstra.py)
   * [dijkstra 2](https://github.com/TheAlgorithms/Python/blob/master/graphs/dijkstra_2.py)
   * [dijkstra algorithm](https://github.com/TheAlgorithms/Python/blob/master/graphs/dijkstra_algorithm.py)
-  * [Directed and Undirected (Weighted) Graph](https://github.com/TheAlgorithms/Python/blob/master/graphs/Directed_and_Undirected_(Weighted)_Graph.py)
+  * [directed and undirected (weighted) graph](https://github.com/TheAlgorithms/Python/blob/master/graphs/directed_and_undirected_(weighted)_graph.py)
   * [edmonds karp multiple source and sink](https://github.com/TheAlgorithms/Python/blob/master/graphs/edmonds_karp_multiple_source_and_sink.py)
-  * [Eulerian path and circuit for undirected graph](https://github.com/TheAlgorithms/Python/blob/master/graphs/Eulerian_path_and_circuit_for_undirected_graph.py)
+  * [eulerian path and circuit for undirected graph](https://github.com/TheAlgorithms/Python/blob/master/graphs/eulerian_path_and_circuit_for_undirected_graph.py)
   * [even tree](https://github.com/TheAlgorithms/Python/blob/master/graphs/even_tree.py)
   * [finding bridges](https://github.com/TheAlgorithms/Python/blob/master/graphs/finding_bridges.py)
   * [floyd warshall](https://github.com/TheAlgorithms/Python/blob/master/graphs/floyd_warshall.py)
@@ -141,6 +156,7 @@
   * [tarjans scc](https://github.com/TheAlgorithms/Python/blob/master/graphs/tarjans_scc.py)
 ## Hashes
   * [chaos machine](https://github.com/TheAlgorithms/Python/blob/master/hashes/chaos_machine.py)
+  * [enigma machine](https://github.com/TheAlgorithms/Python/blob/master/hashes/enigma_machine.py)
   * [md5](https://github.com/TheAlgorithms/Python/blob/master/hashes/md5.py)
   * [sha1](https://github.com/TheAlgorithms/Python/blob/master/hashes/sha1.py)
 ## Linear Algebra Python
@@ -151,24 +167,26 @@
   * [decision tree](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/decision_tree.py)
   * [gradient descent](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/gradient_descent.py)
   * [k means clust](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/k_means_clust.py)
+  * [knn sklearn](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/knn_sklearn.py)
   * [linear regression](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/linear_regression.py)
   * [logistic regression](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/logistic_regression.py)
   * [perceptron](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/perceptron.py)
   * [scoring functions](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/scoring_functions.py)
   * Random Forest Classification
-    * [random forest classification](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/Random%20Forest%20Classification/random_forest_classification.py)
-    * [Social Network Ads](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/Random%20Forest%20Classification/Social_Network_Ads.csv)
+    * [random forest classification](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/random_forest_classification/random_forest_classification.py)
+    * [Social Network Ads](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/random_forest_classification/Social_Network_Ads.csv)
   * Random Forest Regression
-    * [Position Salaries](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/Random%20Forest%20Regression/Position_Salaries.csv)
-    * [random forest regression](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/Random%20Forest%20Regression/random_forest_regression.py)
+    * [Position Salaries](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/random_forest_regression/Position_Salaries.csv)
+    * [random forest regression](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/random_forest_regression/random_forest_regression.py)
 ## Maths
   * [3n+1](https://github.com/TheAlgorithms/Python/blob/master/maths/3n+1.py)
   * [abs](https://github.com/TheAlgorithms/Python/blob/master/maths/abs.py)
-  * [abs Max](https://github.com/TheAlgorithms/Python/blob/master/maths/abs_Max.py)
-  * [abs Min](https://github.com/TheAlgorithms/Python/blob/master/maths/abs_Min.py)
-  * [average](https://github.com/TheAlgorithms/Python/blob/master/maths/average.py)
+  * [abs max](https://github.com/TheAlgorithms/Python/blob/master/maths/abs_max.py)
+  * [abs min](https://github.com/TheAlgorithms/Python/blob/master/maths/abs_min.py)
+  * [average mean](https://github.com/TheAlgorithms/Python/blob/master/maths/average_mean.py)
+  * [average median](https://github.com/TheAlgorithms/Python/blob/master/maths/average_median.py)
   * [basic maths](https://github.com/TheAlgorithms/Python/blob/master/maths/basic_maths.py)
-  * [Binary Exponentiation](https://github.com/TheAlgorithms/Python/blob/master/maths/Binary_Exponentiation.py)
+  * [binary exponentiation](https://github.com/TheAlgorithms/Python/blob/master/maths/binary_exponentiation.py)
   * [extended euclidean algorithm](https://github.com/TheAlgorithms/Python/blob/master/maths/extended_euclidean_algorithm.py)
   * [factorial python](https://github.com/TheAlgorithms/Python/blob/master/maths/factorial_python.py)
   * [factorial recursive](https://github.com/TheAlgorithms/Python/blob/master/maths/factorial_recursive.py)
@@ -176,29 +194,27 @@
   * [fibonacci](https://github.com/TheAlgorithms/Python/blob/master/maths/fibonacci.py)
   * [fibonacci sequence recursion](https://github.com/TheAlgorithms/Python/blob/master/maths/fibonacci_sequence_recursion.py)
   * [find lcm](https://github.com/TheAlgorithms/Python/blob/master/maths/find_lcm.py)
-  * [Find Max](https://github.com/TheAlgorithms/Python/blob/master/maths/Find_Max.py)
-  * [Find Min](https://github.com/TheAlgorithms/Python/blob/master/maths/Find_Min.py)
+  * [find max](https://github.com/TheAlgorithms/Python/blob/master/maths/find_max.py)
+  * [find min](https://github.com/TheAlgorithms/Python/blob/master/maths/find_min.py)
   * [greater common divisor](https://github.com/TheAlgorithms/Python/blob/master/maths/greater_common_divisor.py)
-  * [Hanoi](https://github.com/TheAlgorithms/Python/blob/master/maths/Hanoi.py)
-  * [lucasSeries](https://github.com/TheAlgorithms/Python/blob/master/maths/lucasSeries.py)
+  * [lucas series](https://github.com/TheAlgorithms/Python/blob/master/maths/lucas%20series.py)
   * [modular exponential](https://github.com/TheAlgorithms/Python/blob/master/maths/modular_exponential.py)
   * [newton raphson](https://github.com/TheAlgorithms/Python/blob/master/maths/newton_raphson.py)
-  * [Prime Check](https://github.com/TheAlgorithms/Python/blob/master/maths/Prime_Check.py)
+  * [prime check](https://github.com/TheAlgorithms/Python/blob/master/maths/prime_check.py)
   * [segmented sieve](https://github.com/TheAlgorithms/Python/blob/master/maths/segmented_sieve.py)
   * [sieve of eratosthenes](https://github.com/TheAlgorithms/Python/blob/master/maths/sieve_of_eratosthenes.py)
   * [simpson rule](https://github.com/TheAlgorithms/Python/blob/master/maths/simpson_rule.py)
   * [trapezoidal rule](https://github.com/TheAlgorithms/Python/blob/master/maths/trapezoidal_rule.py)
-  * Tests
-    * [test fibonacci](https://github.com/TheAlgorithms/Python/blob/master/maths/tests/test_fibonacci.py)
+  * [volume](https://github.com/TheAlgorithms/Python/blob/master/maths/volume.py)
 ## Matrix
   * [matrix operation](https://github.com/TheAlgorithms/Python/blob/master/matrix/matrix_operation.py)
   * [searching in sorted matrix](https://github.com/TheAlgorithms/Python/blob/master/matrix/searching_in_sorted_matrix.py)
-  * [spiralPrint](https://github.com/TheAlgorithms/Python/blob/master/matrix/spiralPrint.py)
+  * [spiral print](https://github.com/TheAlgorithms/Python/blob/master/matrix/spiral_print.py)
 ## Networking Flow
   * [ford fulkerson](https://github.com/TheAlgorithms/Python/blob/master/networking_flow/ford_fulkerson.py)
   * [minimum cut](https://github.com/TheAlgorithms/Python/blob/master/networking_flow/minimum_cut.py)
 ## Neural Network
-  * [bpnn](https://github.com/TheAlgorithms/Python/blob/master/neural_network/bpnn.py)
+  * [back propagation neural network](https://github.com/TheAlgorithms/Python/blob/master/neural_network/back_propagation_neural_network.py)
   * [convolution neural network](https://github.com/TheAlgorithms/Python/blob/master/neural_network/convolution_neural_network.py)
   * [perceptron](https://github.com/TheAlgorithms/Python/blob/master/neural_network/perceptron.py)
 ## Other
@@ -208,11 +224,11 @@
   * [detecting english programmatically](https://github.com/TheAlgorithms/Python/blob/master/other/detecting_english_programmatically.py)
   * [dictionary](https://github.com/TheAlgorithms/Python/blob/master/other/dictionary.txt)
   * [euclidean gcd](https://github.com/TheAlgorithms/Python/blob/master/other/euclidean_gcd.py)
-  * [finding Primes](https://github.com/TheAlgorithms/Python/blob/master/other/finding_Primes.py)
+  * [finding primes](https://github.com/TheAlgorithms/Python/blob/master/other/finding_primes.py)
   * [fischer yates shuffle](https://github.com/TheAlgorithms/Python/blob/master/other/fischer_yates_shuffle.py)
   * [frequency finder](https://github.com/TheAlgorithms/Python/blob/master/other/frequency_finder.py)
+  * [game of life](https://github.com/TheAlgorithms/Python/blob/master/other/game_of_life.py)
   * [linear congruential generator](https://github.com/TheAlgorithms/Python/blob/master/other/linear_congruential_generator.py)
-  * [n queens](https://github.com/TheAlgorithms/Python/blob/master/other/n_queens.py)
   * [nested brackets](https://github.com/TheAlgorithms/Python/blob/master/other/nested_brackets.py)
   * [palindrome](https://github.com/TheAlgorithms/Python/blob/master/other/palindrome.py)
   * [password generator](https://github.com/TheAlgorithms/Python/blob/master/other/password_generator.py)
@@ -222,9 +238,8 @@
   * [two sum](https://github.com/TheAlgorithms/Python/blob/master/other/two_sum.py)
   * [word patterns](https://github.com/TheAlgorithms/Python/blob/master/other/word_patterns.py)
   * [words](https://github.com/TheAlgorithms/Python/blob/master/other/words)
-  * Game Of Life
-    * [game o life](https://github.com/TheAlgorithms/Python/blob/master/other/game_of_life/game_o_life.py)
-    * [sample](https://github.com/TheAlgorithms/Python/blob/master/other/game_of_life/sample.gif)
+  *   Pycache  
+    * [password generator.cpython-37](https://github.com/TheAlgorithms/Python/blob/master/other/__pycache__/password_generator.cpython-37.pyc)
 ## Project Euler
   * Problem 01
     * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_01/sol1.py)
@@ -273,7 +288,9 @@
     * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_12/sol1.py)
     * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_12/sol2.py)
   * Problem 13
+    * [num](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_13/num.txt)
     * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_13/sol1.py)
+    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_13/sol2.py)
   * Problem 14
     * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_14/sol1.py)
     * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_14/sol2.py)
@@ -281,6 +298,7 @@
     * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_15/sol1.py)
   * Problem 16
     * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_16/sol1.py)
+    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_16/sol2.py)
   * Problem 17
     * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_17/sol1.py)
   * Problem 19
@@ -319,6 +337,8 @@
     * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_53/sol1.py)
   * Problem 76
     * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_76/sol1.py)
+## Scripts
+  * [build directory md](https://github.com/TheAlgorithms/Python/blob/master/scripts/build_directory_md.py)
 ## Searches
   * [binary search](https://github.com/TheAlgorithms/Python/blob/master/searches/binary_search.py)
   * [interpolation search](https://github.com/TheAlgorithms/Python/blob/master/searches/interpolation_search.py)
@@ -329,13 +349,8 @@
   * [tabu search](https://github.com/TheAlgorithms/Python/blob/master/searches/tabu_search.py)
   * [tabu test data](https://github.com/TheAlgorithms/Python/blob/master/searches/tabu_test_data.txt)
   * [ternary search](https://github.com/TheAlgorithms/Python/blob/master/searches/ternary_search.py)
-  * [test interpolation search](https://github.com/TheAlgorithms/Python/blob/master/searches/test_interpolation_search.py)
-  * [test tabu search](https://github.com/TheAlgorithms/Python/blob/master/searches/test_tabu_search.py)
-## Simple Client
-  * [client](https://github.com/TheAlgorithms/Python/blob/master/simple_client/client.py)
-  * [server](https://github.com/TheAlgorithms/Python/blob/master/simple_client/server.py)
 ## Sorts
-  * [Bitonic Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/Bitonic_Sort.py)
+  * [bitonic sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/bitonic_sort.py)
   * [bogo sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/bogo_sort.py)
   * [bubble sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/bubble_sort.py)
   * [bucket sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/bucket_sort.py)
@@ -349,8 +364,8 @@
   * [insertion sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/insertion_sort.py)
   * [merge sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/merge_sort.py)
   * [merge sort fastest](https://github.com/TheAlgorithms/Python/blob/master/sorts/merge_sort_fastest.py)
-  * [Odd-Even transposition parallel](https://github.com/TheAlgorithms/Python/blob/master/sorts/Odd-Even_transposition_parallel.py)
-  * [Odd-Even transposition single-threaded](https://github.com/TheAlgorithms/Python/blob/master/sorts/Odd-Even_transposition_single-threaded.py)
+  * [odd even transposition parallel](https://github.com/TheAlgorithms/Python/blob/master/sorts/odd_even_transposition_parallel.py)
+  * [odd even transposition single threaded](https://github.com/TheAlgorithms/Python/blob/master/sorts/odd_even_transposition_single_threaded.py)
   * [pancake sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/pancake_sort.py)
   * [pigeon sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/pigeon_sort.py)
   * [quick sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/quick_sort.py)
@@ -360,17 +375,17 @@
   * [random pivot quick sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/random_pivot_quick_sort.py)
   * [selection sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/selection_sort.py)
   * [shell sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/shell_sort.py)
-  * [tests](https://github.com/TheAlgorithms/Python/blob/master/sorts/tests.py)
   * [tim sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/tim_sort.py)
   * [topological sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/topological_sort.py)
   * [tree sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/tree_sort.py)
   * [wiggle sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/wiggle_sort.py)
 ## Strings
+  * [boyer moore search](https://github.com/TheAlgorithms/Python/blob/master/strings/boyer_moore_search.py)
   * [knuth morris pratt](https://github.com/TheAlgorithms/Python/blob/master/strings/knuth_morris_pratt.py)
   * [levenshtein distance](https://github.com/TheAlgorithms/Python/blob/master/strings/levenshtein_distance.py)
   * [manacher](https://github.com/TheAlgorithms/Python/blob/master/strings/manacher.py)
   * [min cost string conversion](https://github.com/TheAlgorithms/Python/blob/master/strings/min_cost_string_conversion.py)
-  * [naive String Search](https://github.com/TheAlgorithms/Python/blob/master/strings/naive_String_Search.py)
+  * [naive string search](https://github.com/TheAlgorithms/Python/blob/master/strings/naive_string_search.py)
   * [rabin karp](https://github.com/TheAlgorithms/Python/blob/master/strings/rabin_karp.py)
 ## Traversals
   * [binary tree traversals](https://github.com/TheAlgorithms/Python/blob/master/traversals/binary_tree_traversals.py)
diff --git a/~script.py b/scripts/build_directory_md.py
similarity index 97%
rename from ~script.py
rename to scripts/build_directory_md.py
index 1fbb1e838c62..47192701880d 100644
--- a/~script.py
+++ b/scripts/build_directory_md.py
@@ -51,8 +51,10 @@ def _markdown(parent, ignores, ignores_ext, depth):
 ignores = [".vs",
     ".gitignore",
     ".git",
-    "~script.py",
+    "scripts",
     "__init__.py",
+    "requirements.txt",
+    ".github"
 ]
 # Files with given entensions will be ignored
 ignores_ext = [

From 0d615398830e8a6fd1c3aa4bd6896de1b8200561 Mon Sep 17 00:00:00 2001
From: Rakshit Parashar <34675136+rishu2403@users.noreply.github.com>
Date: Sat, 13 Jul 2019 12:54:38 -0700
Subject: [PATCH 114/348] Log_likelihood update  (#1008)

* Add files via upload

This is a simple exploratory notebook that heavily expolits pandas and seaborn

* Update logistic_regression.py

* Update logistic_regression.py

* Rename Food wastage analysis from 1961-2013 (FAO).ipynb to other/Food wastage analysis from 1961-2013 (FAO).ipynb

* Update logistic_regression.py

* Update logistic_regression.py

* Update logistic_regression.py

* Update logistic_regression.py

* Update logistic_regression.py

* Update logistic_regression.py

* Update logistic_regression.py
---
 machine_learning/logistic_regression.py       |   28 +-
 ...astage analysis from 1961-2013 (FAO).ipynb | 5916 +++++++++++++++++
 2 files changed, 5933 insertions(+), 11 deletions(-)
 create mode 100644 other/Food wastage analysis from 1961-2013 (FAO).ipynb

diff --git a/machine_learning/logistic_regression.py b/machine_learning/logistic_regression.py
index 71952e792e81..9a60831862da 100644
--- a/machine_learning/logistic_regression.py
+++ b/machine_learning/logistic_regression.py
@@ -31,13 +31,16 @@ def sigmoid_function(z):
 def cost_function(h, y):
     return (-y * np.log(h) - (1 - y) * np.log(1 - h)).mean()
 
+def log_likelihood(X, Y, weights):
+    scores = np.dot(X, weights)
+    return np.sum(Y*scores - np.log(1 + np.exp(scores)) )
 
 # here alpha is the learning rate, X is the feature matrix,y is the target matrix
-
 def logistic_reg(
     alpha,
     X,
     y,
+    num_steps,
     max_iterations=70000,
     ):
     converged = False
@@ -49,21 +52,24 @@ def logistic_reg(
         h = sigmoid_function(z)
         gradient = np.dot(X.T, h - y) / y.size
         theta = theta - alpha * gradient
-
         z = np.dot(X, theta)
         h = sigmoid_function(z)
         J = cost_function(h, y)
-
         iterations += 1  # update iterations
-
-        if iterations == max_iterations:
-            print ('Maximum iterations exceeded!')
-            print ('Minimal cost function J=', J)
-            converged = True
-
+        weights = np.zeros(X.shape[1])
+    for step in range(num_steps):
+        scores = np.dot(X, weights)
+        predictions = sigmoid_function(scores)
+        if step % 10000 == 0:
+            print(log_likelihood(X,y,weights))    # Print log-likelihood every so often
+    return weights
+    
+    if iterations == max_iterations:
+        print ('Maximum iterations exceeded!')
+        print ('Minimal cost function J=', J)
+        converged = True
     return theta
 
-
 # In[68]:
 
 if __name__ == '__main__':
@@ -72,7 +78,7 @@ def logistic_reg(
     y = (iris.target != 0) * 1
 
     alpha = 0.1
-    theta = logistic_reg(alpha, X, y, max_iterations=70000)
+    theta = logistic_reg(alpha,X,y,max_iterations=70000,num_steps=30000)
     print (theta)
 
 
diff --git a/other/Food wastage analysis from 1961-2013 (FAO).ipynb b/other/Food wastage analysis from 1961-2013 (FAO).ipynb
new file mode 100644
index 000000000000..384314c7e8f1
--- /dev/null
+++ b/other/Food wastage analysis from 1961-2013 (FAO).ipynb	
@@ -0,0 +1,5916 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "_cell_guid": "1eecdb4a-89ca-4a1e-9c4c-7c44b2e628a1",
+    "_uuid": "110a8132a8179a9bed2fc8f1096592dc791f1661"
+   },
+   "source": [
+    "# About the dataset\n",
+    "\n",
+    "Context\n",
+    "Our world population is expected to grow from 7.3 billion today to 9.7 billion in the year 2050. Finding solutions for feeding the growing world population has become a hot topic for food and agriculture organizations, entrepreneurs and philanthropists. These solutions range from changing the way we grow our food to changing the way we eat. To make things harder, the world's climate is changing and it is both affecting and affected by the way we grow our food – agriculture. This dataset provides an insight on our worldwide food production - focusing on a comparison between food produced for human consumption and feed produced for animals.\n",
+    "\n",
+    "Content\n",
+    "The Food and Agriculture Organization of the United Nations provides free access to food and agriculture data for over 245 countries and territories, from the year 1961 to the most recent update (depends on the dataset). One dataset from the FAO's database is the Food Balance Sheets. It presents a comprehensive picture of the pattern of a country's food supply during a specified reference period, the last time an update was loaded to the FAO database was in 2013. The food balance sheet shows for each food item the sources of supply and its utilization. This chunk of the dataset is focused on two utilizations of each food item available:\n",
+    "\n",
+    "Food - refers to the total amount of the food item available as human food during the reference period.\n",
+    "Feed - refers to the quantity of the food item available for feeding to the livestock and poultry during the reference period.\n",
+    "Dataset's attributes:\n",
+    "\n",
+    "Area code - Country name abbreviation\n",
+    "Area - County name\n",
+    "Item - Food item\n",
+    "Element - Food or Feed\n",
+    "Latitude - geographic coordinate that specifies the north–south position of a point on the Earth's surface\n",
+    "Longitude - geographic coordinate that specifies the east-west position of a point on the Earth's surface\n",
+    "Production per year - Amount of food item produced in 1000 tonnes\n",
+    "\n",
+    "This is a simple exploratory notebook that heavily expolits pandas and seaborn"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "_cell_guid": "b1076dfc-b9ad-4769-8c92-a6c4dae69d19",
+    "_uuid": "8f2839f25d086af736a60e9eeb907d3b93b6e0e5"
+   },
+   "outputs": [],
+   "source": [
+    "# Importing libraries\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import matplotlib.pyplot as plt\n",
+    "import seaborn as sns\n",
+    "%matplotlib inline\n",
+    "# importing data\n",
+    "df = pd.read_csv(\"FAO.csv\",  encoding = \"ISO-8859-1\")\n",
+    "pd.options.mode.chained_assignment = None\n",
+    "from sklearn.linear_model import LinearRegression"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Area Abbreviation</th>\n",
+       "      <th>Area Code</th>\n",
+       "      <th>Area</th>\n",
+       "      <th>Item Code</th>\n",
+       "      <th>Item</th>\n",
+       "      <th>Element Code</th>\n",
+       "      <th>Element</th>\n",
+       "      <th>Unit</th>\n",
+       "      <th>latitude</th>\n",
+       "      <th>longitude</th>\n",
+       "      <th>...</th>\n",
+       "      <th>Y2004</th>\n",
+       "      <th>Y2005</th>\n",
+       "      <th>Y2006</th>\n",
+       "      <th>Y2007</th>\n",
+       "      <th>Y2008</th>\n",
+       "      <th>Y2009</th>\n",
+       "      <th>Y2010</th>\n",
+       "      <th>Y2011</th>\n",
+       "      <th>Y2012</th>\n",
+       "      <th>Y2013</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>AFG</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Afghanistan</td>\n",
+       "      <td>2511</td>\n",
+       "      <td>Wheat and products</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>33.94</td>\n",
+       "      <td>67.71</td>\n",
+       "      <td>...</td>\n",
+       "      <td>3249.0</td>\n",
+       "      <td>3486.0</td>\n",
+       "      <td>3704.0</td>\n",
+       "      <td>4164.0</td>\n",
+       "      <td>4252.0</td>\n",
+       "      <td>4538.0</td>\n",
+       "      <td>4605.0</td>\n",
+       "      <td>4711.0</td>\n",
+       "      <td>4810</td>\n",
+       "      <td>4895</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>AFG</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Afghanistan</td>\n",
+       "      <td>2805</td>\n",
+       "      <td>Rice (Milled Equivalent)</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>33.94</td>\n",
+       "      <td>67.71</td>\n",
+       "      <td>...</td>\n",
+       "      <td>419.0</td>\n",
+       "      <td>445.0</td>\n",
+       "      <td>546.0</td>\n",
+       "      <td>455.0</td>\n",
+       "      <td>490.0</td>\n",
+       "      <td>415.0</td>\n",
+       "      <td>442.0</td>\n",
+       "      <td>476.0</td>\n",
+       "      <td>425</td>\n",
+       "      <td>422</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>AFG</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Afghanistan</td>\n",
+       "      <td>2513</td>\n",
+       "      <td>Barley and products</td>\n",
+       "      <td>5521</td>\n",
+       "      <td>Feed</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>33.94</td>\n",
+       "      <td>67.71</td>\n",
+       "      <td>...</td>\n",
+       "      <td>58.0</td>\n",
+       "      <td>236.0</td>\n",
+       "      <td>262.0</td>\n",
+       "      <td>263.0</td>\n",
+       "      <td>230.0</td>\n",
+       "      <td>379.0</td>\n",
+       "      <td>315.0</td>\n",
+       "      <td>203.0</td>\n",
+       "      <td>367</td>\n",
+       "      <td>360</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>AFG</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Afghanistan</td>\n",
+       "      <td>2513</td>\n",
+       "      <td>Barley and products</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>33.94</td>\n",
+       "      <td>67.71</td>\n",
+       "      <td>...</td>\n",
+       "      <td>185.0</td>\n",
+       "      <td>43.0</td>\n",
+       "      <td>44.0</td>\n",
+       "      <td>48.0</td>\n",
+       "      <td>62.0</td>\n",
+       "      <td>55.0</td>\n",
+       "      <td>60.0</td>\n",
+       "      <td>72.0</td>\n",
+       "      <td>78</td>\n",
+       "      <td>89</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>AFG</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Afghanistan</td>\n",
+       "      <td>2514</td>\n",
+       "      <td>Maize and products</td>\n",
+       "      <td>5521</td>\n",
+       "      <td>Feed</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>33.94</td>\n",
+       "      <td>67.71</td>\n",
+       "      <td>...</td>\n",
+       "      <td>120.0</td>\n",
+       "      <td>208.0</td>\n",
+       "      <td>233.0</td>\n",
+       "      <td>249.0</td>\n",
+       "      <td>247.0</td>\n",
+       "      <td>195.0</td>\n",
+       "      <td>178.0</td>\n",
+       "      <td>191.0</td>\n",
+       "      <td>200</td>\n",
+       "      <td>200</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>AFG</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Afghanistan</td>\n",
+       "      <td>2514</td>\n",
+       "      <td>Maize and products</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>33.94</td>\n",
+       "      <td>67.71</td>\n",
+       "      <td>...</td>\n",
+       "      <td>231.0</td>\n",
+       "      <td>67.0</td>\n",
+       "      <td>82.0</td>\n",
+       "      <td>67.0</td>\n",
+       "      <td>69.0</td>\n",
+       "      <td>71.0</td>\n",
+       "      <td>82.0</td>\n",
+       "      <td>73.0</td>\n",
+       "      <td>77</td>\n",
+       "      <td>76</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6</th>\n",
+       "      <td>AFG</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Afghanistan</td>\n",
+       "      <td>2517</td>\n",
+       "      <td>Millet and products</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>33.94</td>\n",
+       "      <td>67.71</td>\n",
+       "      <td>...</td>\n",
+       "      <td>15.0</td>\n",
+       "      <td>21.0</td>\n",
+       "      <td>11.0</td>\n",
+       "      <td>19.0</td>\n",
+       "      <td>21.0</td>\n",
+       "      <td>18.0</td>\n",
+       "      <td>14.0</td>\n",
+       "      <td>14.0</td>\n",
+       "      <td>14</td>\n",
+       "      <td>12</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>7</th>\n",
+       "      <td>AFG</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Afghanistan</td>\n",
+       "      <td>2520</td>\n",
+       "      <td>Cereals, Other</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>33.94</td>\n",
+       "      <td>67.71</td>\n",
+       "      <td>...</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8</th>\n",
+       "      <td>AFG</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Afghanistan</td>\n",
+       "      <td>2531</td>\n",
+       "      <td>Potatoes and products</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>33.94</td>\n",
+       "      <td>67.71</td>\n",
+       "      <td>...</td>\n",
+       "      <td>276.0</td>\n",
+       "      <td>294.0</td>\n",
+       "      <td>294.0</td>\n",
+       "      <td>260.0</td>\n",
+       "      <td>242.0</td>\n",
+       "      <td>250.0</td>\n",
+       "      <td>192.0</td>\n",
+       "      <td>169.0</td>\n",
+       "      <td>196</td>\n",
+       "      <td>230</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>9</th>\n",
+       "      <td>AFG</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Afghanistan</td>\n",
+       "      <td>2536</td>\n",
+       "      <td>Sugar cane</td>\n",
+       "      <td>5521</td>\n",
+       "      <td>Feed</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>33.94</td>\n",
+       "      <td>67.71</td>\n",
+       "      <td>...</td>\n",
+       "      <td>50.0</td>\n",
+       "      <td>29.0</td>\n",
+       "      <td>61.0</td>\n",
+       "      <td>65.0</td>\n",
+       "      <td>54.0</td>\n",
+       "      <td>114.0</td>\n",
+       "      <td>83.0</td>\n",
+       "      <td>83.0</td>\n",
+       "      <td>69</td>\n",
+       "      <td>81</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>10</th>\n",
+       "      <td>AFG</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Afghanistan</td>\n",
+       "      <td>2537</td>\n",
+       "      <td>Sugar beet</td>\n",
+       "      <td>5521</td>\n",
+       "      <td>Feed</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>33.94</td>\n",
+       "      <td>67.71</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>11</th>\n",
+       "      <td>AFG</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Afghanistan</td>\n",
+       "      <td>2542</td>\n",
+       "      <td>Sugar (Raw Equivalent)</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>33.94</td>\n",
+       "      <td>67.71</td>\n",
+       "      <td>...</td>\n",
+       "      <td>124.0</td>\n",
+       "      <td>152.0</td>\n",
+       "      <td>169.0</td>\n",
+       "      <td>192.0</td>\n",
+       "      <td>217.0</td>\n",
+       "      <td>231.0</td>\n",
+       "      <td>240.0</td>\n",
+       "      <td>240.0</td>\n",
+       "      <td>250</td>\n",
+       "      <td>255</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>12</th>\n",
+       "      <td>AFG</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Afghanistan</td>\n",
+       "      <td>2543</td>\n",
+       "      <td>Sweeteners, Other</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>33.94</td>\n",
+       "      <td>67.71</td>\n",
+       "      <td>...</td>\n",
+       "      <td>9.0</td>\n",
+       "      <td>15.0</td>\n",
+       "      <td>12.0</td>\n",
+       "      <td>6.0</td>\n",
+       "      <td>11.0</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>9.0</td>\n",
+       "      <td>21.0</td>\n",
+       "      <td>24</td>\n",
+       "      <td>16</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>13</th>\n",
+       "      <td>AFG</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Afghanistan</td>\n",
+       "      <td>2745</td>\n",
+       "      <td>Honey</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>33.94</td>\n",
+       "      <td>67.71</td>\n",
+       "      <td>...</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>2</td>\n",
+       "      <td>2</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>14</th>\n",
+       "      <td>AFG</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Afghanistan</td>\n",
+       "      <td>2549</td>\n",
+       "      <td>Pulses, Other and products</td>\n",
+       "      <td>5521</td>\n",
+       "      <td>Feed</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>33.94</td>\n",
+       "      <td>67.71</td>\n",
+       "      <td>...</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>5.0</td>\n",
+       "      <td>4.0</td>\n",
+       "      <td>5.0</td>\n",
+       "      <td>4</td>\n",
+       "      <td>4</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>15</th>\n",
+       "      <td>AFG</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Afghanistan</td>\n",
+       "      <td>2549</td>\n",
+       "      <td>Pulses, Other and products</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>33.94</td>\n",
+       "      <td>67.71</td>\n",
+       "      <td>...</td>\n",
+       "      <td>17.0</td>\n",
+       "      <td>35.0</td>\n",
+       "      <td>37.0</td>\n",
+       "      <td>40.0</td>\n",
+       "      <td>54.0</td>\n",
+       "      <td>80.0</td>\n",
+       "      <td>66.0</td>\n",
+       "      <td>81.0</td>\n",
+       "      <td>63</td>\n",
+       "      <td>74</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>16</th>\n",
+       "      <td>AFG</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Afghanistan</td>\n",
+       "      <td>2551</td>\n",
+       "      <td>Nuts and products</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>33.94</td>\n",
+       "      <td>67.71</td>\n",
+       "      <td>...</td>\n",
+       "      <td>11.0</td>\n",
+       "      <td>13.0</td>\n",
+       "      <td>24.0</td>\n",
+       "      <td>34.0</td>\n",
+       "      <td>42.0</td>\n",
+       "      <td>28.0</td>\n",
+       "      <td>66.0</td>\n",
+       "      <td>71.0</td>\n",
+       "      <td>70</td>\n",
+       "      <td>44</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>17</th>\n",
+       "      <td>AFG</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Afghanistan</td>\n",
+       "      <td>2560</td>\n",
+       "      <td>Coconuts - Incl Copra</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>33.94</td>\n",
+       "      <td>67.71</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>18</th>\n",
+       "      <td>AFG</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Afghanistan</td>\n",
+       "      <td>2561</td>\n",
+       "      <td>Sesame seed</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>33.94</td>\n",
+       "      <td>67.71</td>\n",
+       "      <td>...</td>\n",
+       "      <td>16.0</td>\n",
+       "      <td>16.0</td>\n",
+       "      <td>13.0</td>\n",
+       "      <td>16.0</td>\n",
+       "      <td>16.0</td>\n",
+       "      <td>16.0</td>\n",
+       "      <td>19.0</td>\n",
+       "      <td>17.0</td>\n",
+       "      <td>16</td>\n",
+       "      <td>16</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>19</th>\n",
+       "      <td>AFG</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Afghanistan</td>\n",
+       "      <td>2563</td>\n",
+       "      <td>Olives (including preserved)</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>33.94</td>\n",
+       "      <td>67.71</td>\n",
+       "      <td>...</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>2</td>\n",
+       "      <td>2</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>20</th>\n",
+       "      <td>AFG</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Afghanistan</td>\n",
+       "      <td>2571</td>\n",
+       "      <td>Soyabean Oil</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>33.94</td>\n",
+       "      <td>67.71</td>\n",
+       "      <td>...</td>\n",
+       "      <td>6.0</td>\n",
+       "      <td>35.0</td>\n",
+       "      <td>18.0</td>\n",
+       "      <td>21.0</td>\n",
+       "      <td>11.0</td>\n",
+       "      <td>6.0</td>\n",
+       "      <td>15.0</td>\n",
+       "      <td>16.0</td>\n",
+       "      <td>16</td>\n",
+       "      <td>16</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21</th>\n",
+       "      <td>AFG</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Afghanistan</td>\n",
+       "      <td>2572</td>\n",
+       "      <td>Groundnut Oil</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>33.94</td>\n",
+       "      <td>67.71</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>22</th>\n",
+       "      <td>AFG</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Afghanistan</td>\n",
+       "      <td>2573</td>\n",
+       "      <td>Sunflowerseed Oil</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>33.94</td>\n",
+       "      <td>67.71</td>\n",
+       "      <td>...</td>\n",
+       "      <td>4.0</td>\n",
+       "      <td>6.0</td>\n",
+       "      <td>5.0</td>\n",
+       "      <td>9.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>8.0</td>\n",
+       "      <td>15.0</td>\n",
+       "      <td>16.0</td>\n",
+       "      <td>17</td>\n",
+       "      <td>23</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>23</th>\n",
+       "      <td>AFG</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Afghanistan</td>\n",
+       "      <td>2574</td>\n",
+       "      <td>Rape and Mustard Oil</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>33.94</td>\n",
+       "      <td>67.71</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>5.0</td>\n",
+       "      <td>6.0</td>\n",
+       "      <td>6.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>2</td>\n",
+       "      <td>2</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>24</th>\n",
+       "      <td>AFG</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Afghanistan</td>\n",
+       "      <td>2575</td>\n",
+       "      <td>Cottonseed Oil</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>33.94</td>\n",
+       "      <td>67.71</td>\n",
+       "      <td>...</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>4.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>3</td>\n",
+       "      <td>4</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>25</th>\n",
+       "      <td>AFG</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Afghanistan</td>\n",
+       "      <td>2577</td>\n",
+       "      <td>Palm Oil</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>33.94</td>\n",
+       "      <td>67.71</td>\n",
+       "      <td>...</td>\n",
+       "      <td>71.0</td>\n",
+       "      <td>69.0</td>\n",
+       "      <td>56.0</td>\n",
+       "      <td>51.0</td>\n",
+       "      <td>36.0</td>\n",
+       "      <td>53.0</td>\n",
+       "      <td>59.0</td>\n",
+       "      <td>51.0</td>\n",
+       "      <td>61</td>\n",
+       "      <td>64</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>26</th>\n",
+       "      <td>AFG</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Afghanistan</td>\n",
+       "      <td>2579</td>\n",
+       "      <td>Sesameseed Oil</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>33.94</td>\n",
+       "      <td>67.71</td>\n",
+       "      <td>...</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>27</th>\n",
+       "      <td>AFG</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Afghanistan</td>\n",
+       "      <td>2580</td>\n",
+       "      <td>Olive Oil</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>33.94</td>\n",
+       "      <td>67.71</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>28</th>\n",
+       "      <td>AFG</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Afghanistan</td>\n",
+       "      <td>2586</td>\n",
+       "      <td>Oilcrops Oil, Other</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>33.94</td>\n",
+       "      <td>67.71</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>2</td>\n",
+       "      <td>2</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>29</th>\n",
+       "      <td>AFG</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Afghanistan</td>\n",
+       "      <td>2601</td>\n",
+       "      <td>Tomatoes and products</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>33.94</td>\n",
+       "      <td>67.71</td>\n",
+       "      <td>...</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>8.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>...</th>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21447</th>\n",
+       "      <td>ZWE</td>\n",
+       "      <td>181</td>\n",
+       "      <td>Zimbabwe</td>\n",
+       "      <td>2765</td>\n",
+       "      <td>Crustaceans</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>-19.02</td>\n",
+       "      <td>29.15</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21448</th>\n",
+       "      <td>ZWE</td>\n",
+       "      <td>181</td>\n",
+       "      <td>Zimbabwe</td>\n",
+       "      <td>2766</td>\n",
+       "      <td>Cephalopods</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>-19.02</td>\n",
+       "      <td>29.15</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21449</th>\n",
+       "      <td>ZWE</td>\n",
+       "      <td>181</td>\n",
+       "      <td>Zimbabwe</td>\n",
+       "      <td>2767</td>\n",
+       "      <td>Molluscs, Other</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>-19.02</td>\n",
+       "      <td>29.15</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21450</th>\n",
+       "      <td>ZWE</td>\n",
+       "      <td>181</td>\n",
+       "      <td>Zimbabwe</td>\n",
+       "      <td>2775</td>\n",
+       "      <td>Aquatic Plants</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>-19.02</td>\n",
+       "      <td>29.15</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21451</th>\n",
+       "      <td>ZWE</td>\n",
+       "      <td>181</td>\n",
+       "      <td>Zimbabwe</td>\n",
+       "      <td>2680</td>\n",
+       "      <td>Infant food</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>-19.02</td>\n",
+       "      <td>29.15</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21452</th>\n",
+       "      <td>ZWE</td>\n",
+       "      <td>181</td>\n",
+       "      <td>Zimbabwe</td>\n",
+       "      <td>2905</td>\n",
+       "      <td>Cereals - Excluding Beer</td>\n",
+       "      <td>5521</td>\n",
+       "      <td>Feed</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>-19.02</td>\n",
+       "      <td>29.15</td>\n",
+       "      <td>...</td>\n",
+       "      <td>75.0</td>\n",
+       "      <td>54.0</td>\n",
+       "      <td>75.0</td>\n",
+       "      <td>55.0</td>\n",
+       "      <td>63.0</td>\n",
+       "      <td>62.0</td>\n",
+       "      <td>55.0</td>\n",
+       "      <td>55.0</td>\n",
+       "      <td>55</td>\n",
+       "      <td>55</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21453</th>\n",
+       "      <td>ZWE</td>\n",
+       "      <td>181</td>\n",
+       "      <td>Zimbabwe</td>\n",
+       "      <td>2905</td>\n",
+       "      <td>Cereals - Excluding Beer</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>-19.02</td>\n",
+       "      <td>29.15</td>\n",
+       "      <td>...</td>\n",
+       "      <td>1844.0</td>\n",
+       "      <td>1842.0</td>\n",
+       "      <td>1944.0</td>\n",
+       "      <td>1962.0</td>\n",
+       "      <td>1918.0</td>\n",
+       "      <td>1980.0</td>\n",
+       "      <td>2011.0</td>\n",
+       "      <td>2094.0</td>\n",
+       "      <td>2071</td>\n",
+       "      <td>2016</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21454</th>\n",
+       "      <td>ZWE</td>\n",
+       "      <td>181</td>\n",
+       "      <td>Zimbabwe</td>\n",
+       "      <td>2907</td>\n",
+       "      <td>Starchy Roots</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>-19.02</td>\n",
+       "      <td>29.15</td>\n",
+       "      <td>...</td>\n",
+       "      <td>223.0</td>\n",
+       "      <td>236.0</td>\n",
+       "      <td>238.0</td>\n",
+       "      <td>228.0</td>\n",
+       "      <td>245.0</td>\n",
+       "      <td>258.0</td>\n",
+       "      <td>258.0</td>\n",
+       "      <td>269.0</td>\n",
+       "      <td>272</td>\n",
+       "      <td>276</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21455</th>\n",
+       "      <td>ZWE</td>\n",
+       "      <td>181</td>\n",
+       "      <td>Zimbabwe</td>\n",
+       "      <td>2908</td>\n",
+       "      <td>Sugar Crops</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>-19.02</td>\n",
+       "      <td>29.15</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21456</th>\n",
+       "      <td>ZWE</td>\n",
+       "      <td>181</td>\n",
+       "      <td>Zimbabwe</td>\n",
+       "      <td>2909</td>\n",
+       "      <td>Sugar &amp; Sweeteners</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>-19.02</td>\n",
+       "      <td>29.15</td>\n",
+       "      <td>...</td>\n",
+       "      <td>335.0</td>\n",
+       "      <td>313.0</td>\n",
+       "      <td>339.0</td>\n",
+       "      <td>302.0</td>\n",
+       "      <td>285.0</td>\n",
+       "      <td>287.0</td>\n",
+       "      <td>314.0</td>\n",
+       "      <td>336.0</td>\n",
+       "      <td>396</td>\n",
+       "      <td>416</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21457</th>\n",
+       "      <td>ZWE</td>\n",
+       "      <td>181</td>\n",
+       "      <td>Zimbabwe</td>\n",
+       "      <td>2911</td>\n",
+       "      <td>Pulses</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>-19.02</td>\n",
+       "      <td>29.15</td>\n",
+       "      <td>...</td>\n",
+       "      <td>63.0</td>\n",
+       "      <td>59.0</td>\n",
+       "      <td>61.0</td>\n",
+       "      <td>57.0</td>\n",
+       "      <td>69.0</td>\n",
+       "      <td>78.0</td>\n",
+       "      <td>68.0</td>\n",
+       "      <td>56.0</td>\n",
+       "      <td>52</td>\n",
+       "      <td>55</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21458</th>\n",
+       "      <td>ZWE</td>\n",
+       "      <td>181</td>\n",
+       "      <td>Zimbabwe</td>\n",
+       "      <td>2912</td>\n",
+       "      <td>Treenuts</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>-19.02</td>\n",
+       "      <td>29.15</td>\n",
+       "      <td>...</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>4.0</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>4</td>\n",
+       "      <td>3</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21459</th>\n",
+       "      <td>ZWE</td>\n",
+       "      <td>181</td>\n",
+       "      <td>Zimbabwe</td>\n",
+       "      <td>2913</td>\n",
+       "      <td>Oilcrops</td>\n",
+       "      <td>5521</td>\n",
+       "      <td>Feed</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>-19.02</td>\n",
+       "      <td>29.15</td>\n",
+       "      <td>...</td>\n",
+       "      <td>36.0</td>\n",
+       "      <td>46.0</td>\n",
+       "      <td>41.0</td>\n",
+       "      <td>33.0</td>\n",
+       "      <td>31.0</td>\n",
+       "      <td>19.0</td>\n",
+       "      <td>24.0</td>\n",
+       "      <td>17.0</td>\n",
+       "      <td>27</td>\n",
+       "      <td>30</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21460</th>\n",
+       "      <td>ZWE</td>\n",
+       "      <td>181</td>\n",
+       "      <td>Zimbabwe</td>\n",
+       "      <td>2913</td>\n",
+       "      <td>Oilcrops</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>-19.02</td>\n",
+       "      <td>29.15</td>\n",
+       "      <td>...</td>\n",
+       "      <td>60.0</td>\n",
+       "      <td>59.0</td>\n",
+       "      <td>61.0</td>\n",
+       "      <td>62.0</td>\n",
+       "      <td>48.0</td>\n",
+       "      <td>44.0</td>\n",
+       "      <td>41.0</td>\n",
+       "      <td>40.0</td>\n",
+       "      <td>38</td>\n",
+       "      <td>38</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21461</th>\n",
+       "      <td>ZWE</td>\n",
+       "      <td>181</td>\n",
+       "      <td>Zimbabwe</td>\n",
+       "      <td>2914</td>\n",
+       "      <td>Vegetable Oils</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>-19.02</td>\n",
+       "      <td>29.15</td>\n",
+       "      <td>...</td>\n",
+       "      <td>111.0</td>\n",
+       "      <td>114.0</td>\n",
+       "      <td>112.0</td>\n",
+       "      <td>114.0</td>\n",
+       "      <td>134.0</td>\n",
+       "      <td>135.0</td>\n",
+       "      <td>137.0</td>\n",
+       "      <td>147.0</td>\n",
+       "      <td>159</td>\n",
+       "      <td>160</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21462</th>\n",
+       "      <td>ZWE</td>\n",
+       "      <td>181</td>\n",
+       "      <td>Zimbabwe</td>\n",
+       "      <td>2918</td>\n",
+       "      <td>Vegetables</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>-19.02</td>\n",
+       "      <td>29.15</td>\n",
+       "      <td>...</td>\n",
+       "      <td>161.0</td>\n",
+       "      <td>166.0</td>\n",
+       "      <td>208.0</td>\n",
+       "      <td>185.0</td>\n",
+       "      <td>137.0</td>\n",
+       "      <td>179.0</td>\n",
+       "      <td>215.0</td>\n",
+       "      <td>217.0</td>\n",
+       "      <td>227</td>\n",
+       "      <td>227</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21463</th>\n",
+       "      <td>ZWE</td>\n",
+       "      <td>181</td>\n",
+       "      <td>Zimbabwe</td>\n",
+       "      <td>2919</td>\n",
+       "      <td>Fruits - Excluding Wine</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>-19.02</td>\n",
+       "      <td>29.15</td>\n",
+       "      <td>...</td>\n",
+       "      <td>191.0</td>\n",
+       "      <td>134.0</td>\n",
+       "      <td>167.0</td>\n",
+       "      <td>177.0</td>\n",
+       "      <td>185.0</td>\n",
+       "      <td>184.0</td>\n",
+       "      <td>211.0</td>\n",
+       "      <td>230.0</td>\n",
+       "      <td>246</td>\n",
+       "      <td>217</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21464</th>\n",
+       "      <td>ZWE</td>\n",
+       "      <td>181</td>\n",
+       "      <td>Zimbabwe</td>\n",
+       "      <td>2922</td>\n",
+       "      <td>Stimulants</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>-19.02</td>\n",
+       "      <td>29.15</td>\n",
+       "      <td>...</td>\n",
+       "      <td>7.0</td>\n",
+       "      <td>21.0</td>\n",
+       "      <td>14.0</td>\n",
+       "      <td>24.0</td>\n",
+       "      <td>16.0</td>\n",
+       "      <td>11.0</td>\n",
+       "      <td>23.0</td>\n",
+       "      <td>11.0</td>\n",
+       "      <td>10</td>\n",
+       "      <td>10</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21465</th>\n",
+       "      <td>ZWE</td>\n",
+       "      <td>181</td>\n",
+       "      <td>Zimbabwe</td>\n",
+       "      <td>2923</td>\n",
+       "      <td>Spices</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>-19.02</td>\n",
+       "      <td>29.15</td>\n",
+       "      <td>...</td>\n",
+       "      <td>7.0</td>\n",
+       "      <td>11.0</td>\n",
+       "      <td>7.0</td>\n",
+       "      <td>12.0</td>\n",
+       "      <td>16.0</td>\n",
+       "      <td>16.0</td>\n",
+       "      <td>14.0</td>\n",
+       "      <td>11.0</td>\n",
+       "      <td>12</td>\n",
+       "      <td>12</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21466</th>\n",
+       "      <td>ZWE</td>\n",
+       "      <td>181</td>\n",
+       "      <td>Zimbabwe</td>\n",
+       "      <td>2924</td>\n",
+       "      <td>Alcoholic Beverages</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>-19.02</td>\n",
+       "      <td>29.15</td>\n",
+       "      <td>...</td>\n",
+       "      <td>294.0</td>\n",
+       "      <td>290.0</td>\n",
+       "      <td>316.0</td>\n",
+       "      <td>355.0</td>\n",
+       "      <td>398.0</td>\n",
+       "      <td>437.0</td>\n",
+       "      <td>448.0</td>\n",
+       "      <td>476.0</td>\n",
+       "      <td>525</td>\n",
+       "      <td>516</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21467</th>\n",
+       "      <td>ZWE</td>\n",
+       "      <td>181</td>\n",
+       "      <td>Zimbabwe</td>\n",
+       "      <td>2943</td>\n",
+       "      <td>Meat</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>-19.02</td>\n",
+       "      <td>29.15</td>\n",
+       "      <td>...</td>\n",
+       "      <td>222.0</td>\n",
+       "      <td>228.0</td>\n",
+       "      <td>233.0</td>\n",
+       "      <td>238.0</td>\n",
+       "      <td>242.0</td>\n",
+       "      <td>265.0</td>\n",
+       "      <td>262.0</td>\n",
+       "      <td>277.0</td>\n",
+       "      <td>280</td>\n",
+       "      <td>258</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21468</th>\n",
+       "      <td>ZWE</td>\n",
+       "      <td>181</td>\n",
+       "      <td>Zimbabwe</td>\n",
+       "      <td>2945</td>\n",
+       "      <td>Offals</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>-19.02</td>\n",
+       "      <td>29.15</td>\n",
+       "      <td>...</td>\n",
+       "      <td>20.0</td>\n",
+       "      <td>20.0</td>\n",
+       "      <td>21.0</td>\n",
+       "      <td>21.0</td>\n",
+       "      <td>21.0</td>\n",
+       "      <td>21.0</td>\n",
+       "      <td>21.0</td>\n",
+       "      <td>21.0</td>\n",
+       "      <td>22</td>\n",
+       "      <td>22</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21469</th>\n",
+       "      <td>ZWE</td>\n",
+       "      <td>181</td>\n",
+       "      <td>Zimbabwe</td>\n",
+       "      <td>2946</td>\n",
+       "      <td>Animal fats</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>-19.02</td>\n",
+       "      <td>29.15</td>\n",
+       "      <td>...</td>\n",
+       "      <td>26.0</td>\n",
+       "      <td>26.0</td>\n",
+       "      <td>29.0</td>\n",
+       "      <td>29.0</td>\n",
+       "      <td>27.0</td>\n",
+       "      <td>31.0</td>\n",
+       "      <td>30.0</td>\n",
+       "      <td>25.0</td>\n",
+       "      <td>26</td>\n",
+       "      <td>20</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21470</th>\n",
+       "      <td>ZWE</td>\n",
+       "      <td>181</td>\n",
+       "      <td>Zimbabwe</td>\n",
+       "      <td>2949</td>\n",
+       "      <td>Eggs</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>-19.02</td>\n",
+       "      <td>29.15</td>\n",
+       "      <td>...</td>\n",
+       "      <td>15.0</td>\n",
+       "      <td>18.0</td>\n",
+       "      <td>18.0</td>\n",
+       "      <td>21.0</td>\n",
+       "      <td>22.0</td>\n",
+       "      <td>27.0</td>\n",
+       "      <td>27.0</td>\n",
+       "      <td>24.0</td>\n",
+       "      <td>24</td>\n",
+       "      <td>25</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21471</th>\n",
+       "      <td>ZWE</td>\n",
+       "      <td>181</td>\n",
+       "      <td>Zimbabwe</td>\n",
+       "      <td>2948</td>\n",
+       "      <td>Milk - Excluding Butter</td>\n",
+       "      <td>5521</td>\n",
+       "      <td>Feed</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>-19.02</td>\n",
+       "      <td>29.15</td>\n",
+       "      <td>...</td>\n",
+       "      <td>21.0</td>\n",
+       "      <td>21.0</td>\n",
+       "      <td>21.0</td>\n",
+       "      <td>21.0</td>\n",
+       "      <td>21.0</td>\n",
+       "      <td>23.0</td>\n",
+       "      <td>25.0</td>\n",
+       "      <td>25.0</td>\n",
+       "      <td>30</td>\n",
+       "      <td>31</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21472</th>\n",
+       "      <td>ZWE</td>\n",
+       "      <td>181</td>\n",
+       "      <td>Zimbabwe</td>\n",
+       "      <td>2948</td>\n",
+       "      <td>Milk - Excluding Butter</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>-19.02</td>\n",
+       "      <td>29.15</td>\n",
+       "      <td>...</td>\n",
+       "      <td>373.0</td>\n",
+       "      <td>357.0</td>\n",
+       "      <td>359.0</td>\n",
+       "      <td>356.0</td>\n",
+       "      <td>341.0</td>\n",
+       "      <td>385.0</td>\n",
+       "      <td>418.0</td>\n",
+       "      <td>457.0</td>\n",
+       "      <td>426</td>\n",
+       "      <td>451</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21473</th>\n",
+       "      <td>ZWE</td>\n",
+       "      <td>181</td>\n",
+       "      <td>Zimbabwe</td>\n",
+       "      <td>2960</td>\n",
+       "      <td>Fish, Seafood</td>\n",
+       "      <td>5521</td>\n",
+       "      <td>Feed</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>-19.02</td>\n",
+       "      <td>29.15</td>\n",
+       "      <td>...</td>\n",
+       "      <td>5.0</td>\n",
+       "      <td>4.0</td>\n",
+       "      <td>9.0</td>\n",
+       "      <td>6.0</td>\n",
+       "      <td>9.0</td>\n",
+       "      <td>5.0</td>\n",
+       "      <td>15.0</td>\n",
+       "      <td>15.0</td>\n",
+       "      <td>15</td>\n",
+       "      <td>15</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21474</th>\n",
+       "      <td>ZWE</td>\n",
+       "      <td>181</td>\n",
+       "      <td>Zimbabwe</td>\n",
+       "      <td>2960</td>\n",
+       "      <td>Fish, Seafood</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>-19.02</td>\n",
+       "      <td>29.15</td>\n",
+       "      <td>...</td>\n",
+       "      <td>18.0</td>\n",
+       "      <td>14.0</td>\n",
+       "      <td>17.0</td>\n",
+       "      <td>14.0</td>\n",
+       "      <td>15.0</td>\n",
+       "      <td>18.0</td>\n",
+       "      <td>29.0</td>\n",
+       "      <td>40.0</td>\n",
+       "      <td>40</td>\n",
+       "      <td>40</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21475</th>\n",
+       "      <td>ZWE</td>\n",
+       "      <td>181</td>\n",
+       "      <td>Zimbabwe</td>\n",
+       "      <td>2961</td>\n",
+       "      <td>Aquatic Products, Other</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>-19.02</td>\n",
+       "      <td>29.15</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21476</th>\n",
+       "      <td>ZWE</td>\n",
+       "      <td>181</td>\n",
+       "      <td>Zimbabwe</td>\n",
+       "      <td>2928</td>\n",
+       "      <td>Miscellaneous</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>-19.02</td>\n",
+       "      <td>29.15</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>21477 rows × 63 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "      Area Abbreviation  Area Code         Area  Item Code  \\\n",
+       "0                   AFG          2  Afghanistan       2511   \n",
+       "1                   AFG          2  Afghanistan       2805   \n",
+       "2                   AFG          2  Afghanistan       2513   \n",
+       "3                   AFG          2  Afghanistan       2513   \n",
+       "4                   AFG          2  Afghanistan       2514   \n",
+       "5                   AFG          2  Afghanistan       2514   \n",
+       "6                   AFG          2  Afghanistan       2517   \n",
+       "7                   AFG          2  Afghanistan       2520   \n",
+       "8                   AFG          2  Afghanistan       2531   \n",
+       "9                   AFG          2  Afghanistan       2536   \n",
+       "10                  AFG          2  Afghanistan       2537   \n",
+       "11                  AFG          2  Afghanistan       2542   \n",
+       "12                  AFG          2  Afghanistan       2543   \n",
+       "13                  AFG          2  Afghanistan       2745   \n",
+       "14                  AFG          2  Afghanistan       2549   \n",
+       "15                  AFG          2  Afghanistan       2549   \n",
+       "16                  AFG          2  Afghanistan       2551   \n",
+       "17                  AFG          2  Afghanistan       2560   \n",
+       "18                  AFG          2  Afghanistan       2561   \n",
+       "19                  AFG          2  Afghanistan       2563   \n",
+       "20                  AFG          2  Afghanistan       2571   \n",
+       "21                  AFG          2  Afghanistan       2572   \n",
+       "22                  AFG          2  Afghanistan       2573   \n",
+       "23                  AFG          2  Afghanistan       2574   \n",
+       "24                  AFG          2  Afghanistan       2575   \n",
+       "25                  AFG          2  Afghanistan       2577   \n",
+       "26                  AFG          2  Afghanistan       2579   \n",
+       "27                  AFG          2  Afghanistan       2580   \n",
+       "28                  AFG          2  Afghanistan       2586   \n",
+       "29                  AFG          2  Afghanistan       2601   \n",
+       "...                 ...        ...          ...        ...   \n",
+       "21447               ZWE        181     Zimbabwe       2765   \n",
+       "21448               ZWE        181     Zimbabwe       2766   \n",
+       "21449               ZWE        181     Zimbabwe       2767   \n",
+       "21450               ZWE        181     Zimbabwe       2775   \n",
+       "21451               ZWE        181     Zimbabwe       2680   \n",
+       "21452               ZWE        181     Zimbabwe       2905   \n",
+       "21453               ZWE        181     Zimbabwe       2905   \n",
+       "21454               ZWE        181     Zimbabwe       2907   \n",
+       "21455               ZWE        181     Zimbabwe       2908   \n",
+       "21456               ZWE        181     Zimbabwe       2909   \n",
+       "21457               ZWE        181     Zimbabwe       2911   \n",
+       "21458               ZWE        181     Zimbabwe       2912   \n",
+       "21459               ZWE        181     Zimbabwe       2913   \n",
+       "21460               ZWE        181     Zimbabwe       2913   \n",
+       "21461               ZWE        181     Zimbabwe       2914   \n",
+       "21462               ZWE        181     Zimbabwe       2918   \n",
+       "21463               ZWE        181     Zimbabwe       2919   \n",
+       "21464               ZWE        181     Zimbabwe       2922   \n",
+       "21465               ZWE        181     Zimbabwe       2923   \n",
+       "21466               ZWE        181     Zimbabwe       2924   \n",
+       "21467               ZWE        181     Zimbabwe       2943   \n",
+       "21468               ZWE        181     Zimbabwe       2945   \n",
+       "21469               ZWE        181     Zimbabwe       2946   \n",
+       "21470               ZWE        181     Zimbabwe       2949   \n",
+       "21471               ZWE        181     Zimbabwe       2948   \n",
+       "21472               ZWE        181     Zimbabwe       2948   \n",
+       "21473               ZWE        181     Zimbabwe       2960   \n",
+       "21474               ZWE        181     Zimbabwe       2960   \n",
+       "21475               ZWE        181     Zimbabwe       2961   \n",
+       "21476               ZWE        181     Zimbabwe       2928   \n",
+       "\n",
+       "                               Item  Element Code Element         Unit  \\\n",
+       "0                Wheat and products          5142    Food  1000 tonnes   \n",
+       "1          Rice (Milled Equivalent)          5142    Food  1000 tonnes   \n",
+       "2               Barley and products          5521    Feed  1000 tonnes   \n",
+       "3               Barley and products          5142    Food  1000 tonnes   \n",
+       "4                Maize and products          5521    Feed  1000 tonnes   \n",
+       "5                Maize and products          5142    Food  1000 tonnes   \n",
+       "6               Millet and products          5142    Food  1000 tonnes   \n",
+       "7                    Cereals, Other          5142    Food  1000 tonnes   \n",
+       "8             Potatoes and products          5142    Food  1000 tonnes   \n",
+       "9                        Sugar cane          5521    Feed  1000 tonnes   \n",
+       "10                       Sugar beet          5521    Feed  1000 tonnes   \n",
+       "11           Sugar (Raw Equivalent)          5142    Food  1000 tonnes   \n",
+       "12                Sweeteners, Other          5142    Food  1000 tonnes   \n",
+       "13                            Honey          5142    Food  1000 tonnes   \n",
+       "14       Pulses, Other and products          5521    Feed  1000 tonnes   \n",
+       "15       Pulses, Other and products          5142    Food  1000 tonnes   \n",
+       "16                Nuts and products          5142    Food  1000 tonnes   \n",
+       "17            Coconuts - Incl Copra          5142    Food  1000 tonnes   \n",
+       "18                      Sesame seed          5142    Food  1000 tonnes   \n",
+       "19     Olives (including preserved)          5142    Food  1000 tonnes   \n",
+       "20                     Soyabean Oil          5142    Food  1000 tonnes   \n",
+       "21                    Groundnut Oil          5142    Food  1000 tonnes   \n",
+       "22                Sunflowerseed Oil          5142    Food  1000 tonnes   \n",
+       "23             Rape and Mustard Oil          5142    Food  1000 tonnes   \n",
+       "24                   Cottonseed Oil          5142    Food  1000 tonnes   \n",
+       "25                         Palm Oil          5142    Food  1000 tonnes   \n",
+       "26                   Sesameseed Oil          5142    Food  1000 tonnes   \n",
+       "27                        Olive Oil          5142    Food  1000 tonnes   \n",
+       "28              Oilcrops Oil, Other          5142    Food  1000 tonnes   \n",
+       "29            Tomatoes and products          5142    Food  1000 tonnes   \n",
+       "...                             ...           ...     ...          ...   \n",
+       "21447                   Crustaceans          5142    Food  1000 tonnes   \n",
+       "21448                   Cephalopods          5142    Food  1000 tonnes   \n",
+       "21449               Molluscs, Other          5142    Food  1000 tonnes   \n",
+       "21450                Aquatic Plants          5142    Food  1000 tonnes   \n",
+       "21451                   Infant food          5142    Food  1000 tonnes   \n",
+       "21452      Cereals - Excluding Beer          5521    Feed  1000 tonnes   \n",
+       "21453      Cereals - Excluding Beer          5142    Food  1000 tonnes   \n",
+       "21454                 Starchy Roots          5142    Food  1000 tonnes   \n",
+       "21455                   Sugar Crops          5142    Food  1000 tonnes   \n",
+       "21456            Sugar & Sweeteners          5142    Food  1000 tonnes   \n",
+       "21457                        Pulses          5142    Food  1000 tonnes   \n",
+       "21458                      Treenuts          5142    Food  1000 tonnes   \n",
+       "21459                      Oilcrops          5521    Feed  1000 tonnes   \n",
+       "21460                      Oilcrops          5142    Food  1000 tonnes   \n",
+       "21461                Vegetable Oils          5142    Food  1000 tonnes   \n",
+       "21462                    Vegetables          5142    Food  1000 tonnes   \n",
+       "21463       Fruits - Excluding Wine          5142    Food  1000 tonnes   \n",
+       "21464                    Stimulants          5142    Food  1000 tonnes   \n",
+       "21465                        Spices          5142    Food  1000 tonnes   \n",
+       "21466           Alcoholic Beverages          5142    Food  1000 tonnes   \n",
+       "21467                          Meat          5142    Food  1000 tonnes   \n",
+       "21468                        Offals          5142    Food  1000 tonnes   \n",
+       "21469                   Animal fats          5142    Food  1000 tonnes   \n",
+       "21470                          Eggs          5142    Food  1000 tonnes   \n",
+       "21471       Milk - Excluding Butter          5521    Feed  1000 tonnes   \n",
+       "21472       Milk - Excluding Butter          5142    Food  1000 tonnes   \n",
+       "21473                 Fish, Seafood          5521    Feed  1000 tonnes   \n",
+       "21474                 Fish, Seafood          5142    Food  1000 tonnes   \n",
+       "21475       Aquatic Products, Other          5142    Food  1000 tonnes   \n",
+       "21476                 Miscellaneous          5142    Food  1000 tonnes   \n",
+       "\n",
+       "       latitude  longitude  ...     Y2004   Y2005   Y2006   Y2007   Y2008  \\\n",
+       "0         33.94      67.71  ...    3249.0  3486.0  3704.0  4164.0  4252.0   \n",
+       "1         33.94      67.71  ...     419.0   445.0   546.0   455.0   490.0   \n",
+       "2         33.94      67.71  ...      58.0   236.0   262.0   263.0   230.0   \n",
+       "3         33.94      67.71  ...     185.0    43.0    44.0    48.0    62.0   \n",
+       "4         33.94      67.71  ...     120.0   208.0   233.0   249.0   247.0   \n",
+       "5         33.94      67.71  ...     231.0    67.0    82.0    67.0    69.0   \n",
+       "6         33.94      67.71  ...      15.0    21.0    11.0    19.0    21.0   \n",
+       "7         33.94      67.71  ...       2.0     1.0     1.0     0.0     0.0   \n",
+       "8         33.94      67.71  ...     276.0   294.0   294.0   260.0   242.0   \n",
+       "9         33.94      67.71  ...      50.0    29.0    61.0    65.0    54.0   \n",
+       "10        33.94      67.71  ...       0.0     0.0     0.0     0.0     0.0   \n",
+       "11        33.94      67.71  ...     124.0   152.0   169.0   192.0   217.0   \n",
+       "12        33.94      67.71  ...       9.0    15.0    12.0     6.0    11.0   \n",
+       "13        33.94      67.71  ...       3.0     3.0     3.0     3.0     3.0   \n",
+       "14        33.94      67.71  ...       3.0     2.0     3.0     3.0     3.0   \n",
+       "15        33.94      67.71  ...      17.0    35.0    37.0    40.0    54.0   \n",
+       "16        33.94      67.71  ...      11.0    13.0    24.0    34.0    42.0   \n",
+       "17        33.94      67.71  ...       0.0     0.0     0.0     0.0     0.0   \n",
+       "18        33.94      67.71  ...      16.0    16.0    13.0    16.0    16.0   \n",
+       "19        33.94      67.71  ...       1.0     1.0     0.0     0.0     2.0   \n",
+       "20        33.94      67.71  ...       6.0    35.0    18.0    21.0    11.0   \n",
+       "21        33.94      67.71  ...       0.0     0.0     0.0     0.0     0.0   \n",
+       "22        33.94      67.71  ...       4.0     6.0     5.0     9.0     3.0   \n",
+       "23        33.94      67.71  ...       0.0     1.0     3.0     5.0     6.0   \n",
+       "24        33.94      67.71  ...       2.0     3.0     3.0     3.0     3.0   \n",
+       "25        33.94      67.71  ...      71.0    69.0    56.0    51.0    36.0   \n",
+       "26        33.94      67.71  ...       1.0     1.0     1.0     2.0     2.0   \n",
+       "27        33.94      67.71  ...       0.0     0.0     0.0     0.0     0.0   \n",
+       "28        33.94      67.71  ...       0.0     1.0     0.0     0.0     3.0   \n",
+       "29        33.94      67.71  ...       2.0     2.0     8.0     1.0     0.0   \n",
+       "...         ...        ...  ...       ...     ...     ...     ...     ...   \n",
+       "21447    -19.02      29.15  ...       0.0     0.0     0.0     0.0     0.0   \n",
+       "21448    -19.02      29.15  ...       0.0     0.0     0.0     0.0     0.0   \n",
+       "21449    -19.02      29.15  ...       0.0     0.0     0.0     0.0     0.0   \n",
+       "21450    -19.02      29.15  ...       0.0     0.0     0.0     0.0     0.0   \n",
+       "21451    -19.02      29.15  ...       0.0     0.0     0.0     0.0     0.0   \n",
+       "21452    -19.02      29.15  ...      75.0    54.0    75.0    55.0    63.0   \n",
+       "21453    -19.02      29.15  ...    1844.0  1842.0  1944.0  1962.0  1918.0   \n",
+       "21454    -19.02      29.15  ...     223.0   236.0   238.0   228.0   245.0   \n",
+       "21455    -19.02      29.15  ...       0.0     0.0     0.0     0.0     0.0   \n",
+       "21456    -19.02      29.15  ...     335.0   313.0   339.0   302.0   285.0   \n",
+       "21457    -19.02      29.15  ...      63.0    59.0    61.0    57.0    69.0   \n",
+       "21458    -19.02      29.15  ...       1.0     2.0     1.0     2.0     2.0   \n",
+       "21459    -19.02      29.15  ...      36.0    46.0    41.0    33.0    31.0   \n",
+       "21460    -19.02      29.15  ...      60.0    59.0    61.0    62.0    48.0   \n",
+       "21461    -19.02      29.15  ...     111.0   114.0   112.0   114.0   134.0   \n",
+       "21462    -19.02      29.15  ...     161.0   166.0   208.0   185.0   137.0   \n",
+       "21463    -19.02      29.15  ...     191.0   134.0   167.0   177.0   185.0   \n",
+       "21464    -19.02      29.15  ...       7.0    21.0    14.0    24.0    16.0   \n",
+       "21465    -19.02      29.15  ...       7.0    11.0     7.0    12.0    16.0   \n",
+       "21466    -19.02      29.15  ...     294.0   290.0   316.0   355.0   398.0   \n",
+       "21467    -19.02      29.15  ...     222.0   228.0   233.0   238.0   242.0   \n",
+       "21468    -19.02      29.15  ...      20.0    20.0    21.0    21.0    21.0   \n",
+       "21469    -19.02      29.15  ...      26.0    26.0    29.0    29.0    27.0   \n",
+       "21470    -19.02      29.15  ...      15.0    18.0    18.0    21.0    22.0   \n",
+       "21471    -19.02      29.15  ...      21.0    21.0    21.0    21.0    21.0   \n",
+       "21472    -19.02      29.15  ...     373.0   357.0   359.0   356.0   341.0   \n",
+       "21473    -19.02      29.15  ...       5.0     4.0     9.0     6.0     9.0   \n",
+       "21474    -19.02      29.15  ...      18.0    14.0    17.0    14.0    15.0   \n",
+       "21475    -19.02      29.15  ...       0.0     0.0     0.0     0.0     0.0   \n",
+       "21476    -19.02      29.15  ...       0.0     0.0     0.0     0.0     0.0   \n",
+       "\n",
+       "        Y2009   Y2010   Y2011  Y2012  Y2013  \n",
+       "0      4538.0  4605.0  4711.0   4810   4895  \n",
+       "1       415.0   442.0   476.0    425    422  \n",
+       "2       379.0   315.0   203.0    367    360  \n",
+       "3        55.0    60.0    72.0     78     89  \n",
+       "4       195.0   178.0   191.0    200    200  \n",
+       "5        71.0    82.0    73.0     77     76  \n",
+       "6        18.0    14.0    14.0     14     12  \n",
+       "7         0.0     0.0     0.0      0      0  \n",
+       "8       250.0   192.0   169.0    196    230  \n",
+       "9       114.0    83.0    83.0     69     81  \n",
+       "10        0.0     0.0     0.0      0      0  \n",
+       "11      231.0   240.0   240.0    250    255  \n",
+       "12        2.0     9.0    21.0     24     16  \n",
+       "13        3.0     3.0     2.0      2      2  \n",
+       "14        5.0     4.0     5.0      4      4  \n",
+       "15       80.0    66.0    81.0     63     74  \n",
+       "16       28.0    66.0    71.0     70     44  \n",
+       "17        0.0     0.0     0.0      0      0  \n",
+       "18       16.0    19.0    17.0     16     16  \n",
+       "19        3.0     2.0     2.0      2      2  \n",
+       "20        6.0    15.0    16.0     16     16  \n",
+       "21        0.0     0.0     0.0      0      0  \n",
+       "22        8.0    15.0    16.0     17     23  \n",
+       "23        6.0     1.0     2.0      2      2  \n",
+       "24        4.0     3.0     3.0      3      4  \n",
+       "25       53.0    59.0    51.0     61     64  \n",
+       "26        1.0     1.0     2.0      1      1  \n",
+       "27        1.0     1.0     1.0      1      1  \n",
+       "28        1.0     2.0     2.0      2      2  \n",
+       "29        0.0     0.0     0.0      0      0  \n",
+       "...       ...     ...     ...    ...    ...  \n",
+       "21447     0.0     0.0     0.0      0      0  \n",
+       "21448     0.0     0.0     0.0      0      0  \n",
+       "21449     0.0     1.0     0.0      0      0  \n",
+       "21450     0.0     0.0     0.0      0      0  \n",
+       "21451     0.0     0.0     0.0      0      0  \n",
+       "21452    62.0    55.0    55.0     55     55  \n",
+       "21453  1980.0  2011.0  2094.0   2071   2016  \n",
+       "21454   258.0   258.0   269.0    272    276  \n",
+       "21455     0.0     0.0     0.0      0      0  \n",
+       "21456   287.0   314.0   336.0    396    416  \n",
+       "21457    78.0    68.0    56.0     52     55  \n",
+       "21458     3.0     4.0     2.0      4      3  \n",
+       "21459    19.0    24.0    17.0     27     30  \n",
+       "21460    44.0    41.0    40.0     38     38  \n",
+       "21461   135.0   137.0   147.0    159    160  \n",
+       "21462   179.0   215.0   217.0    227    227  \n",
+       "21463   184.0   211.0   230.0    246    217  \n",
+       "21464    11.0    23.0    11.0     10     10  \n",
+       "21465    16.0    14.0    11.0     12     12  \n",
+       "21466   437.0   448.0   476.0    525    516  \n",
+       "21467   265.0   262.0   277.0    280    258  \n",
+       "21468    21.0    21.0    21.0     22     22  \n",
+       "21469    31.0    30.0    25.0     26     20  \n",
+       "21470    27.0    27.0    24.0     24     25  \n",
+       "21471    23.0    25.0    25.0     30     31  \n",
+       "21472   385.0   418.0   457.0    426    451  \n",
+       "21473     5.0    15.0    15.0     15     15  \n",
+       "21474    18.0    29.0    40.0     40     40  \n",
+       "21475     0.0     0.0     0.0      0      0  \n",
+       "21476     0.0     0.0     0.0      0      0  \n",
+       "\n",
+       "[21477 rows x 63 columns]"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "_cell_guid": "731a952c-b292-46e3-be7a-4afffe2b4ff1",
+    "_uuid": "5d165c279ce22afc0a874e32931d7b0ebb0717f9"
+   },
+   "source": [
+    "Let's see what the data looks like..."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "_cell_guid": "79c7e3d0-c299-4dcb-8224-4455121ee9b0",
+    "_uuid": "d629ff2d2480ee46fbb7e2d37f6b5fab8052498a",
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "_cell_guid": "25c3f986-fd14-4a3f-baff-02571ad665eb",
+    "_uuid": "5a7da58320ab35ab1bcf83a62209afbe40b672fe"
+   },
+   "source": [
+    "# Plot for annual produce of different countries with quantity in y-axis and years in x-axis"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Area Abbreviation</th>\n",
+       "      <th>Area Code</th>\n",
+       "      <th>Area</th>\n",
+       "      <th>Item Code</th>\n",
+       "      <th>Item</th>\n",
+       "      <th>Element Code</th>\n",
+       "      <th>Element</th>\n",
+       "      <th>Unit</th>\n",
+       "      <th>latitude</th>\n",
+       "      <th>longitude</th>\n",
+       "      <th>...</th>\n",
+       "      <th>Y2004</th>\n",
+       "      <th>Y2005</th>\n",
+       "      <th>Y2006</th>\n",
+       "      <th>Y2007</th>\n",
+       "      <th>Y2008</th>\n",
+       "      <th>Y2009</th>\n",
+       "      <th>Y2010</th>\n",
+       "      <th>Y2011</th>\n",
+       "      <th>Y2012</th>\n",
+       "      <th>Y2013</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>AFG</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Afghanistan</td>\n",
+       "      <td>2511</td>\n",
+       "      <td>Wheat and products</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>33.94</td>\n",
+       "      <td>67.71</td>\n",
+       "      <td>...</td>\n",
+       "      <td>3249.0</td>\n",
+       "      <td>3486.0</td>\n",
+       "      <td>3704.0</td>\n",
+       "      <td>4164.0</td>\n",
+       "      <td>4252.0</td>\n",
+       "      <td>4538.0</td>\n",
+       "      <td>4605.0</td>\n",
+       "      <td>4711.0</td>\n",
+       "      <td>4810</td>\n",
+       "      <td>4895</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>AFG</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Afghanistan</td>\n",
+       "      <td>2805</td>\n",
+       "      <td>Rice (Milled Equivalent)</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>33.94</td>\n",
+       "      <td>67.71</td>\n",
+       "      <td>...</td>\n",
+       "      <td>419.0</td>\n",
+       "      <td>445.0</td>\n",
+       "      <td>546.0</td>\n",
+       "      <td>455.0</td>\n",
+       "      <td>490.0</td>\n",
+       "      <td>415.0</td>\n",
+       "      <td>442.0</td>\n",
+       "      <td>476.0</td>\n",
+       "      <td>425</td>\n",
+       "      <td>422</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>AFG</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Afghanistan</td>\n",
+       "      <td>2513</td>\n",
+       "      <td>Barley and products</td>\n",
+       "      <td>5521</td>\n",
+       "      <td>Feed</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>33.94</td>\n",
+       "      <td>67.71</td>\n",
+       "      <td>...</td>\n",
+       "      <td>58.0</td>\n",
+       "      <td>236.0</td>\n",
+       "      <td>262.0</td>\n",
+       "      <td>263.0</td>\n",
+       "      <td>230.0</td>\n",
+       "      <td>379.0</td>\n",
+       "      <td>315.0</td>\n",
+       "      <td>203.0</td>\n",
+       "      <td>367</td>\n",
+       "      <td>360</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>AFG</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Afghanistan</td>\n",
+       "      <td>2513</td>\n",
+       "      <td>Barley and products</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>33.94</td>\n",
+       "      <td>67.71</td>\n",
+       "      <td>...</td>\n",
+       "      <td>185.0</td>\n",
+       "      <td>43.0</td>\n",
+       "      <td>44.0</td>\n",
+       "      <td>48.0</td>\n",
+       "      <td>62.0</td>\n",
+       "      <td>55.0</td>\n",
+       "      <td>60.0</td>\n",
+       "      <td>72.0</td>\n",
+       "      <td>78</td>\n",
+       "      <td>89</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>AFG</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Afghanistan</td>\n",
+       "      <td>2514</td>\n",
+       "      <td>Maize and products</td>\n",
+       "      <td>5521</td>\n",
+       "      <td>Feed</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>33.94</td>\n",
+       "      <td>67.71</td>\n",
+       "      <td>...</td>\n",
+       "      <td>120.0</td>\n",
+       "      <td>208.0</td>\n",
+       "      <td>233.0</td>\n",
+       "      <td>249.0</td>\n",
+       "      <td>247.0</td>\n",
+       "      <td>195.0</td>\n",
+       "      <td>178.0</td>\n",
+       "      <td>191.0</td>\n",
+       "      <td>200</td>\n",
+       "      <td>200</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>AFG</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Afghanistan</td>\n",
+       "      <td>2514</td>\n",
+       "      <td>Maize and products</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>33.94</td>\n",
+       "      <td>67.71</td>\n",
+       "      <td>...</td>\n",
+       "      <td>231.0</td>\n",
+       "      <td>67.0</td>\n",
+       "      <td>82.0</td>\n",
+       "      <td>67.0</td>\n",
+       "      <td>69.0</td>\n",
+       "      <td>71.0</td>\n",
+       "      <td>82.0</td>\n",
+       "      <td>73.0</td>\n",
+       "      <td>77</td>\n",
+       "      <td>76</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6</th>\n",
+       "      <td>AFG</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Afghanistan</td>\n",
+       "      <td>2517</td>\n",
+       "      <td>Millet and products</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>33.94</td>\n",
+       "      <td>67.71</td>\n",
+       "      <td>...</td>\n",
+       "      <td>15.0</td>\n",
+       "      <td>21.0</td>\n",
+       "      <td>11.0</td>\n",
+       "      <td>19.0</td>\n",
+       "      <td>21.0</td>\n",
+       "      <td>18.0</td>\n",
+       "      <td>14.0</td>\n",
+       "      <td>14.0</td>\n",
+       "      <td>14</td>\n",
+       "      <td>12</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>7</th>\n",
+       "      <td>AFG</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Afghanistan</td>\n",
+       "      <td>2520</td>\n",
+       "      <td>Cereals, Other</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>33.94</td>\n",
+       "      <td>67.71</td>\n",
+       "      <td>...</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8</th>\n",
+       "      <td>AFG</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Afghanistan</td>\n",
+       "      <td>2531</td>\n",
+       "      <td>Potatoes and products</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>33.94</td>\n",
+       "      <td>67.71</td>\n",
+       "      <td>...</td>\n",
+       "      <td>276.0</td>\n",
+       "      <td>294.0</td>\n",
+       "      <td>294.0</td>\n",
+       "      <td>260.0</td>\n",
+       "      <td>242.0</td>\n",
+       "      <td>250.0</td>\n",
+       "      <td>192.0</td>\n",
+       "      <td>169.0</td>\n",
+       "      <td>196</td>\n",
+       "      <td>230</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>9</th>\n",
+       "      <td>AFG</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Afghanistan</td>\n",
+       "      <td>2536</td>\n",
+       "      <td>Sugar cane</td>\n",
+       "      <td>5521</td>\n",
+       "      <td>Feed</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>33.94</td>\n",
+       "      <td>67.71</td>\n",
+       "      <td>...</td>\n",
+       "      <td>50.0</td>\n",
+       "      <td>29.0</td>\n",
+       "      <td>61.0</td>\n",
+       "      <td>65.0</td>\n",
+       "      <td>54.0</td>\n",
+       "      <td>114.0</td>\n",
+       "      <td>83.0</td>\n",
+       "      <td>83.0</td>\n",
+       "      <td>69</td>\n",
+       "      <td>81</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>10</th>\n",
+       "      <td>AFG</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Afghanistan</td>\n",
+       "      <td>2537</td>\n",
+       "      <td>Sugar beet</td>\n",
+       "      <td>5521</td>\n",
+       "      <td>Feed</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>33.94</td>\n",
+       "      <td>67.71</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>11</th>\n",
+       "      <td>AFG</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Afghanistan</td>\n",
+       "      <td>2542</td>\n",
+       "      <td>Sugar (Raw Equivalent)</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>33.94</td>\n",
+       "      <td>67.71</td>\n",
+       "      <td>...</td>\n",
+       "      <td>124.0</td>\n",
+       "      <td>152.0</td>\n",
+       "      <td>169.0</td>\n",
+       "      <td>192.0</td>\n",
+       "      <td>217.0</td>\n",
+       "      <td>231.0</td>\n",
+       "      <td>240.0</td>\n",
+       "      <td>240.0</td>\n",
+       "      <td>250</td>\n",
+       "      <td>255</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>12</th>\n",
+       "      <td>AFG</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Afghanistan</td>\n",
+       "      <td>2543</td>\n",
+       "      <td>Sweeteners, Other</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>33.94</td>\n",
+       "      <td>67.71</td>\n",
+       "      <td>...</td>\n",
+       "      <td>9.0</td>\n",
+       "      <td>15.0</td>\n",
+       "      <td>12.0</td>\n",
+       "      <td>6.0</td>\n",
+       "      <td>11.0</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>9.0</td>\n",
+       "      <td>21.0</td>\n",
+       "      <td>24</td>\n",
+       "      <td>16</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>13</th>\n",
+       "      <td>AFG</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Afghanistan</td>\n",
+       "      <td>2745</td>\n",
+       "      <td>Honey</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>33.94</td>\n",
+       "      <td>67.71</td>\n",
+       "      <td>...</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>2</td>\n",
+       "      <td>2</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>14</th>\n",
+       "      <td>AFG</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Afghanistan</td>\n",
+       "      <td>2549</td>\n",
+       "      <td>Pulses, Other and products</td>\n",
+       "      <td>5521</td>\n",
+       "      <td>Feed</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>33.94</td>\n",
+       "      <td>67.71</td>\n",
+       "      <td>...</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>5.0</td>\n",
+       "      <td>4.0</td>\n",
+       "      <td>5.0</td>\n",
+       "      <td>4</td>\n",
+       "      <td>4</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>15</th>\n",
+       "      <td>AFG</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Afghanistan</td>\n",
+       "      <td>2549</td>\n",
+       "      <td>Pulses, Other and products</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>33.94</td>\n",
+       "      <td>67.71</td>\n",
+       "      <td>...</td>\n",
+       "      <td>17.0</td>\n",
+       "      <td>35.0</td>\n",
+       "      <td>37.0</td>\n",
+       "      <td>40.0</td>\n",
+       "      <td>54.0</td>\n",
+       "      <td>80.0</td>\n",
+       "      <td>66.0</td>\n",
+       "      <td>81.0</td>\n",
+       "      <td>63</td>\n",
+       "      <td>74</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>16</th>\n",
+       "      <td>AFG</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Afghanistan</td>\n",
+       "      <td>2551</td>\n",
+       "      <td>Nuts and products</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>33.94</td>\n",
+       "      <td>67.71</td>\n",
+       "      <td>...</td>\n",
+       "      <td>11.0</td>\n",
+       "      <td>13.0</td>\n",
+       "      <td>24.0</td>\n",
+       "      <td>34.0</td>\n",
+       "      <td>42.0</td>\n",
+       "      <td>28.0</td>\n",
+       "      <td>66.0</td>\n",
+       "      <td>71.0</td>\n",
+       "      <td>70</td>\n",
+       "      <td>44</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>17</th>\n",
+       "      <td>AFG</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Afghanistan</td>\n",
+       "      <td>2560</td>\n",
+       "      <td>Coconuts - Incl Copra</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>33.94</td>\n",
+       "      <td>67.71</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>18</th>\n",
+       "      <td>AFG</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Afghanistan</td>\n",
+       "      <td>2561</td>\n",
+       "      <td>Sesame seed</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>33.94</td>\n",
+       "      <td>67.71</td>\n",
+       "      <td>...</td>\n",
+       "      <td>16.0</td>\n",
+       "      <td>16.0</td>\n",
+       "      <td>13.0</td>\n",
+       "      <td>16.0</td>\n",
+       "      <td>16.0</td>\n",
+       "      <td>16.0</td>\n",
+       "      <td>19.0</td>\n",
+       "      <td>17.0</td>\n",
+       "      <td>16</td>\n",
+       "      <td>16</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>19</th>\n",
+       "      <td>AFG</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Afghanistan</td>\n",
+       "      <td>2563</td>\n",
+       "      <td>Olives (including preserved)</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>33.94</td>\n",
+       "      <td>67.71</td>\n",
+       "      <td>...</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>2</td>\n",
+       "      <td>2</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>20</th>\n",
+       "      <td>AFG</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Afghanistan</td>\n",
+       "      <td>2571</td>\n",
+       "      <td>Soyabean Oil</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>33.94</td>\n",
+       "      <td>67.71</td>\n",
+       "      <td>...</td>\n",
+       "      <td>6.0</td>\n",
+       "      <td>35.0</td>\n",
+       "      <td>18.0</td>\n",
+       "      <td>21.0</td>\n",
+       "      <td>11.0</td>\n",
+       "      <td>6.0</td>\n",
+       "      <td>15.0</td>\n",
+       "      <td>16.0</td>\n",
+       "      <td>16</td>\n",
+       "      <td>16</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21</th>\n",
+       "      <td>AFG</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Afghanistan</td>\n",
+       "      <td>2572</td>\n",
+       "      <td>Groundnut Oil</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>33.94</td>\n",
+       "      <td>67.71</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>22</th>\n",
+       "      <td>AFG</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Afghanistan</td>\n",
+       "      <td>2573</td>\n",
+       "      <td>Sunflowerseed Oil</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>33.94</td>\n",
+       "      <td>67.71</td>\n",
+       "      <td>...</td>\n",
+       "      <td>4.0</td>\n",
+       "      <td>6.0</td>\n",
+       "      <td>5.0</td>\n",
+       "      <td>9.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>8.0</td>\n",
+       "      <td>15.0</td>\n",
+       "      <td>16.0</td>\n",
+       "      <td>17</td>\n",
+       "      <td>23</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>23</th>\n",
+       "      <td>AFG</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Afghanistan</td>\n",
+       "      <td>2574</td>\n",
+       "      <td>Rape and Mustard Oil</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>33.94</td>\n",
+       "      <td>67.71</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>5.0</td>\n",
+       "      <td>6.0</td>\n",
+       "      <td>6.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>2</td>\n",
+       "      <td>2</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>24</th>\n",
+       "      <td>AFG</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Afghanistan</td>\n",
+       "      <td>2575</td>\n",
+       "      <td>Cottonseed Oil</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>33.94</td>\n",
+       "      <td>67.71</td>\n",
+       "      <td>...</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>4.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>3</td>\n",
+       "      <td>4</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>25</th>\n",
+       "      <td>AFG</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Afghanistan</td>\n",
+       "      <td>2577</td>\n",
+       "      <td>Palm Oil</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>33.94</td>\n",
+       "      <td>67.71</td>\n",
+       "      <td>...</td>\n",
+       "      <td>71.0</td>\n",
+       "      <td>69.0</td>\n",
+       "      <td>56.0</td>\n",
+       "      <td>51.0</td>\n",
+       "      <td>36.0</td>\n",
+       "      <td>53.0</td>\n",
+       "      <td>59.0</td>\n",
+       "      <td>51.0</td>\n",
+       "      <td>61</td>\n",
+       "      <td>64</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>26</th>\n",
+       "      <td>AFG</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Afghanistan</td>\n",
+       "      <td>2579</td>\n",
+       "      <td>Sesameseed Oil</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>33.94</td>\n",
+       "      <td>67.71</td>\n",
+       "      <td>...</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>27</th>\n",
+       "      <td>AFG</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Afghanistan</td>\n",
+       "      <td>2580</td>\n",
+       "      <td>Olive Oil</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>33.94</td>\n",
+       "      <td>67.71</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>28</th>\n",
+       "      <td>AFG</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Afghanistan</td>\n",
+       "      <td>2586</td>\n",
+       "      <td>Oilcrops Oil, Other</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>33.94</td>\n",
+       "      <td>67.71</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>2</td>\n",
+       "      <td>2</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>29</th>\n",
+       "      <td>AFG</td>\n",
+       "      <td>2</td>\n",
+       "      <td>Afghanistan</td>\n",
+       "      <td>2601</td>\n",
+       "      <td>Tomatoes and products</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>33.94</td>\n",
+       "      <td>67.71</td>\n",
+       "      <td>...</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>8.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>...</th>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21447</th>\n",
+       "      <td>ZWE</td>\n",
+       "      <td>181</td>\n",
+       "      <td>Zimbabwe</td>\n",
+       "      <td>2765</td>\n",
+       "      <td>Crustaceans</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>-19.02</td>\n",
+       "      <td>29.15</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21448</th>\n",
+       "      <td>ZWE</td>\n",
+       "      <td>181</td>\n",
+       "      <td>Zimbabwe</td>\n",
+       "      <td>2766</td>\n",
+       "      <td>Cephalopods</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>-19.02</td>\n",
+       "      <td>29.15</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21449</th>\n",
+       "      <td>ZWE</td>\n",
+       "      <td>181</td>\n",
+       "      <td>Zimbabwe</td>\n",
+       "      <td>2767</td>\n",
+       "      <td>Molluscs, Other</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>-19.02</td>\n",
+       "      <td>29.15</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21450</th>\n",
+       "      <td>ZWE</td>\n",
+       "      <td>181</td>\n",
+       "      <td>Zimbabwe</td>\n",
+       "      <td>2775</td>\n",
+       "      <td>Aquatic Plants</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>-19.02</td>\n",
+       "      <td>29.15</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21451</th>\n",
+       "      <td>ZWE</td>\n",
+       "      <td>181</td>\n",
+       "      <td>Zimbabwe</td>\n",
+       "      <td>2680</td>\n",
+       "      <td>Infant food</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>-19.02</td>\n",
+       "      <td>29.15</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21452</th>\n",
+       "      <td>ZWE</td>\n",
+       "      <td>181</td>\n",
+       "      <td>Zimbabwe</td>\n",
+       "      <td>2905</td>\n",
+       "      <td>Cereals - Excluding Beer</td>\n",
+       "      <td>5521</td>\n",
+       "      <td>Feed</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>-19.02</td>\n",
+       "      <td>29.15</td>\n",
+       "      <td>...</td>\n",
+       "      <td>75.0</td>\n",
+       "      <td>54.0</td>\n",
+       "      <td>75.0</td>\n",
+       "      <td>55.0</td>\n",
+       "      <td>63.0</td>\n",
+       "      <td>62.0</td>\n",
+       "      <td>55.0</td>\n",
+       "      <td>55.0</td>\n",
+       "      <td>55</td>\n",
+       "      <td>55</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21453</th>\n",
+       "      <td>ZWE</td>\n",
+       "      <td>181</td>\n",
+       "      <td>Zimbabwe</td>\n",
+       "      <td>2905</td>\n",
+       "      <td>Cereals - Excluding Beer</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>-19.02</td>\n",
+       "      <td>29.15</td>\n",
+       "      <td>...</td>\n",
+       "      <td>1844.0</td>\n",
+       "      <td>1842.0</td>\n",
+       "      <td>1944.0</td>\n",
+       "      <td>1962.0</td>\n",
+       "      <td>1918.0</td>\n",
+       "      <td>1980.0</td>\n",
+       "      <td>2011.0</td>\n",
+       "      <td>2094.0</td>\n",
+       "      <td>2071</td>\n",
+       "      <td>2016</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21454</th>\n",
+       "      <td>ZWE</td>\n",
+       "      <td>181</td>\n",
+       "      <td>Zimbabwe</td>\n",
+       "      <td>2907</td>\n",
+       "      <td>Starchy Roots</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>-19.02</td>\n",
+       "      <td>29.15</td>\n",
+       "      <td>...</td>\n",
+       "      <td>223.0</td>\n",
+       "      <td>236.0</td>\n",
+       "      <td>238.0</td>\n",
+       "      <td>228.0</td>\n",
+       "      <td>245.0</td>\n",
+       "      <td>258.0</td>\n",
+       "      <td>258.0</td>\n",
+       "      <td>269.0</td>\n",
+       "      <td>272</td>\n",
+       "      <td>276</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21455</th>\n",
+       "      <td>ZWE</td>\n",
+       "      <td>181</td>\n",
+       "      <td>Zimbabwe</td>\n",
+       "      <td>2908</td>\n",
+       "      <td>Sugar Crops</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>-19.02</td>\n",
+       "      <td>29.15</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21456</th>\n",
+       "      <td>ZWE</td>\n",
+       "      <td>181</td>\n",
+       "      <td>Zimbabwe</td>\n",
+       "      <td>2909</td>\n",
+       "      <td>Sugar &amp; Sweeteners</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>-19.02</td>\n",
+       "      <td>29.15</td>\n",
+       "      <td>...</td>\n",
+       "      <td>335.0</td>\n",
+       "      <td>313.0</td>\n",
+       "      <td>339.0</td>\n",
+       "      <td>302.0</td>\n",
+       "      <td>285.0</td>\n",
+       "      <td>287.0</td>\n",
+       "      <td>314.0</td>\n",
+       "      <td>336.0</td>\n",
+       "      <td>396</td>\n",
+       "      <td>416</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21457</th>\n",
+       "      <td>ZWE</td>\n",
+       "      <td>181</td>\n",
+       "      <td>Zimbabwe</td>\n",
+       "      <td>2911</td>\n",
+       "      <td>Pulses</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>-19.02</td>\n",
+       "      <td>29.15</td>\n",
+       "      <td>...</td>\n",
+       "      <td>63.0</td>\n",
+       "      <td>59.0</td>\n",
+       "      <td>61.0</td>\n",
+       "      <td>57.0</td>\n",
+       "      <td>69.0</td>\n",
+       "      <td>78.0</td>\n",
+       "      <td>68.0</td>\n",
+       "      <td>56.0</td>\n",
+       "      <td>52</td>\n",
+       "      <td>55</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21458</th>\n",
+       "      <td>ZWE</td>\n",
+       "      <td>181</td>\n",
+       "      <td>Zimbabwe</td>\n",
+       "      <td>2912</td>\n",
+       "      <td>Treenuts</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>-19.02</td>\n",
+       "      <td>29.15</td>\n",
+       "      <td>...</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>4.0</td>\n",
+       "      <td>2.0</td>\n",
+       "      <td>4</td>\n",
+       "      <td>3</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21459</th>\n",
+       "      <td>ZWE</td>\n",
+       "      <td>181</td>\n",
+       "      <td>Zimbabwe</td>\n",
+       "      <td>2913</td>\n",
+       "      <td>Oilcrops</td>\n",
+       "      <td>5521</td>\n",
+       "      <td>Feed</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>-19.02</td>\n",
+       "      <td>29.15</td>\n",
+       "      <td>...</td>\n",
+       "      <td>36.0</td>\n",
+       "      <td>46.0</td>\n",
+       "      <td>41.0</td>\n",
+       "      <td>33.0</td>\n",
+       "      <td>31.0</td>\n",
+       "      <td>19.0</td>\n",
+       "      <td>24.0</td>\n",
+       "      <td>17.0</td>\n",
+       "      <td>27</td>\n",
+       "      <td>30</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21460</th>\n",
+       "      <td>ZWE</td>\n",
+       "      <td>181</td>\n",
+       "      <td>Zimbabwe</td>\n",
+       "      <td>2913</td>\n",
+       "      <td>Oilcrops</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>-19.02</td>\n",
+       "      <td>29.15</td>\n",
+       "      <td>...</td>\n",
+       "      <td>60.0</td>\n",
+       "      <td>59.0</td>\n",
+       "      <td>61.0</td>\n",
+       "      <td>62.0</td>\n",
+       "      <td>48.0</td>\n",
+       "      <td>44.0</td>\n",
+       "      <td>41.0</td>\n",
+       "      <td>40.0</td>\n",
+       "      <td>38</td>\n",
+       "      <td>38</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21461</th>\n",
+       "      <td>ZWE</td>\n",
+       "      <td>181</td>\n",
+       "      <td>Zimbabwe</td>\n",
+       "      <td>2914</td>\n",
+       "      <td>Vegetable Oils</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>-19.02</td>\n",
+       "      <td>29.15</td>\n",
+       "      <td>...</td>\n",
+       "      <td>111.0</td>\n",
+       "      <td>114.0</td>\n",
+       "      <td>112.0</td>\n",
+       "      <td>114.0</td>\n",
+       "      <td>134.0</td>\n",
+       "      <td>135.0</td>\n",
+       "      <td>137.0</td>\n",
+       "      <td>147.0</td>\n",
+       "      <td>159</td>\n",
+       "      <td>160</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21462</th>\n",
+       "      <td>ZWE</td>\n",
+       "      <td>181</td>\n",
+       "      <td>Zimbabwe</td>\n",
+       "      <td>2918</td>\n",
+       "      <td>Vegetables</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>-19.02</td>\n",
+       "      <td>29.15</td>\n",
+       "      <td>...</td>\n",
+       "      <td>161.0</td>\n",
+       "      <td>166.0</td>\n",
+       "      <td>208.0</td>\n",
+       "      <td>185.0</td>\n",
+       "      <td>137.0</td>\n",
+       "      <td>179.0</td>\n",
+       "      <td>215.0</td>\n",
+       "      <td>217.0</td>\n",
+       "      <td>227</td>\n",
+       "      <td>227</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21463</th>\n",
+       "      <td>ZWE</td>\n",
+       "      <td>181</td>\n",
+       "      <td>Zimbabwe</td>\n",
+       "      <td>2919</td>\n",
+       "      <td>Fruits - Excluding Wine</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>-19.02</td>\n",
+       "      <td>29.15</td>\n",
+       "      <td>...</td>\n",
+       "      <td>191.0</td>\n",
+       "      <td>134.0</td>\n",
+       "      <td>167.0</td>\n",
+       "      <td>177.0</td>\n",
+       "      <td>185.0</td>\n",
+       "      <td>184.0</td>\n",
+       "      <td>211.0</td>\n",
+       "      <td>230.0</td>\n",
+       "      <td>246</td>\n",
+       "      <td>217</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21464</th>\n",
+       "      <td>ZWE</td>\n",
+       "      <td>181</td>\n",
+       "      <td>Zimbabwe</td>\n",
+       "      <td>2922</td>\n",
+       "      <td>Stimulants</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>-19.02</td>\n",
+       "      <td>29.15</td>\n",
+       "      <td>...</td>\n",
+       "      <td>7.0</td>\n",
+       "      <td>21.0</td>\n",
+       "      <td>14.0</td>\n",
+       "      <td>24.0</td>\n",
+       "      <td>16.0</td>\n",
+       "      <td>11.0</td>\n",
+       "      <td>23.0</td>\n",
+       "      <td>11.0</td>\n",
+       "      <td>10</td>\n",
+       "      <td>10</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21465</th>\n",
+       "      <td>ZWE</td>\n",
+       "      <td>181</td>\n",
+       "      <td>Zimbabwe</td>\n",
+       "      <td>2923</td>\n",
+       "      <td>Spices</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>-19.02</td>\n",
+       "      <td>29.15</td>\n",
+       "      <td>...</td>\n",
+       "      <td>7.0</td>\n",
+       "      <td>11.0</td>\n",
+       "      <td>7.0</td>\n",
+       "      <td>12.0</td>\n",
+       "      <td>16.0</td>\n",
+       "      <td>16.0</td>\n",
+       "      <td>14.0</td>\n",
+       "      <td>11.0</td>\n",
+       "      <td>12</td>\n",
+       "      <td>12</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21466</th>\n",
+       "      <td>ZWE</td>\n",
+       "      <td>181</td>\n",
+       "      <td>Zimbabwe</td>\n",
+       "      <td>2924</td>\n",
+       "      <td>Alcoholic Beverages</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>-19.02</td>\n",
+       "      <td>29.15</td>\n",
+       "      <td>...</td>\n",
+       "      <td>294.0</td>\n",
+       "      <td>290.0</td>\n",
+       "      <td>316.0</td>\n",
+       "      <td>355.0</td>\n",
+       "      <td>398.0</td>\n",
+       "      <td>437.0</td>\n",
+       "      <td>448.0</td>\n",
+       "      <td>476.0</td>\n",
+       "      <td>525</td>\n",
+       "      <td>516</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21467</th>\n",
+       "      <td>ZWE</td>\n",
+       "      <td>181</td>\n",
+       "      <td>Zimbabwe</td>\n",
+       "      <td>2943</td>\n",
+       "      <td>Meat</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>-19.02</td>\n",
+       "      <td>29.15</td>\n",
+       "      <td>...</td>\n",
+       "      <td>222.0</td>\n",
+       "      <td>228.0</td>\n",
+       "      <td>233.0</td>\n",
+       "      <td>238.0</td>\n",
+       "      <td>242.0</td>\n",
+       "      <td>265.0</td>\n",
+       "      <td>262.0</td>\n",
+       "      <td>277.0</td>\n",
+       "      <td>280</td>\n",
+       "      <td>258</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21468</th>\n",
+       "      <td>ZWE</td>\n",
+       "      <td>181</td>\n",
+       "      <td>Zimbabwe</td>\n",
+       "      <td>2945</td>\n",
+       "      <td>Offals</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>-19.02</td>\n",
+       "      <td>29.15</td>\n",
+       "      <td>...</td>\n",
+       "      <td>20.0</td>\n",
+       "      <td>20.0</td>\n",
+       "      <td>21.0</td>\n",
+       "      <td>21.0</td>\n",
+       "      <td>21.0</td>\n",
+       "      <td>21.0</td>\n",
+       "      <td>21.0</td>\n",
+       "      <td>21.0</td>\n",
+       "      <td>22</td>\n",
+       "      <td>22</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21469</th>\n",
+       "      <td>ZWE</td>\n",
+       "      <td>181</td>\n",
+       "      <td>Zimbabwe</td>\n",
+       "      <td>2946</td>\n",
+       "      <td>Animal fats</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>-19.02</td>\n",
+       "      <td>29.15</td>\n",
+       "      <td>...</td>\n",
+       "      <td>26.0</td>\n",
+       "      <td>26.0</td>\n",
+       "      <td>29.0</td>\n",
+       "      <td>29.0</td>\n",
+       "      <td>27.0</td>\n",
+       "      <td>31.0</td>\n",
+       "      <td>30.0</td>\n",
+       "      <td>25.0</td>\n",
+       "      <td>26</td>\n",
+       "      <td>20</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21470</th>\n",
+       "      <td>ZWE</td>\n",
+       "      <td>181</td>\n",
+       "      <td>Zimbabwe</td>\n",
+       "      <td>2949</td>\n",
+       "      <td>Eggs</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>-19.02</td>\n",
+       "      <td>29.15</td>\n",
+       "      <td>...</td>\n",
+       "      <td>15.0</td>\n",
+       "      <td>18.0</td>\n",
+       "      <td>18.0</td>\n",
+       "      <td>21.0</td>\n",
+       "      <td>22.0</td>\n",
+       "      <td>27.0</td>\n",
+       "      <td>27.0</td>\n",
+       "      <td>24.0</td>\n",
+       "      <td>24</td>\n",
+       "      <td>25</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21471</th>\n",
+       "      <td>ZWE</td>\n",
+       "      <td>181</td>\n",
+       "      <td>Zimbabwe</td>\n",
+       "      <td>2948</td>\n",
+       "      <td>Milk - Excluding Butter</td>\n",
+       "      <td>5521</td>\n",
+       "      <td>Feed</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>-19.02</td>\n",
+       "      <td>29.15</td>\n",
+       "      <td>...</td>\n",
+       "      <td>21.0</td>\n",
+       "      <td>21.0</td>\n",
+       "      <td>21.0</td>\n",
+       "      <td>21.0</td>\n",
+       "      <td>21.0</td>\n",
+       "      <td>23.0</td>\n",
+       "      <td>25.0</td>\n",
+       "      <td>25.0</td>\n",
+       "      <td>30</td>\n",
+       "      <td>31</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21472</th>\n",
+       "      <td>ZWE</td>\n",
+       "      <td>181</td>\n",
+       "      <td>Zimbabwe</td>\n",
+       "      <td>2948</td>\n",
+       "      <td>Milk - Excluding Butter</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>-19.02</td>\n",
+       "      <td>29.15</td>\n",
+       "      <td>...</td>\n",
+       "      <td>373.0</td>\n",
+       "      <td>357.0</td>\n",
+       "      <td>359.0</td>\n",
+       "      <td>356.0</td>\n",
+       "      <td>341.0</td>\n",
+       "      <td>385.0</td>\n",
+       "      <td>418.0</td>\n",
+       "      <td>457.0</td>\n",
+       "      <td>426</td>\n",
+       "      <td>451</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21473</th>\n",
+       "      <td>ZWE</td>\n",
+       "      <td>181</td>\n",
+       "      <td>Zimbabwe</td>\n",
+       "      <td>2960</td>\n",
+       "      <td>Fish, Seafood</td>\n",
+       "      <td>5521</td>\n",
+       "      <td>Feed</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>-19.02</td>\n",
+       "      <td>29.15</td>\n",
+       "      <td>...</td>\n",
+       "      <td>5.0</td>\n",
+       "      <td>4.0</td>\n",
+       "      <td>9.0</td>\n",
+       "      <td>6.0</td>\n",
+       "      <td>9.0</td>\n",
+       "      <td>5.0</td>\n",
+       "      <td>15.0</td>\n",
+       "      <td>15.0</td>\n",
+       "      <td>15</td>\n",
+       "      <td>15</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21474</th>\n",
+       "      <td>ZWE</td>\n",
+       "      <td>181</td>\n",
+       "      <td>Zimbabwe</td>\n",
+       "      <td>2960</td>\n",
+       "      <td>Fish, Seafood</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>-19.02</td>\n",
+       "      <td>29.15</td>\n",
+       "      <td>...</td>\n",
+       "      <td>18.0</td>\n",
+       "      <td>14.0</td>\n",
+       "      <td>17.0</td>\n",
+       "      <td>14.0</td>\n",
+       "      <td>15.0</td>\n",
+       "      <td>18.0</td>\n",
+       "      <td>29.0</td>\n",
+       "      <td>40.0</td>\n",
+       "      <td>40</td>\n",
+       "      <td>40</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21475</th>\n",
+       "      <td>ZWE</td>\n",
+       "      <td>181</td>\n",
+       "      <td>Zimbabwe</td>\n",
+       "      <td>2961</td>\n",
+       "      <td>Aquatic Products, Other</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>-19.02</td>\n",
+       "      <td>29.15</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21476</th>\n",
+       "      <td>ZWE</td>\n",
+       "      <td>181</td>\n",
+       "      <td>Zimbabwe</td>\n",
+       "      <td>2928</td>\n",
+       "      <td>Miscellaneous</td>\n",
+       "      <td>5142</td>\n",
+       "      <td>Food</td>\n",
+       "      <td>1000 tonnes</td>\n",
+       "      <td>-19.02</td>\n",
+       "      <td>29.15</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>21477 rows × 63 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "      Area Abbreviation  Area Code         Area  Item Code  \\\n",
+       "0                   AFG          2  Afghanistan       2511   \n",
+       "1                   AFG          2  Afghanistan       2805   \n",
+       "2                   AFG          2  Afghanistan       2513   \n",
+       "3                   AFG          2  Afghanistan       2513   \n",
+       "4                   AFG          2  Afghanistan       2514   \n",
+       "5                   AFG          2  Afghanistan       2514   \n",
+       "6                   AFG          2  Afghanistan       2517   \n",
+       "7                   AFG          2  Afghanistan       2520   \n",
+       "8                   AFG          2  Afghanistan       2531   \n",
+       "9                   AFG          2  Afghanistan       2536   \n",
+       "10                  AFG          2  Afghanistan       2537   \n",
+       "11                  AFG          2  Afghanistan       2542   \n",
+       "12                  AFG          2  Afghanistan       2543   \n",
+       "13                  AFG          2  Afghanistan       2745   \n",
+       "14                  AFG          2  Afghanistan       2549   \n",
+       "15                  AFG          2  Afghanistan       2549   \n",
+       "16                  AFG          2  Afghanistan       2551   \n",
+       "17                  AFG          2  Afghanistan       2560   \n",
+       "18                  AFG          2  Afghanistan       2561   \n",
+       "19                  AFG          2  Afghanistan       2563   \n",
+       "20                  AFG          2  Afghanistan       2571   \n",
+       "21                  AFG          2  Afghanistan       2572   \n",
+       "22                  AFG          2  Afghanistan       2573   \n",
+       "23                  AFG          2  Afghanistan       2574   \n",
+       "24                  AFG          2  Afghanistan       2575   \n",
+       "25                  AFG          2  Afghanistan       2577   \n",
+       "26                  AFG          2  Afghanistan       2579   \n",
+       "27                  AFG          2  Afghanistan       2580   \n",
+       "28                  AFG          2  Afghanistan       2586   \n",
+       "29                  AFG          2  Afghanistan       2601   \n",
+       "...                 ...        ...          ...        ...   \n",
+       "21447               ZWE        181     Zimbabwe       2765   \n",
+       "21448               ZWE        181     Zimbabwe       2766   \n",
+       "21449               ZWE        181     Zimbabwe       2767   \n",
+       "21450               ZWE        181     Zimbabwe       2775   \n",
+       "21451               ZWE        181     Zimbabwe       2680   \n",
+       "21452               ZWE        181     Zimbabwe       2905   \n",
+       "21453               ZWE        181     Zimbabwe       2905   \n",
+       "21454               ZWE        181     Zimbabwe       2907   \n",
+       "21455               ZWE        181     Zimbabwe       2908   \n",
+       "21456               ZWE        181     Zimbabwe       2909   \n",
+       "21457               ZWE        181     Zimbabwe       2911   \n",
+       "21458               ZWE        181     Zimbabwe       2912   \n",
+       "21459               ZWE        181     Zimbabwe       2913   \n",
+       "21460               ZWE        181     Zimbabwe       2913   \n",
+       "21461               ZWE        181     Zimbabwe       2914   \n",
+       "21462               ZWE        181     Zimbabwe       2918   \n",
+       "21463               ZWE        181     Zimbabwe       2919   \n",
+       "21464               ZWE        181     Zimbabwe       2922   \n",
+       "21465               ZWE        181     Zimbabwe       2923   \n",
+       "21466               ZWE        181     Zimbabwe       2924   \n",
+       "21467               ZWE        181     Zimbabwe       2943   \n",
+       "21468               ZWE        181     Zimbabwe       2945   \n",
+       "21469               ZWE        181     Zimbabwe       2946   \n",
+       "21470               ZWE        181     Zimbabwe       2949   \n",
+       "21471               ZWE        181     Zimbabwe       2948   \n",
+       "21472               ZWE        181     Zimbabwe       2948   \n",
+       "21473               ZWE        181     Zimbabwe       2960   \n",
+       "21474               ZWE        181     Zimbabwe       2960   \n",
+       "21475               ZWE        181     Zimbabwe       2961   \n",
+       "21476               ZWE        181     Zimbabwe       2928   \n",
+       "\n",
+       "                               Item  Element Code Element         Unit  \\\n",
+       "0                Wheat and products          5142    Food  1000 tonnes   \n",
+       "1          Rice (Milled Equivalent)          5142    Food  1000 tonnes   \n",
+       "2               Barley and products          5521    Feed  1000 tonnes   \n",
+       "3               Barley and products          5142    Food  1000 tonnes   \n",
+       "4                Maize and products          5521    Feed  1000 tonnes   \n",
+       "5                Maize and products          5142    Food  1000 tonnes   \n",
+       "6               Millet and products          5142    Food  1000 tonnes   \n",
+       "7                    Cereals, Other          5142    Food  1000 tonnes   \n",
+       "8             Potatoes and products          5142    Food  1000 tonnes   \n",
+       "9                        Sugar cane          5521    Feed  1000 tonnes   \n",
+       "10                       Sugar beet          5521    Feed  1000 tonnes   \n",
+       "11           Sugar (Raw Equivalent)          5142    Food  1000 tonnes   \n",
+       "12                Sweeteners, Other          5142    Food  1000 tonnes   \n",
+       "13                            Honey          5142    Food  1000 tonnes   \n",
+       "14       Pulses, Other and products          5521    Feed  1000 tonnes   \n",
+       "15       Pulses, Other and products          5142    Food  1000 tonnes   \n",
+       "16                Nuts and products          5142    Food  1000 tonnes   \n",
+       "17            Coconuts - Incl Copra          5142    Food  1000 tonnes   \n",
+       "18                      Sesame seed          5142    Food  1000 tonnes   \n",
+       "19     Olives (including preserved)          5142    Food  1000 tonnes   \n",
+       "20                     Soyabean Oil          5142    Food  1000 tonnes   \n",
+       "21                    Groundnut Oil          5142    Food  1000 tonnes   \n",
+       "22                Sunflowerseed Oil          5142    Food  1000 tonnes   \n",
+       "23             Rape and Mustard Oil          5142    Food  1000 tonnes   \n",
+       "24                   Cottonseed Oil          5142    Food  1000 tonnes   \n",
+       "25                         Palm Oil          5142    Food  1000 tonnes   \n",
+       "26                   Sesameseed Oil          5142    Food  1000 tonnes   \n",
+       "27                        Olive Oil          5142    Food  1000 tonnes   \n",
+       "28              Oilcrops Oil, Other          5142    Food  1000 tonnes   \n",
+       "29            Tomatoes and products          5142    Food  1000 tonnes   \n",
+       "...                             ...           ...     ...          ...   \n",
+       "21447                   Crustaceans          5142    Food  1000 tonnes   \n",
+       "21448                   Cephalopods          5142    Food  1000 tonnes   \n",
+       "21449               Molluscs, Other          5142    Food  1000 tonnes   \n",
+       "21450                Aquatic Plants          5142    Food  1000 tonnes   \n",
+       "21451                   Infant food          5142    Food  1000 tonnes   \n",
+       "21452      Cereals - Excluding Beer          5521    Feed  1000 tonnes   \n",
+       "21453      Cereals - Excluding Beer          5142    Food  1000 tonnes   \n",
+       "21454                 Starchy Roots          5142    Food  1000 tonnes   \n",
+       "21455                   Sugar Crops          5142    Food  1000 tonnes   \n",
+       "21456            Sugar & Sweeteners          5142    Food  1000 tonnes   \n",
+       "21457                        Pulses          5142    Food  1000 tonnes   \n",
+       "21458                      Treenuts          5142    Food  1000 tonnes   \n",
+       "21459                      Oilcrops          5521    Feed  1000 tonnes   \n",
+       "21460                      Oilcrops          5142    Food  1000 tonnes   \n",
+       "21461                Vegetable Oils          5142    Food  1000 tonnes   \n",
+       "21462                    Vegetables          5142    Food  1000 tonnes   \n",
+       "21463       Fruits - Excluding Wine          5142    Food  1000 tonnes   \n",
+       "21464                    Stimulants          5142    Food  1000 tonnes   \n",
+       "21465                        Spices          5142    Food  1000 tonnes   \n",
+       "21466           Alcoholic Beverages          5142    Food  1000 tonnes   \n",
+       "21467                          Meat          5142    Food  1000 tonnes   \n",
+       "21468                        Offals          5142    Food  1000 tonnes   \n",
+       "21469                   Animal fats          5142    Food  1000 tonnes   \n",
+       "21470                          Eggs          5142    Food  1000 tonnes   \n",
+       "21471       Milk - Excluding Butter          5521    Feed  1000 tonnes   \n",
+       "21472       Milk - Excluding Butter          5142    Food  1000 tonnes   \n",
+       "21473                 Fish, Seafood          5521    Feed  1000 tonnes   \n",
+       "21474                 Fish, Seafood          5142    Food  1000 tonnes   \n",
+       "21475       Aquatic Products, Other          5142    Food  1000 tonnes   \n",
+       "21476                 Miscellaneous          5142    Food  1000 tonnes   \n",
+       "\n",
+       "       latitude  longitude  ...     Y2004   Y2005   Y2006   Y2007   Y2008  \\\n",
+       "0         33.94      67.71  ...    3249.0  3486.0  3704.0  4164.0  4252.0   \n",
+       "1         33.94      67.71  ...     419.0   445.0   546.0   455.0   490.0   \n",
+       "2         33.94      67.71  ...      58.0   236.0   262.0   263.0   230.0   \n",
+       "3         33.94      67.71  ...     185.0    43.0    44.0    48.0    62.0   \n",
+       "4         33.94      67.71  ...     120.0   208.0   233.0   249.0   247.0   \n",
+       "5         33.94      67.71  ...     231.0    67.0    82.0    67.0    69.0   \n",
+       "6         33.94      67.71  ...      15.0    21.0    11.0    19.0    21.0   \n",
+       "7         33.94      67.71  ...       2.0     1.0     1.0     0.0     0.0   \n",
+       "8         33.94      67.71  ...     276.0   294.0   294.0   260.0   242.0   \n",
+       "9         33.94      67.71  ...      50.0    29.0    61.0    65.0    54.0   \n",
+       "10        33.94      67.71  ...       0.0     0.0     0.0     0.0     0.0   \n",
+       "11        33.94      67.71  ...     124.0   152.0   169.0   192.0   217.0   \n",
+       "12        33.94      67.71  ...       9.0    15.0    12.0     6.0    11.0   \n",
+       "13        33.94      67.71  ...       3.0     3.0     3.0     3.0     3.0   \n",
+       "14        33.94      67.71  ...       3.0     2.0     3.0     3.0     3.0   \n",
+       "15        33.94      67.71  ...      17.0    35.0    37.0    40.0    54.0   \n",
+       "16        33.94      67.71  ...      11.0    13.0    24.0    34.0    42.0   \n",
+       "17        33.94      67.71  ...       0.0     0.0     0.0     0.0     0.0   \n",
+       "18        33.94      67.71  ...      16.0    16.0    13.0    16.0    16.0   \n",
+       "19        33.94      67.71  ...       1.0     1.0     0.0     0.0     2.0   \n",
+       "20        33.94      67.71  ...       6.0    35.0    18.0    21.0    11.0   \n",
+       "21        33.94      67.71  ...       0.0     0.0     0.0     0.0     0.0   \n",
+       "22        33.94      67.71  ...       4.0     6.0     5.0     9.0     3.0   \n",
+       "23        33.94      67.71  ...       0.0     1.0     3.0     5.0     6.0   \n",
+       "24        33.94      67.71  ...       2.0     3.0     3.0     3.0     3.0   \n",
+       "25        33.94      67.71  ...      71.0    69.0    56.0    51.0    36.0   \n",
+       "26        33.94      67.71  ...       1.0     1.0     1.0     2.0     2.0   \n",
+       "27        33.94      67.71  ...       0.0     0.0     0.0     0.0     0.0   \n",
+       "28        33.94      67.71  ...       0.0     1.0     0.0     0.0     3.0   \n",
+       "29        33.94      67.71  ...       2.0     2.0     8.0     1.0     0.0   \n",
+       "...         ...        ...  ...       ...     ...     ...     ...     ...   \n",
+       "21447    -19.02      29.15  ...       0.0     0.0     0.0     0.0     0.0   \n",
+       "21448    -19.02      29.15  ...       0.0     0.0     0.0     0.0     0.0   \n",
+       "21449    -19.02      29.15  ...       0.0     0.0     0.0     0.0     0.0   \n",
+       "21450    -19.02      29.15  ...       0.0     0.0     0.0     0.0     0.0   \n",
+       "21451    -19.02      29.15  ...       0.0     0.0     0.0     0.0     0.0   \n",
+       "21452    -19.02      29.15  ...      75.0    54.0    75.0    55.0    63.0   \n",
+       "21453    -19.02      29.15  ...    1844.0  1842.0  1944.0  1962.0  1918.0   \n",
+       "21454    -19.02      29.15  ...     223.0   236.0   238.0   228.0   245.0   \n",
+       "21455    -19.02      29.15  ...       0.0     0.0     0.0     0.0     0.0   \n",
+       "21456    -19.02      29.15  ...     335.0   313.0   339.0   302.0   285.0   \n",
+       "21457    -19.02      29.15  ...      63.0    59.0    61.0    57.0    69.0   \n",
+       "21458    -19.02      29.15  ...       1.0     2.0     1.0     2.0     2.0   \n",
+       "21459    -19.02      29.15  ...      36.0    46.0    41.0    33.0    31.0   \n",
+       "21460    -19.02      29.15  ...      60.0    59.0    61.0    62.0    48.0   \n",
+       "21461    -19.02      29.15  ...     111.0   114.0   112.0   114.0   134.0   \n",
+       "21462    -19.02      29.15  ...     161.0   166.0   208.0   185.0   137.0   \n",
+       "21463    -19.02      29.15  ...     191.0   134.0   167.0   177.0   185.0   \n",
+       "21464    -19.02      29.15  ...       7.0    21.0    14.0    24.0    16.0   \n",
+       "21465    -19.02      29.15  ...       7.0    11.0     7.0    12.0    16.0   \n",
+       "21466    -19.02      29.15  ...     294.0   290.0   316.0   355.0   398.0   \n",
+       "21467    -19.02      29.15  ...     222.0   228.0   233.0   238.0   242.0   \n",
+       "21468    -19.02      29.15  ...      20.0    20.0    21.0    21.0    21.0   \n",
+       "21469    -19.02      29.15  ...      26.0    26.0    29.0    29.0    27.0   \n",
+       "21470    -19.02      29.15  ...      15.0    18.0    18.0    21.0    22.0   \n",
+       "21471    -19.02      29.15  ...      21.0    21.0    21.0    21.0    21.0   \n",
+       "21472    -19.02      29.15  ...     373.0   357.0   359.0   356.0   341.0   \n",
+       "21473    -19.02      29.15  ...       5.0     4.0     9.0     6.0     9.0   \n",
+       "21474    -19.02      29.15  ...      18.0    14.0    17.0    14.0    15.0   \n",
+       "21475    -19.02      29.15  ...       0.0     0.0     0.0     0.0     0.0   \n",
+       "21476    -19.02      29.15  ...       0.0     0.0     0.0     0.0     0.0   \n",
+       "\n",
+       "        Y2009   Y2010   Y2011  Y2012  Y2013  \n",
+       "0      4538.0  4605.0  4711.0   4810   4895  \n",
+       "1       415.0   442.0   476.0    425    422  \n",
+       "2       379.0   315.0   203.0    367    360  \n",
+       "3        55.0    60.0    72.0     78     89  \n",
+       "4       195.0   178.0   191.0    200    200  \n",
+       "5        71.0    82.0    73.0     77     76  \n",
+       "6        18.0    14.0    14.0     14     12  \n",
+       "7         0.0     0.0     0.0      0      0  \n",
+       "8       250.0   192.0   169.0    196    230  \n",
+       "9       114.0    83.0    83.0     69     81  \n",
+       "10        0.0     0.0     0.0      0      0  \n",
+       "11      231.0   240.0   240.0    250    255  \n",
+       "12        2.0     9.0    21.0     24     16  \n",
+       "13        3.0     3.0     2.0      2      2  \n",
+       "14        5.0     4.0     5.0      4      4  \n",
+       "15       80.0    66.0    81.0     63     74  \n",
+       "16       28.0    66.0    71.0     70     44  \n",
+       "17        0.0     0.0     0.0      0      0  \n",
+       "18       16.0    19.0    17.0     16     16  \n",
+       "19        3.0     2.0     2.0      2      2  \n",
+       "20        6.0    15.0    16.0     16     16  \n",
+       "21        0.0     0.0     0.0      0      0  \n",
+       "22        8.0    15.0    16.0     17     23  \n",
+       "23        6.0     1.0     2.0      2      2  \n",
+       "24        4.0     3.0     3.0      3      4  \n",
+       "25       53.0    59.0    51.0     61     64  \n",
+       "26        1.0     1.0     2.0      1      1  \n",
+       "27        1.0     1.0     1.0      1      1  \n",
+       "28        1.0     2.0     2.0      2      2  \n",
+       "29        0.0     0.0     0.0      0      0  \n",
+       "...       ...     ...     ...    ...    ...  \n",
+       "21447     0.0     0.0     0.0      0      0  \n",
+       "21448     0.0     0.0     0.0      0      0  \n",
+       "21449     0.0     1.0     0.0      0      0  \n",
+       "21450     0.0     0.0     0.0      0      0  \n",
+       "21451     0.0     0.0     0.0      0      0  \n",
+       "21452    62.0    55.0    55.0     55     55  \n",
+       "21453  1980.0  2011.0  2094.0   2071   2016  \n",
+       "21454   258.0   258.0   269.0    272    276  \n",
+       "21455     0.0     0.0     0.0      0      0  \n",
+       "21456   287.0   314.0   336.0    396    416  \n",
+       "21457    78.0    68.0    56.0     52     55  \n",
+       "21458     3.0     4.0     2.0      4      3  \n",
+       "21459    19.0    24.0    17.0     27     30  \n",
+       "21460    44.0    41.0    40.0     38     38  \n",
+       "21461   135.0   137.0   147.0    159    160  \n",
+       "21462   179.0   215.0   217.0    227    227  \n",
+       "21463   184.0   211.0   230.0    246    217  \n",
+       "21464    11.0    23.0    11.0     10     10  \n",
+       "21465    16.0    14.0    11.0     12     12  \n",
+       "21466   437.0   448.0   476.0    525    516  \n",
+       "21467   265.0   262.0   277.0    280    258  \n",
+       "21468    21.0    21.0    21.0     22     22  \n",
+       "21469    31.0    30.0    25.0     26     20  \n",
+       "21470    27.0    27.0    24.0     24     25  \n",
+       "21471    23.0    25.0    25.0     30     31  \n",
+       "21472   385.0   418.0   457.0    426    451  \n",
+       "21473     5.0    15.0    15.0     15     15  \n",
+       "21474    18.0    29.0    40.0     40     40  \n",
+       "21475     0.0     0.0     0.0      0      0  \n",
+       "21476     0.0     0.0     0.0      0      0  \n",
+       "\n",
+       "[21477 rows x 63 columns]"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {
+    "_cell_guid": "347e620f-b0e4-448e-81c7-e164f560c5a3",
+    "_uuid": "0acdd759950f5df3298224b0804562973663a11d",
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1728x864 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "area_list = list(df['Area'].unique())\n",
+    "year_list = list(df.iloc[:,10:].columns)\n",
+    "\n",
+    "plt.figure(figsize=(24,12))\n",
+    "for ar in area_list:\n",
+    "    yearly_produce = []\n",
+    "    for yr in year_list:\n",
+    "        yearly_produce.append(df[yr][df['Area'] == ar].sum())\n",
+    "    plt.plot(yearly_produce, label=ar)\n",
+    "plt.xticks(np.arange(53), tuple(year_list), rotation=60)\n",
+    "plt.legend(bbox_to_anchor=(0., 1.02, 1., .102), loc=3, ncol=8, mode=\"expand\", borderaxespad=0.)\n",
+    "plt.savefig('p.png')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 1728x864 with 0 Axes>"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 1728x864 with 0 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(figsize=(24,12))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "_cell_guid": "2ebe07e3-739b-4f39-8736-a512426c05bf",
+    "_uuid": "70900ec0ff5e248cd382ee53b5927cb671efa80e",
+    "collapsed": true
+   },
+   "source": [
+    "Clearly, China, India and US stand out here. So, these are the countries with most food and feed production.\n",
+    "\n",
+    "Now, let's have a close look at their food and feed data\n",
+    "\n",
+    "# Food and feed plot for the whole dataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {
+    "_cell_guid": "ec0c911d-e154-4f8a-a79f-ced4896d5115",
+    "_uuid": "683dc56125b3a4c66b1e140098ec91490cbbe96f",
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/anaconda3/lib/python3.7/site-packages/seaborn/categorical.py:3666: UserWarning: The `factorplot` function has been renamed to `catplot`. The original name will be removed in a future release. Please update your code. Note that the default `kind` in `factorplot` (`'point'`) has changed `'strip'` in `catplot`.\n",
+      "  warnings.warn(msg)\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 360x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "sns.factorplot(\"Element\", data=df, kind=\"count\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "_cell_guid": "189c74af-e6e4-4ddd-a73c-3725f3aa8124",
+    "_uuid": "bfd404fb5dbb48c3e3bd1dcd45fb27a5fb475a00"
+   },
+   "source": [
+    "So, there is a huge difference in food and feed production. Now, we have obvious assumptions about the following plots after looking at this huge difference.\n",
+    "\n",
+    "# Food and feed plot for the largest producers(India, USA, China)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "_cell_guid": "0bf44e4e-d4c4-4f74-ae9f-82f52139d182",
+    "_uuid": "be1bc3d49c8cee62f48a09ada0db3170adcedc17"
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/anaconda3/lib/python3.7/site-packages/seaborn/categorical.py:3666: UserWarning: The `factorplot` function has been renamed to `catplot`. The original name will be removed in a future release. Please update your code. Note that the default `kind` in `factorplot` (`'point'`) has changed `'strip'` in `catplot`.\n",
+      "  warnings.warn(msg)\n",
+      "/anaconda3/lib/python3.7/site-packages/seaborn/categorical.py:3672: UserWarning: The `size` paramter has been renamed to `height`; please update your code.\n",
+      "  warnings.warn(msg, UserWarning)\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<seaborn.axisgrid.FacetGrid at 0x1a218d2550>"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 521.175x576 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "sns.factorplot(\"Area\", data=df[(df['Area'] == \"India\") | (df['Area'] == \"China, mainland\") | (df['Area'] == \"United States of America\")], kind=\"count\", hue=\"Element\", size=8, aspect=.8)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "_cell_guid": "94c19dc8-b1e7-4b61-b81f-422c27184c4e",
+    "_uuid": "0d1cfc7acc74847dbc5813b9b3bd0eb9db450985"
+   },
+   "source": [
+    "Though, there is a huge difference between feed and food production, these countries' total production and their ranks depend on feed production."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "_cell_guid": "9dba87b4-fa51-43ef-95ae-f31396c20146",
+    "_uuid": "43e0f00abf706ab1782ebb78cefc38aca17316e6"
+   },
+   "source": [
+    "Now, we create a dataframe with countries as index and their annual produce as columns from 1961 to 2013."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {
+    "_cell_guid": "c4a5f859-0384-4c8e-b894-3f747aec8cf9",
+    "_uuid": "84dd7a2b601479728dd172d3100951553c2daff5",
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Afghanistan</th>\n",
+       "      <th>Albania</th>\n",
+       "      <th>Algeria</th>\n",
+       "      <th>Angola</th>\n",
+       "      <th>Antigua and Barbuda</th>\n",
+       "      <th>Argentina</th>\n",
+       "      <th>Armenia</th>\n",
+       "      <th>Australia</th>\n",
+       "      <th>Austria</th>\n",
+       "      <th>Azerbaijan</th>\n",
+       "      <th>...</th>\n",
+       "      <th>United Republic of Tanzania</th>\n",
+       "      <th>United States of America</th>\n",
+       "      <th>Uruguay</th>\n",
+       "      <th>Uzbekistan</th>\n",
+       "      <th>Vanuatu</th>\n",
+       "      <th>Venezuela (Bolivarian Republic of)</th>\n",
+       "      <th>Viet Nam</th>\n",
+       "      <th>Yemen</th>\n",
+       "      <th>Zambia</th>\n",
+       "      <th>Zimbabwe</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>9481.0</td>\n",
+       "      <td>1706.0</td>\n",
+       "      <td>7488.0</td>\n",
+       "      <td>4834.0</td>\n",
+       "      <td>92.0</td>\n",
+       "      <td>43402.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>25795.0</td>\n",
+       "      <td>22542.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>12367.0</td>\n",
+       "      <td>559347.0</td>\n",
+       "      <td>4631.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>97.0</td>\n",
+       "      <td>9523.0</td>\n",
+       "      <td>23856.0</td>\n",
+       "      <td>2982.0</td>\n",
+       "      <td>2976.0</td>\n",
+       "      <td>3260.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>9414.0</td>\n",
+       "      <td>1749.0</td>\n",
+       "      <td>7235.0</td>\n",
+       "      <td>4775.0</td>\n",
+       "      <td>94.0</td>\n",
+       "      <td>40784.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>27618.0</td>\n",
+       "      <td>22627.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>12810.0</td>\n",
+       "      <td>556319.0</td>\n",
+       "      <td>4448.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>101.0</td>\n",
+       "      <td>9369.0</td>\n",
+       "      <td>25220.0</td>\n",
+       "      <td>3038.0</td>\n",
+       "      <td>3057.0</td>\n",
+       "      <td>3503.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>9194.0</td>\n",
+       "      <td>1767.0</td>\n",
+       "      <td>6861.0</td>\n",
+       "      <td>5240.0</td>\n",
+       "      <td>105.0</td>\n",
+       "      <td>40219.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>28902.0</td>\n",
+       "      <td>23637.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>13109.0</td>\n",
+       "      <td>552630.0</td>\n",
+       "      <td>4682.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>103.0</td>\n",
+       "      <td>9788.0</td>\n",
+       "      <td>26053.0</td>\n",
+       "      <td>3147.0</td>\n",
+       "      <td>3069.0</td>\n",
+       "      <td>3479.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>10170.0</td>\n",
+       "      <td>1889.0</td>\n",
+       "      <td>7255.0</td>\n",
+       "      <td>5286.0</td>\n",
+       "      <td>95.0</td>\n",
+       "      <td>41638.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>29107.0</td>\n",
+       "      <td>24099.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>12965.0</td>\n",
+       "      <td>555677.0</td>\n",
+       "      <td>4723.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>102.0</td>\n",
+       "      <td>10539.0</td>\n",
+       "      <td>26377.0</td>\n",
+       "      <td>3224.0</td>\n",
+       "      <td>3121.0</td>\n",
+       "      <td>3738.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>10473.0</td>\n",
+       "      <td>1884.0</td>\n",
+       "      <td>7509.0</td>\n",
+       "      <td>5527.0</td>\n",
+       "      <td>84.0</td>\n",
+       "      <td>44936.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>28961.0</td>\n",
+       "      <td>22664.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>13742.0</td>\n",
+       "      <td>589288.0</td>\n",
+       "      <td>4581.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>107.0</td>\n",
+       "      <td>10641.0</td>\n",
+       "      <td>26961.0</td>\n",
+       "      <td>3328.0</td>\n",
+       "      <td>3236.0</td>\n",
+       "      <td>3940.0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>5 rows × 174 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   Afghanistan  Albania  Algeria  Angola  Antigua and Barbuda  Argentina  \\\n",
+       "0       9481.0   1706.0   7488.0  4834.0                 92.0    43402.0   \n",
+       "1       9414.0   1749.0   7235.0  4775.0                 94.0    40784.0   \n",
+       "2       9194.0   1767.0   6861.0  5240.0                105.0    40219.0   \n",
+       "3      10170.0   1889.0   7255.0  5286.0                 95.0    41638.0   \n",
+       "4      10473.0   1884.0   7509.0  5527.0                 84.0    44936.0   \n",
+       "\n",
+       "   Armenia  Australia  Austria  Azerbaijan    ...     \\\n",
+       "0      0.0    25795.0  22542.0         0.0    ...      \n",
+       "1      0.0    27618.0  22627.0         0.0    ...      \n",
+       "2      0.0    28902.0  23637.0         0.0    ...      \n",
+       "3      0.0    29107.0  24099.0         0.0    ...      \n",
+       "4      0.0    28961.0  22664.0         0.0    ...      \n",
+       "\n",
+       "   United Republic of Tanzania  United States of America  Uruguay  Uzbekistan  \\\n",
+       "0                      12367.0                  559347.0   4631.0         0.0   \n",
+       "1                      12810.0                  556319.0   4448.0         0.0   \n",
+       "2                      13109.0                  552630.0   4682.0         0.0   \n",
+       "3                      12965.0                  555677.0   4723.0         0.0   \n",
+       "4                      13742.0                  589288.0   4581.0         0.0   \n",
+       "\n",
+       "   Vanuatu  Venezuela (Bolivarian Republic of)  Viet Nam   Yemen  Zambia  \\\n",
+       "0     97.0                              9523.0   23856.0  2982.0  2976.0   \n",
+       "1    101.0                              9369.0   25220.0  3038.0  3057.0   \n",
+       "2    103.0                              9788.0   26053.0  3147.0  3069.0   \n",
+       "3    102.0                             10539.0   26377.0  3224.0  3121.0   \n",
+       "4    107.0                             10641.0   26961.0  3328.0  3236.0   \n",
+       "\n",
+       "   Zimbabwe  \n",
+       "0    3260.0  \n",
+       "1    3503.0  \n",
+       "2    3479.0  \n",
+       "3    3738.0  \n",
+       "4    3940.0  \n",
+       "\n",
+       "[5 rows x 174 columns]"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "new_df_dict = {}\n",
+    "for ar in area_list:\n",
+    "    yearly_produce = []\n",
+    "    for yr in year_list:\n",
+    "        yearly_produce.append(df[yr][df['Area']==ar].sum())\n",
+    "    new_df_dict[ar] = yearly_produce\n",
+    "new_df = pd.DataFrame(new_df_dict)\n",
+    "\n",
+    "new_df.head()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "_cell_guid": "15fbe29c-5cea-4ac3-9b95-f92acd89b336",
+    "_uuid": "ea48f75e9824a0c4c1a5f19cbd63e59a6cb44fe1"
+   },
+   "source": [
+    "Now, this is not perfect so we transpose this dataframe and add column names."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {
+    "_cell_guid": "145f751e-4f5b-4811-a68c-9d20b3c36e10",
+    "_uuid": "28e765d82bb4ebec3be49200a30fc4e0eabb24d7"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Y1961</th>\n",
+       "      <th>Y1962</th>\n",
+       "      <th>Y1963</th>\n",
+       "      <th>Y1964</th>\n",
+       "      <th>Y1965</th>\n",
+       "      <th>Y1966</th>\n",
+       "      <th>Y1967</th>\n",
+       "      <th>Y1968</th>\n",
+       "      <th>Y1969</th>\n",
+       "      <th>Y1970</th>\n",
+       "      <th>...</th>\n",
+       "      <th>Y2004</th>\n",
+       "      <th>Y2005</th>\n",
+       "      <th>Y2006</th>\n",
+       "      <th>Y2007</th>\n",
+       "      <th>Y2008</th>\n",
+       "      <th>Y2009</th>\n",
+       "      <th>Y2010</th>\n",
+       "      <th>Y2011</th>\n",
+       "      <th>Y2012</th>\n",
+       "      <th>Y2013</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>Afghanistan</th>\n",
+       "      <td>9481.0</td>\n",
+       "      <td>9414.0</td>\n",
+       "      <td>9194.0</td>\n",
+       "      <td>10170.0</td>\n",
+       "      <td>10473.0</td>\n",
+       "      <td>10169.0</td>\n",
+       "      <td>11289.0</td>\n",
+       "      <td>11508.0</td>\n",
+       "      <td>11815.0</td>\n",
+       "      <td>10454.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>16542.0</td>\n",
+       "      <td>17658.0</td>\n",
+       "      <td>18317.0</td>\n",
+       "      <td>19248.0</td>\n",
+       "      <td>19381.0</td>\n",
+       "      <td>20661.0</td>\n",
+       "      <td>21030.0</td>\n",
+       "      <td>21100.0</td>\n",
+       "      <td>22706.0</td>\n",
+       "      <td>23007.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Albania</th>\n",
+       "      <td>1706.0</td>\n",
+       "      <td>1749.0</td>\n",
+       "      <td>1767.0</td>\n",
+       "      <td>1889.0</td>\n",
+       "      <td>1884.0</td>\n",
+       "      <td>1995.0</td>\n",
+       "      <td>2046.0</td>\n",
+       "      <td>2169.0</td>\n",
+       "      <td>2230.0</td>\n",
+       "      <td>2395.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>6637.0</td>\n",
+       "      <td>6719.0</td>\n",
+       "      <td>6911.0</td>\n",
+       "      <td>6744.0</td>\n",
+       "      <td>7168.0</td>\n",
+       "      <td>7316.0</td>\n",
+       "      <td>7907.0</td>\n",
+       "      <td>8114.0</td>\n",
+       "      <td>8221.0</td>\n",
+       "      <td>8271.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Algeria</th>\n",
+       "      <td>7488.0</td>\n",
+       "      <td>7235.0</td>\n",
+       "      <td>6861.0</td>\n",
+       "      <td>7255.0</td>\n",
+       "      <td>7509.0</td>\n",
+       "      <td>7536.0</td>\n",
+       "      <td>7986.0</td>\n",
+       "      <td>8839.0</td>\n",
+       "      <td>9003.0</td>\n",
+       "      <td>9355.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>48619.0</td>\n",
+       "      <td>49562.0</td>\n",
+       "      <td>51067.0</td>\n",
+       "      <td>49933.0</td>\n",
+       "      <td>50916.0</td>\n",
+       "      <td>57505.0</td>\n",
+       "      <td>60071.0</td>\n",
+       "      <td>65852.0</td>\n",
+       "      <td>69365.0</td>\n",
+       "      <td>72161.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Angola</th>\n",
+       "      <td>4834.0</td>\n",
+       "      <td>4775.0</td>\n",
+       "      <td>5240.0</td>\n",
+       "      <td>5286.0</td>\n",
+       "      <td>5527.0</td>\n",
+       "      <td>5677.0</td>\n",
+       "      <td>5833.0</td>\n",
+       "      <td>5685.0</td>\n",
+       "      <td>6219.0</td>\n",
+       "      <td>6460.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>25541.0</td>\n",
+       "      <td>26696.0</td>\n",
+       "      <td>28247.0</td>\n",
+       "      <td>29877.0</td>\n",
+       "      <td>32053.0</td>\n",
+       "      <td>36985.0</td>\n",
+       "      <td>38400.0</td>\n",
+       "      <td>40573.0</td>\n",
+       "      <td>38064.0</td>\n",
+       "      <td>48639.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Antigua and Barbuda</th>\n",
+       "      <td>92.0</td>\n",
+       "      <td>94.0</td>\n",
+       "      <td>105.0</td>\n",
+       "      <td>95.0</td>\n",
+       "      <td>84.0</td>\n",
+       "      <td>73.0</td>\n",
+       "      <td>64.0</td>\n",
+       "      <td>59.0</td>\n",
+       "      <td>68.0</td>\n",
+       "      <td>77.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>92.0</td>\n",
+       "      <td>115.0</td>\n",
+       "      <td>110.0</td>\n",
+       "      <td>122.0</td>\n",
+       "      <td>115.0</td>\n",
+       "      <td>114.0</td>\n",
+       "      <td>115.0</td>\n",
+       "      <td>118.0</td>\n",
+       "      <td>113.0</td>\n",
+       "      <td>119.0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>5 rows × 53 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                      Y1961   Y1962   Y1963    Y1964    Y1965    Y1966  \\\n",
+       "Afghanistan          9481.0  9414.0  9194.0  10170.0  10473.0  10169.0   \n",
+       "Albania              1706.0  1749.0  1767.0   1889.0   1884.0   1995.0   \n",
+       "Algeria              7488.0  7235.0  6861.0   7255.0   7509.0   7536.0   \n",
+       "Angola               4834.0  4775.0  5240.0   5286.0   5527.0   5677.0   \n",
+       "Antigua and Barbuda    92.0    94.0   105.0     95.0     84.0     73.0   \n",
+       "\n",
+       "                       Y1967    Y1968    Y1969    Y1970   ...       Y2004  \\\n",
+       "Afghanistan          11289.0  11508.0  11815.0  10454.0   ...     16542.0   \n",
+       "Albania               2046.0   2169.0   2230.0   2395.0   ...      6637.0   \n",
+       "Algeria               7986.0   8839.0   9003.0   9355.0   ...     48619.0   \n",
+       "Angola                5833.0   5685.0   6219.0   6460.0   ...     25541.0   \n",
+       "Antigua and Barbuda     64.0     59.0     68.0     77.0   ...        92.0   \n",
+       "\n",
+       "                       Y2005    Y2006    Y2007    Y2008    Y2009    Y2010  \\\n",
+       "Afghanistan          17658.0  18317.0  19248.0  19381.0  20661.0  21030.0   \n",
+       "Albania               6719.0   6911.0   6744.0   7168.0   7316.0   7907.0   \n",
+       "Algeria              49562.0  51067.0  49933.0  50916.0  57505.0  60071.0   \n",
+       "Angola               26696.0  28247.0  29877.0  32053.0  36985.0  38400.0   \n",
+       "Antigua and Barbuda    115.0    110.0    122.0    115.0    114.0    115.0   \n",
+       "\n",
+       "                       Y2011    Y2012    Y2013  \n",
+       "Afghanistan          21100.0  22706.0  23007.0  \n",
+       "Albania               8114.0   8221.0   8271.0  \n",
+       "Algeria              65852.0  69365.0  72161.0  \n",
+       "Angola               40573.0  38064.0  48639.0  \n",
+       "Antigua and Barbuda    118.0    113.0    119.0  \n",
+       "\n",
+       "[5 rows x 53 columns]"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "new_df = pd.DataFrame.transpose(new_df)\n",
+    "new_df.columns = year_list\n",
+    "\n",
+    "new_df.head()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "_cell_guid": "57929d23-e3d7-4955-92d1-6fa388eb774d",
+    "_uuid": "605f908af9ff88120fce2a2b59160816fcdcfa67"
+   },
+   "source": [
+    "Perfect! Now, we will do some feature engineering.\n",
+    "\n",
+    "# First, a new column which indicates mean produce of each state over the given years. Second, a ranking column which ranks countries on the basis of mean produce."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {
+    "_cell_guid": "ab91a322-0cb9-4edf-b5a2-cde82a237824",
+    "_uuid": "979f875019abef3ed85af75e000fe59d1de5a381"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Y1961</th>\n",
+       "      <th>Y1962</th>\n",
+       "      <th>Y1963</th>\n",
+       "      <th>Y1964</th>\n",
+       "      <th>Y1965</th>\n",
+       "      <th>Y1966</th>\n",
+       "      <th>Y1967</th>\n",
+       "      <th>Y1968</th>\n",
+       "      <th>Y1969</th>\n",
+       "      <th>Y1970</th>\n",
+       "      <th>...</th>\n",
+       "      <th>Y2006</th>\n",
+       "      <th>Y2007</th>\n",
+       "      <th>Y2008</th>\n",
+       "      <th>Y2009</th>\n",
+       "      <th>Y2010</th>\n",
+       "      <th>Y2011</th>\n",
+       "      <th>Y2012</th>\n",
+       "      <th>Y2013</th>\n",
+       "      <th>Mean_Produce</th>\n",
+       "      <th>Rank</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>Afghanistan</th>\n",
+       "      <td>9481.0</td>\n",
+       "      <td>9414.0</td>\n",
+       "      <td>9194.0</td>\n",
+       "      <td>10170.0</td>\n",
+       "      <td>10473.0</td>\n",
+       "      <td>10169.0</td>\n",
+       "      <td>11289.0</td>\n",
+       "      <td>11508.0</td>\n",
+       "      <td>11815.0</td>\n",
+       "      <td>10454.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>18317.0</td>\n",
+       "      <td>19248.0</td>\n",
+       "      <td>19381.0</td>\n",
+       "      <td>20661.0</td>\n",
+       "      <td>21030.0</td>\n",
+       "      <td>21100.0</td>\n",
+       "      <td>22706.0</td>\n",
+       "      <td>23007.0</td>\n",
+       "      <td>13003.056604</td>\n",
+       "      <td>69.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Albania</th>\n",
+       "      <td>1706.0</td>\n",
+       "      <td>1749.0</td>\n",
+       "      <td>1767.0</td>\n",
+       "      <td>1889.0</td>\n",
+       "      <td>1884.0</td>\n",
+       "      <td>1995.0</td>\n",
+       "      <td>2046.0</td>\n",
+       "      <td>2169.0</td>\n",
+       "      <td>2230.0</td>\n",
+       "      <td>2395.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>6911.0</td>\n",
+       "      <td>6744.0</td>\n",
+       "      <td>7168.0</td>\n",
+       "      <td>7316.0</td>\n",
+       "      <td>7907.0</td>\n",
+       "      <td>8114.0</td>\n",
+       "      <td>8221.0</td>\n",
+       "      <td>8271.0</td>\n",
+       "      <td>4475.509434</td>\n",
+       "      <td>104.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Algeria</th>\n",
+       "      <td>7488.0</td>\n",
+       "      <td>7235.0</td>\n",
+       "      <td>6861.0</td>\n",
+       "      <td>7255.0</td>\n",
+       "      <td>7509.0</td>\n",
+       "      <td>7536.0</td>\n",
+       "      <td>7986.0</td>\n",
+       "      <td>8839.0</td>\n",
+       "      <td>9003.0</td>\n",
+       "      <td>9355.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>51067.0</td>\n",
+       "      <td>49933.0</td>\n",
+       "      <td>50916.0</td>\n",
+       "      <td>57505.0</td>\n",
+       "      <td>60071.0</td>\n",
+       "      <td>65852.0</td>\n",
+       "      <td>69365.0</td>\n",
+       "      <td>72161.0</td>\n",
+       "      <td>28879.490566</td>\n",
+       "      <td>38.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Angola</th>\n",
+       "      <td>4834.0</td>\n",
+       "      <td>4775.0</td>\n",
+       "      <td>5240.0</td>\n",
+       "      <td>5286.0</td>\n",
+       "      <td>5527.0</td>\n",
+       "      <td>5677.0</td>\n",
+       "      <td>5833.0</td>\n",
+       "      <td>5685.0</td>\n",
+       "      <td>6219.0</td>\n",
+       "      <td>6460.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>28247.0</td>\n",
+       "      <td>29877.0</td>\n",
+       "      <td>32053.0</td>\n",
+       "      <td>36985.0</td>\n",
+       "      <td>38400.0</td>\n",
+       "      <td>40573.0</td>\n",
+       "      <td>38064.0</td>\n",
+       "      <td>48639.0</td>\n",
+       "      <td>13321.056604</td>\n",
+       "      <td>68.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Antigua and Barbuda</th>\n",
+       "      <td>92.0</td>\n",
+       "      <td>94.0</td>\n",
+       "      <td>105.0</td>\n",
+       "      <td>95.0</td>\n",
+       "      <td>84.0</td>\n",
+       "      <td>73.0</td>\n",
+       "      <td>64.0</td>\n",
+       "      <td>59.0</td>\n",
+       "      <td>68.0</td>\n",
+       "      <td>77.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>110.0</td>\n",
+       "      <td>122.0</td>\n",
+       "      <td>115.0</td>\n",
+       "      <td>114.0</td>\n",
+       "      <td>115.0</td>\n",
+       "      <td>118.0</td>\n",
+       "      <td>113.0</td>\n",
+       "      <td>119.0</td>\n",
+       "      <td>83.886792</td>\n",
+       "      <td>172.0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>5 rows × 55 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                      Y1961   Y1962   Y1963    Y1964    Y1965    Y1966  \\\n",
+       "Afghanistan          9481.0  9414.0  9194.0  10170.0  10473.0  10169.0   \n",
+       "Albania              1706.0  1749.0  1767.0   1889.0   1884.0   1995.0   \n",
+       "Algeria              7488.0  7235.0  6861.0   7255.0   7509.0   7536.0   \n",
+       "Angola               4834.0  4775.0  5240.0   5286.0   5527.0   5677.0   \n",
+       "Antigua and Barbuda    92.0    94.0   105.0     95.0     84.0     73.0   \n",
+       "\n",
+       "                       Y1967    Y1968    Y1969    Y1970  ...      Y2006  \\\n",
+       "Afghanistan          11289.0  11508.0  11815.0  10454.0  ...    18317.0   \n",
+       "Albania               2046.0   2169.0   2230.0   2395.0  ...     6911.0   \n",
+       "Algeria               7986.0   8839.0   9003.0   9355.0  ...    51067.0   \n",
+       "Angola                5833.0   5685.0   6219.0   6460.0  ...    28247.0   \n",
+       "Antigua and Barbuda     64.0     59.0     68.0     77.0  ...      110.0   \n",
+       "\n",
+       "                       Y2007    Y2008    Y2009    Y2010    Y2011    Y2012  \\\n",
+       "Afghanistan          19248.0  19381.0  20661.0  21030.0  21100.0  22706.0   \n",
+       "Albania               6744.0   7168.0   7316.0   7907.0   8114.0   8221.0   \n",
+       "Algeria              49933.0  50916.0  57505.0  60071.0  65852.0  69365.0   \n",
+       "Angola               29877.0  32053.0  36985.0  38400.0  40573.0  38064.0   \n",
+       "Antigua and Barbuda    122.0    115.0    114.0    115.0    118.0    113.0   \n",
+       "\n",
+       "                       Y2013  Mean_Produce   Rank  \n",
+       "Afghanistan          23007.0  13003.056604   69.0  \n",
+       "Albania               8271.0   4475.509434  104.0  \n",
+       "Algeria              72161.0  28879.490566   38.0  \n",
+       "Angola               48639.0  13321.056604   68.0  \n",
+       "Antigua and Barbuda    119.0     83.886792  172.0  \n",
+       "\n",
+       "[5 rows x 55 columns]"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "mean_produce = []\n",
+    "for i in range(174):\n",
+    "    mean_produce.append(new_df.iloc[i,:].values.mean())\n",
+    "new_df['Mean_Produce'] = mean_produce\n",
+    "\n",
+    "new_df['Rank'] = new_df['Mean_Produce'].rank(ascending=False)\n",
+    "\n",
+    "new_df.head()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "_cell_guid": "6f7c4fb7-1475-439f-9929-4cf4b29d8de7",
+    "_uuid": "da6c9c98eaff45edba1179103ae539bbfbe9753b"
+   },
+   "source": [
+    "Now, we create another dataframe with items and their total production each year from 1961 to 2013"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {
+    "_cell_guid": "bfd692bc-dce4-4870-9ab9-9775cf69a87f",
+    "_uuid": "9e11017d381f175eee714643bc5fa763600aaa0b"
+   },
+   "outputs": [],
+   "source": [
+    "item_list = list(df['Item'].unique())\n",
+    "\n",
+    "item_df = pd.DataFrame()\n",
+    "item_df['Item_Name'] = item_list\n",
+    "\n",
+    "for yr in year_list:\n",
+    "    item_produce = []\n",
+    "    for it in item_list:\n",
+    "        item_produce.append(df[yr][df['Item']==it].sum())\n",
+    "    item_df[yr] = item_produce\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {
+    "_cell_guid": "3b7ed0c2-6140-4285-861c-d0cd2324a1f5",
+    "_uuid": "cb4641df5ce90f516f88c536e8a6c6870c5b4f65"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Item_Name</th>\n",
+       "      <th>Y1961</th>\n",
+       "      <th>Y1962</th>\n",
+       "      <th>Y1963</th>\n",
+       "      <th>Y1964</th>\n",
+       "      <th>Y1965</th>\n",
+       "      <th>Y1966</th>\n",
+       "      <th>Y1967</th>\n",
+       "      <th>Y1968</th>\n",
+       "      <th>Y1969</th>\n",
+       "      <th>...</th>\n",
+       "      <th>Y2004</th>\n",
+       "      <th>Y2005</th>\n",
+       "      <th>Y2006</th>\n",
+       "      <th>Y2007</th>\n",
+       "      <th>Y2008</th>\n",
+       "      <th>Y2009</th>\n",
+       "      <th>Y2010</th>\n",
+       "      <th>Y2011</th>\n",
+       "      <th>Y2012</th>\n",
+       "      <th>Y2013</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>Wheat and products</td>\n",
+       "      <td>138829.0</td>\n",
+       "      <td>144643.0</td>\n",
+       "      <td>147325.0</td>\n",
+       "      <td>156273.0</td>\n",
+       "      <td>168822.0</td>\n",
+       "      <td>169832.0</td>\n",
+       "      <td>171469.0</td>\n",
+       "      <td>179530.0</td>\n",
+       "      <td>189658.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>527394.0</td>\n",
+       "      <td>532263.0</td>\n",
+       "      <td>537279.0</td>\n",
+       "      <td>529271.0</td>\n",
+       "      <td>562239.0</td>\n",
+       "      <td>557245.0</td>\n",
+       "      <td>549926.0</td>\n",
+       "      <td>578179.0</td>\n",
+       "      <td>576597</td>\n",
+       "      <td>587492</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>Rice (Milled Equivalent)</td>\n",
+       "      <td>122700.0</td>\n",
+       "      <td>131842.0</td>\n",
+       "      <td>139507.0</td>\n",
+       "      <td>148304.0</td>\n",
+       "      <td>150056.0</td>\n",
+       "      <td>155583.0</td>\n",
+       "      <td>158587.0</td>\n",
+       "      <td>164614.0</td>\n",
+       "      <td>167922.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>361107.0</td>\n",
+       "      <td>366025.0</td>\n",
+       "      <td>372629.0</td>\n",
+       "      <td>378698.0</td>\n",
+       "      <td>389708.0</td>\n",
+       "      <td>394221.0</td>\n",
+       "      <td>398559.0</td>\n",
+       "      <td>404152.0</td>\n",
+       "      <td>406787</td>\n",
+       "      <td>410880</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>Barley and products</td>\n",
+       "      <td>46180.0</td>\n",
+       "      <td>48915.0</td>\n",
+       "      <td>51642.0</td>\n",
+       "      <td>54184.0</td>\n",
+       "      <td>54945.0</td>\n",
+       "      <td>55463.0</td>\n",
+       "      <td>56424.0</td>\n",
+       "      <td>60455.0</td>\n",
+       "      <td>65501.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>102055.0</td>\n",
+       "      <td>97185.0</td>\n",
+       "      <td>100981.0</td>\n",
+       "      <td>93310.0</td>\n",
+       "      <td>98209.0</td>\n",
+       "      <td>99135.0</td>\n",
+       "      <td>92563.0</td>\n",
+       "      <td>92570.0</td>\n",
+       "      <td>88766</td>\n",
+       "      <td>99452</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>Maize and products</td>\n",
+       "      <td>168039.0</td>\n",
+       "      <td>168305.0</td>\n",
+       "      <td>172905.0</td>\n",
+       "      <td>175468.0</td>\n",
+       "      <td>190304.0</td>\n",
+       "      <td>200860.0</td>\n",
+       "      <td>213050.0</td>\n",
+       "      <td>215613.0</td>\n",
+       "      <td>221953.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>545024.0</td>\n",
+       "      <td>549036.0</td>\n",
+       "      <td>543280.0</td>\n",
+       "      <td>573892.0</td>\n",
+       "      <td>592231.0</td>\n",
+       "      <td>557940.0</td>\n",
+       "      <td>584337.0</td>\n",
+       "      <td>603297.0</td>\n",
+       "      <td>608730</td>\n",
+       "      <td>671300</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>Millet and products</td>\n",
+       "      <td>19075.0</td>\n",
+       "      <td>19019.0</td>\n",
+       "      <td>19740.0</td>\n",
+       "      <td>20353.0</td>\n",
+       "      <td>18377.0</td>\n",
+       "      <td>20860.0</td>\n",
+       "      <td>22997.0</td>\n",
+       "      <td>21785.0</td>\n",
+       "      <td>23966.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>25789.0</td>\n",
+       "      <td>25496.0</td>\n",
+       "      <td>25997.0</td>\n",
+       "      <td>26750.0</td>\n",
+       "      <td>26373.0</td>\n",
+       "      <td>24575.0</td>\n",
+       "      <td>27039.0</td>\n",
+       "      <td>25740.0</td>\n",
+       "      <td>26105</td>\n",
+       "      <td>26346</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>5 rows × 54 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                  Item_Name     Y1961     Y1962     Y1963     Y1964     Y1965  \\\n",
+       "0        Wheat and products  138829.0  144643.0  147325.0  156273.0  168822.0   \n",
+       "1  Rice (Milled Equivalent)  122700.0  131842.0  139507.0  148304.0  150056.0   \n",
+       "2       Barley and products   46180.0   48915.0   51642.0   54184.0   54945.0   \n",
+       "3        Maize and products  168039.0  168305.0  172905.0  175468.0  190304.0   \n",
+       "4       Millet and products   19075.0   19019.0   19740.0   20353.0   18377.0   \n",
+       "\n",
+       "      Y1966     Y1967     Y1968     Y1969   ...       Y2004     Y2005  \\\n",
+       "0  169832.0  171469.0  179530.0  189658.0   ...    527394.0  532263.0   \n",
+       "1  155583.0  158587.0  164614.0  167922.0   ...    361107.0  366025.0   \n",
+       "2   55463.0   56424.0   60455.0   65501.0   ...    102055.0   97185.0   \n",
+       "3  200860.0  213050.0  215613.0  221953.0   ...    545024.0  549036.0   \n",
+       "4   20860.0   22997.0   21785.0   23966.0   ...     25789.0   25496.0   \n",
+       "\n",
+       "      Y2006     Y2007     Y2008     Y2009     Y2010     Y2011   Y2012   Y2013  \n",
+       "0  537279.0  529271.0  562239.0  557245.0  549926.0  578179.0  576597  587492  \n",
+       "1  372629.0  378698.0  389708.0  394221.0  398559.0  404152.0  406787  410880  \n",
+       "2  100981.0   93310.0   98209.0   99135.0   92563.0   92570.0   88766   99452  \n",
+       "3  543280.0  573892.0  592231.0  557940.0  584337.0  603297.0  608730  671300  \n",
+       "4   25997.0   26750.0   26373.0   24575.0   27039.0   25740.0   26105   26346  \n",
+       "\n",
+       "[5 rows x 54 columns]"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "item_df.head()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "_cell_guid": "3fa01e1f-bedd-431b-90c3-8d7d70545f34",
+    "_uuid": "56a647293f1c1aba7c184f249021e008a4d5a8f2"
+   },
+   "source": [
+    "# Some more feature engineering\n",
+    "\n",
+    "This time, we will use the new features to get some good conclusions.\n",
+    "\n",
+    "# 1. Total amount of item produced from 1961 to 2013\n",
+    "# 2. Providing a rank to the items to know the most produced item"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {
+    "_cell_guid": "3a6bb102-6749-4818-860d-59aaad6de07f",
+    "_uuid": "9e816786e7a161227ae72d164b25c0029e01e5b4",
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Item_Name</th>\n",
+       "      <th>Y1961</th>\n",
+       "      <th>Y1962</th>\n",
+       "      <th>Y1963</th>\n",
+       "      <th>Y1964</th>\n",
+       "      <th>Y1965</th>\n",
+       "      <th>Y1966</th>\n",
+       "      <th>Y1967</th>\n",
+       "      <th>Y1968</th>\n",
+       "      <th>Y1969</th>\n",
+       "      <th>...</th>\n",
+       "      <th>Y2006</th>\n",
+       "      <th>Y2007</th>\n",
+       "      <th>Y2008</th>\n",
+       "      <th>Y2009</th>\n",
+       "      <th>Y2010</th>\n",
+       "      <th>Y2011</th>\n",
+       "      <th>Y2012</th>\n",
+       "      <th>Y2013</th>\n",
+       "      <th>Sum</th>\n",
+       "      <th>Production_Rank</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>Wheat and products</td>\n",
+       "      <td>138829.0</td>\n",
+       "      <td>144643.0</td>\n",
+       "      <td>147325.0</td>\n",
+       "      <td>156273.0</td>\n",
+       "      <td>168822.0</td>\n",
+       "      <td>169832.0</td>\n",
+       "      <td>171469.0</td>\n",
+       "      <td>179530.0</td>\n",
+       "      <td>189658.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>537279.0</td>\n",
+       "      <td>529271.0</td>\n",
+       "      <td>562239.0</td>\n",
+       "      <td>557245.0</td>\n",
+       "      <td>549926.0</td>\n",
+       "      <td>578179.0</td>\n",
+       "      <td>576597</td>\n",
+       "      <td>587492</td>\n",
+       "      <td>19194671.0</td>\n",
+       "      <td>6.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>Rice (Milled Equivalent)</td>\n",
+       "      <td>122700.0</td>\n",
+       "      <td>131842.0</td>\n",
+       "      <td>139507.0</td>\n",
+       "      <td>148304.0</td>\n",
+       "      <td>150056.0</td>\n",
+       "      <td>155583.0</td>\n",
+       "      <td>158587.0</td>\n",
+       "      <td>164614.0</td>\n",
+       "      <td>167922.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>372629.0</td>\n",
+       "      <td>378698.0</td>\n",
+       "      <td>389708.0</td>\n",
+       "      <td>394221.0</td>\n",
+       "      <td>398559.0</td>\n",
+       "      <td>404152.0</td>\n",
+       "      <td>406787</td>\n",
+       "      <td>410880</td>\n",
+       "      <td>14475448.0</td>\n",
+       "      <td>8.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>Barley and products</td>\n",
+       "      <td>46180.0</td>\n",
+       "      <td>48915.0</td>\n",
+       "      <td>51642.0</td>\n",
+       "      <td>54184.0</td>\n",
+       "      <td>54945.0</td>\n",
+       "      <td>55463.0</td>\n",
+       "      <td>56424.0</td>\n",
+       "      <td>60455.0</td>\n",
+       "      <td>65501.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>100981.0</td>\n",
+       "      <td>93310.0</td>\n",
+       "      <td>98209.0</td>\n",
+       "      <td>99135.0</td>\n",
+       "      <td>92563.0</td>\n",
+       "      <td>92570.0</td>\n",
+       "      <td>88766</td>\n",
+       "      <td>99452</td>\n",
+       "      <td>4442742.0</td>\n",
+       "      <td>20.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>Maize and products</td>\n",
+       "      <td>168039.0</td>\n",
+       "      <td>168305.0</td>\n",
+       "      <td>172905.0</td>\n",
+       "      <td>175468.0</td>\n",
+       "      <td>190304.0</td>\n",
+       "      <td>200860.0</td>\n",
+       "      <td>213050.0</td>\n",
+       "      <td>215613.0</td>\n",
+       "      <td>221953.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>543280.0</td>\n",
+       "      <td>573892.0</td>\n",
+       "      <td>592231.0</td>\n",
+       "      <td>557940.0</td>\n",
+       "      <td>584337.0</td>\n",
+       "      <td>603297.0</td>\n",
+       "      <td>608730</td>\n",
+       "      <td>671300</td>\n",
+       "      <td>19960640.0</td>\n",
+       "      <td>5.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>Millet and products</td>\n",
+       "      <td>19075.0</td>\n",
+       "      <td>19019.0</td>\n",
+       "      <td>19740.0</td>\n",
+       "      <td>20353.0</td>\n",
+       "      <td>18377.0</td>\n",
+       "      <td>20860.0</td>\n",
+       "      <td>22997.0</td>\n",
+       "      <td>21785.0</td>\n",
+       "      <td>23966.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>25997.0</td>\n",
+       "      <td>26750.0</td>\n",
+       "      <td>26373.0</td>\n",
+       "      <td>24575.0</td>\n",
+       "      <td>27039.0</td>\n",
+       "      <td>25740.0</td>\n",
+       "      <td>26105</td>\n",
+       "      <td>26346</td>\n",
+       "      <td>1225400.0</td>\n",
+       "      <td>38.0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>5 rows × 56 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                  Item_Name     Y1961     Y1962     Y1963     Y1964     Y1965  \\\n",
+       "0        Wheat and products  138829.0  144643.0  147325.0  156273.0  168822.0   \n",
+       "1  Rice (Milled Equivalent)  122700.0  131842.0  139507.0  148304.0  150056.0   \n",
+       "2       Barley and products   46180.0   48915.0   51642.0   54184.0   54945.0   \n",
+       "3        Maize and products  168039.0  168305.0  172905.0  175468.0  190304.0   \n",
+       "4       Millet and products   19075.0   19019.0   19740.0   20353.0   18377.0   \n",
+       "\n",
+       "      Y1966     Y1967     Y1968     Y1969       ...            Y2006  \\\n",
+       "0  169832.0  171469.0  179530.0  189658.0       ...         537279.0   \n",
+       "1  155583.0  158587.0  164614.0  167922.0       ...         372629.0   \n",
+       "2   55463.0   56424.0   60455.0   65501.0       ...         100981.0   \n",
+       "3  200860.0  213050.0  215613.0  221953.0       ...         543280.0   \n",
+       "4   20860.0   22997.0   21785.0   23966.0       ...          25997.0   \n",
+       "\n",
+       "      Y2007     Y2008     Y2009     Y2010     Y2011   Y2012   Y2013  \\\n",
+       "0  529271.0  562239.0  557245.0  549926.0  578179.0  576597  587492   \n",
+       "1  378698.0  389708.0  394221.0  398559.0  404152.0  406787  410880   \n",
+       "2   93310.0   98209.0   99135.0   92563.0   92570.0   88766   99452   \n",
+       "3  573892.0  592231.0  557940.0  584337.0  603297.0  608730  671300   \n",
+       "4   26750.0   26373.0   24575.0   27039.0   25740.0   26105   26346   \n",
+       "\n",
+       "          Sum  Production_Rank  \n",
+       "0  19194671.0              6.0  \n",
+       "1  14475448.0              8.0  \n",
+       "2   4442742.0             20.0  \n",
+       "3  19960640.0              5.0  \n",
+       "4   1225400.0             38.0  \n",
+       "\n",
+       "[5 rows x 56 columns]"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "sum_col = []\n",
+    "for i in range(115):\n",
+    "    sum_col.append(item_df.iloc[i,1:].values.sum())\n",
+    "item_df['Sum'] = sum_col\n",
+    "item_df['Production_Rank'] = item_df['Sum'].rank(ascending=False)\n",
+    "\n",
+    "item_df.head()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "_cell_guid": "7e20740c-565b-4969-a52e-d986e462b750",
+    "_uuid": "f483c9add5f6af9af9162b5425f6d65eb1c5f4aa"
+   },
+   "source": [
+    "# Now, we find the most produced food items in the last half-century"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {
+    "_cell_guid": "3130fe83-404c-4b3c-addc-560b2e2f32bf",
+    "_uuid": "0403e9ab2e13587588e3a30d64b8b6638571d3d5"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "56    Cereals - Excluding Beer\n",
+       "65     Fruits - Excluding Wine\n",
+       "3           Maize and products\n",
+       "53     Milk - Excluding Butter\n",
+       "6        Potatoes and products\n",
+       "1     Rice (Milled Equivalent)\n",
+       "57               Starchy Roots\n",
+       "64                  Vegetables\n",
+       "27           Vegetables, Other\n",
+       "0           Wheat and products\n",
+       "Name: Item_Name, dtype: object"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "item_df['Item_Name'][item_df['Production_Rank'] < 11.0].sort_values()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "_cell_guid": "b6212fed-588b-426e-9271-6d857cd6aacb",
+    "_uuid": "e2c83f4c851b755ea6cf19f1bca168e705bd4edd"
+   },
+   "source": [
+    "So, cereals, fruits and maize are the most produced items in the last 50 years\n",
+    "\n",
+    "# Food and feed plot for most produced items "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {
+    "_cell_guid": "493f9940-1762-4718-acb4-fba5c4c73f4b",
+    "_uuid": "f8454c5200bdeb3995b9a0ada3deb5ca1c31f181"
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/anaconda3/lib/python3.7/site-packages/seaborn/categorical.py:3666: UserWarning: The `factorplot` function has been renamed to `catplot`. The original name will be removed in a future release. Please update your code. Note that the default `kind` in `factorplot` (`'point'`) has changed `'strip'` in `catplot`.\n",
+      "  warnings.warn(msg)\n",
+      "/anaconda3/lib/python3.7/site-packages/seaborn/categorical.py:3672: UserWarning: The `size` paramter has been renamed to `height`; please update your code.\n",
+      "  warnings.warn(msg, UserWarning)\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1212.38x1440 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "sns.factorplot(\"Item\", data=df[(df['Item']=='Wheat and products') | (df['Item']=='Rice (Milled Equivalent)') | (df['Item']=='Maize and products') | (df['Item']=='Potatoes and products') | (df['Item']=='Vegetables, Other') | (df['Item']=='Milk - Excluding Butter') | (df['Item']=='Cereals - Excluding Beer') | (df['Item']=='Starchy Roots') | (df['Item']=='Vegetables') | (df['Item']=='Fruits - Excluding Wine')], kind=\"count\", hue=\"Element\", size=20, aspect=.8)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "_cell_guid": "45dda825-49a0-41ab-9ebd-eaa609aac986",
+    "_uuid": "ce5b2d38ff24ea08da632c4e2773dbd0bd026b9d",
+    "collapsed": true
+   },
+   "source": [
+    "# Now, we plot a heatmap of correlation of produce in difference years"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {
+    "_cell_guid": "b1bab0ec-6615-452c-8d06-a81d4f2ae252",
+    "_uuid": "a2ed2aae2364810ce640648cf50880adcf2cdcc4"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.axes._subplots.AxesSubplot at 0x1a23b4b128>"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA2QAAAJYCAYAAAANJyWqAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzs3X+QXOV95/v3p+eHhMaSk9goldjcJa615LKNpGDWcCsOZkOFQNjF67gQTCjuboktXXnlW3XvJgRSgQ0kUTZFvCorlZQpRRYs4BVyvCaghUireA0yjlKLUIQYsCxbFInHSiyDsQ36wcx0f+8f5wg37Z7pPl8PTc/o86rqmp7znO95nnP6nNPzzDnn+ygiMDMzMzMzs96rvdkNMDMzMzMzO1O5Q2ZmZmZmZvYmcYfMzMzMzMzsTeIOmZmZmZmZ2ZvEHTIzMzMzM7M3iTtkZmZmZmZmbxJ3yMzMzMzMzN4k7pCZmZmZmZm9SdwhMzMzMzMze5O4Q2ZmZmZmZvYmGXyzG5A1+cJzUTmoPlk5JCYnKscAxInvV47R4HCurqlcG1PUmz58vPxCT+opKmvk4iZfrV7Vi/+Yq2swcahOTeXqymyPRnIbnjpROSRe/E6qKg0NVa/r5KlUXfGd76biUnVNVj+vZbZFUVn1z3nqH15MVaXhgeoxIwuqVzSRO05isl45ZuqF6ueMrFe+mft6b0xVP8dPTeS+F+qN6nEnT+b23RdPnVU55hVV3wcBjg1WX6/sN+tA9b+EeCVZ2T8MJPZ5Eg0EvhPV/645Tu5Yfql+snLMK43qx/IrU7nvk+Fa7lh+6p/+RqnAN1Hqb/ukobe/q6+2z4yHpQqPS7qiadpqSTslbZV0TNJYS8xKSXslPS1ph6QlTWUryrJnyvKF5fQNkr4p6ZXZXkEzMzMzM7N+NWOHLCICWAdslLRQ0giwAVgP3A1c3iZsC3BzRJwHPADcCCBpELgPWBcR7wMuAU7/a3cH8MEfd2XMzMzMzGwOatR79+ozHa+DRsSYpB3ATcAIcE9EHAGOSDq3TchyYE/5fjewC7gVuAw4GBFPlct97T6WiPhbAKmvrh6amZmZmZm9obq9MfV2YD8wAVzQYd4x4CrgQeBq4Jxy+jIgJO0Czgbuj4g7KrfYzMzMzMzml+wz/fNAV492RsRxYDtwb0R0epJxDbBe0pPAYopOHBSdvw8B15U/Pyrp0iqNlbRW0j5J+7bcs61KqJmZmZmZWd+pkrqlUb5mFBGHKG5PRNIy4MqyaBx4LCJeKMseAc4HvthtAyJiM7AZepuJxczMzMzM7I0w6znMJS0tf9aAW4A7y6JdwApJi8oEHx8Gnp3t+s3MzMzMbI5pNHr36jPpDpmkbcBeYLmkcUk3lEWjkg4Dh4CjwF0AEfESsBF4AjgA7I+Ih8tl3SFpHFhULuu2bLvMzMzMzMzmChWZ7eeeyW9/rXrDBxIDSiYGkwaIU8erB9Vyg1Cm0ndmH5zs0cDQAPHKSz2ri3r1ASWjkRho/HvHKscAaKj6gLcxUX2wy7QeDgzN93IDDacG1z6V24bxYqKNjeS5uJ44/mu9y2hb/2Zyn88MDH1WYmBoIE4ljuVXc98N9RcT+/xU9X3j5LeqVwMw9Wr1c/zkqdx3V6NefT88cWI4Vde3Ty6qHHM8OTD0Pw1V34ZKHv6Zb+T0wNC16t+Tk+mBoasPvHwicgNDf7de/Zh8pZ4b5DkzOPRQ8m/DQ8eemHOpyyeOPtOzTsnwz76vr7ZP7/66Nqug3ztjZjY/ZDpjWanOmJnNC5nOmJ05ZuyQqfC4pCuapq2WtFPSVknHJI21xKyUtFfS05J2SFrSVLaiLHumLF9YPlP2sKRD5fQ/mv3VNDMzMzOzvuVnyNqL4n7GdcDGsvM0AmwA1gN3A5e3CdsC3BwR5wEPADcClIk87gPWRcT7gEuA0/+a/GREvAf4eeAXmjuAZmZmZmZm81XHhyoiYkzSDuAmYAS4JyKOAEckndsmZDmwp3y/myK74q0UqfAPRsRT5XJPP2RxAvhSOW1C0n7gndkVMjMzMzOzOcYDQ3d0O/DrwBXAHR3mHQOuKt9fDZxTvl8GhKRdkvZL+q3WQEk/AfxrKoxNZmZmZmZmNld11SGLiOPAduDeiI6pb9YA6yU9CSwGJsrpg8CHgOvKnx+VdOnpoPKWxm3An0TEc+0WLGmtpH2S9m25d3s3TTczMzMzs37XqPfu1Weq5IFulK8ZRcQhitsTkbQMuLIsGgcei4gXyrJHgPP54dWwzcDXI+JTMyx7czlfLu29mZmZmZlZH5n1tPeSlpY/a8AtwJ1l0S5gRZlVcRD4MPBsOe8fAG8F/t/Zbo+ZmZmZmfW5aPTu1WfSHTJJ24C9wHJJ45JuKItGJR0GDgFHgbsAIuIlYCPwBHAA2B8RD0t6J/A7wHuB/ZIOSPr36TUyMzMzMzObI7q+ZTEibmv5fXSa+TYBm6Ypu48i9X3ztHGgr0bLNjMzMzOzHurD8cF6pcozZH0lJic6z9Qi1esbGMpEobMWVw+qT6Xqih5eei3uRK0mMus1fFb1mKzk9tNkp/w2bYy8NVVXZj/UwpFcXZn1ykp8zumHRwcTp7tTJ1JVpc412S+iTFxyn49G9a1fO5ncnwYGKodowXD1ehZW/y4B0KlT1YMmkuf4evXPa+gHue1eG+zd49mNevUjZWgy9zB+7WQqLCVzdNWS/5ZOHJJk0xlk1quRPGPXE7VlYiDXxuhRDEAjnDLhTDDjX9cqPN48ULOk1ZJ2Stoq6ZiksZaYlZL2Snpa0g5JS5rKVpRlz5TlC8vpOyU9VU6/U1L1b2IzMzMzM5uTIho9e/WbGTtkERHAOmCjpIWSRoANwHrgbuDyNmFbgJsj4jzgAeBGeC2t/X3Auoh4H3AJMFnGrI6IlcD7gbMpxi8zMzMzMzOb1zrewxMRY5J2ADcBI8A9EXEEOCLp3DYhy4E95fvdFNkVb6VIhX8wIp4ql/tiUx0/aGrPMD/GXUlmZmZmZmZzRbcPVdwO7KcY5PmCDvOOAVcBD1Jc6TqnnL4MCEm7KK6C3R8Rd5wOKqd/EPgr4PPdroCZmZmZmc1xZ3BSj64yNETEcWA7cG9EdHpSeA2wXtKTwGKKThwUnb8PAdeVPz8q6dKmOn4F+BlgAfBL7RYsaa2kfZL2bfms+2xmZmZmZja3VUk71qCLJDsRcYji9kQkLQOuLIvGgcci4oWy7BHgfOCLTbGnJD0EfITidsfWZW8GNgNMjD/t2xrNzMzMzOaDPky20SvpgaGnI2lp+bMG3ALcWRbtAlZIWlQm+Pgw8Kykt0j6mTJmEPhVikGlzczMzMzM5rV0h0zSNmAvsFzSuKQbyqJRSYcpOlVHgbsAIuIlYCPwBHAA2B8RD1MkCnlI0kHgKeAYP+zEmZmZmZnZfNeo9+7VZ7q+ZTEibmv5fXSa+TYBm6Ypu48i9X3ztG8D/6LbdpiZmZmZmc0XVZ4h6ytx4vvVgxYsqhyisxZXrweglhjbuj6Vq6uHWWkic021Ptl5nla1Wb+bdnrZzZdp48BQqioNLqgcE5H8D5AS65W973sgcQqa6pRXqL3UNhwcTtWVOiaz2zBTV/KcoXpinzp5MlUXg4l9Y6j68aV0+6qf43UqcS4EmKz+3TCwaKLzTG1Vfzx7cCq3PzXqqhwzcDK57/ZwNJ1ePgVTq74JaSRiACKxDevJ7Z7ZhsXQudXVE+feRqKuevI7eSDznTxX+RkyMzMzMzMz67UZO2QqPC7piqZpqyXtlLRV0jFJYy0xKyXtlfS0pB2SljSVrSjLninLF7bEPtS6PDMzMzMzm+cajd69+syMHbIorv+uAzZKWihpBNgArAfuBi5vE7YFuDkizgMeAG6E1zIo3gesi4j3AZcAr92/IenXgFd+zPUxMzMzMzObMzrepB8RY5J2ADdRZES8JyKOAEckndsmZDmwp3y/myLd/a0UY5MdjIinyuW+eDpA0luA/wisBT6XXRkzMzMzM5uDzuBnyLp9avp2YD8wAVzQYd4x4CrgQeBq4Jxy+jIgJO0Czgbuj4g7yrLfB/4LcKL7ppuZmZmZmc1tXSX1iIjjwHbg3ojolOJsDbBe0pPAYopOHBSdvw8B15U/PyrpUkmrgH8eEQ90aoektZL2Sdq3ZftD3TTdzMzMzMz63Rn8DFmVvMINushEGhGHKG5PRNIy4MqyaBx4LCJeKMseAc6neG7sA5KeL9uzVNKjEXFJm2VvBjYDvHr48d7lsDUzMzMzM3sDzHrae0lLy5814BbgzrJoF7BC0qIywceHgWcj4tMR8bMRcS7FlbPD7TpjZmZmZmY2P0XUe/bqN+kOmaRtwF5guaRxSTeURaOSDgOHgKPAXQAR8RKwEXgCOADsj4iHf5zGm5mZmZmZzWVd37IYEbe1/D46zXybgE3TlN1Hkfp+ujqeB97fTXs0ONzNbK9XG6geU5+qHpONG1qQqkoDVe48LfUyk02mfZNDubpqif8xZO8lri/sPM+PxCT3p8Q2VHa9BpLbPiGmOj2S+qM0mDtOUvtGZt/ttXriP33pfb76/hsnTqaq0lBiP6ypeszwEJw8VTkspqpv95hMHv8T1eMaE7m7+hsTnedpVZ9MbHegUa8eV5/K/R95IvH/50nl1iuzObL/Ha8lPuZJcvvGyc5PrfyIiUQMwMnGZOeZWhzP7LzAqUTciXr1764BDfDyZPXcdVO1/ruaY7NvDvy1YWZm9gZJdMbMzKrKdMbOOGdw2vsZ/ymjwuOSrmiatlrSTklbJR2TNNYSs1LSXklPS9ohaUlT2Yqy7JmyfGE5/VFJX5N0oHwtne0VNTMzMzMz6zczXiGLiJC0DvgLSV8CBoANwOXAO4A/Be5pCdsC/GZEPCZpDXAjcGuZyOM+4PqIeErS24Dma9LXRcS+WVkrMzMzMzObO/owHX2vdLxlMSLGJO0AbgJGgHsi4ghwRNK5bUKWA3vK97spsiveSpEK/2BEPFUu98Ufu/VmZmZmZmZzWLfPkN0O7KcY5PmCDvOOAVcBDwJXA+eU05cBIWkXcDZwf0Tc0RR3l6Q68N+BP4gIjzNmZmZmZnYm8DNkM4uI48B24N6I6JRaZg2wXtKTwGKKThwUnb8PAdeVPz8q6dKy7LqIOA/4xfJ1fbsFS1oraZ+kfVu2PdBN083MzMzMzPpWlSyLjfI1o4g4RHF7IpKWAVeWRePAYxHxQln2CHA+8MWI+FYZ+7Kk/wZ8kB99No2I2AxsBph47n/7CpqZmZmZ2XzQOHNT/KcHhp7O6QyJkmrALcCdZdEuYIWkRWWCjw8Dz0oalPT2MmYI+FcUtz2amZmZmZnNa+kOmaRtwF5guaRxSTeURaOSDgOHgKPAXQAR8RKwEXgCOADsj4iHgQXALkkHy+nfAv482y4zMzMzM5tjotG7V5/RXM2d8erhxys3XAsWVa9oaEH1GEil7tTwwlxdtYHqMXPhsnB9qnJIZA+yHqZajZMvV47RQG4M90hsQ+qTneeZLVMTnedpEa989w1oyDR1TZzMBX7vheoxmc8K4FSijdm6EsdJ41tHU1VpMHFeW5Q4x0NqcOg4kds3Gi98v3pdr+aOycnx6us1dVypuk79oPo5Khq5ul7+fvXvyn848ZbKMS8NJPZB4OhQKiyllvgT7geZIODvqb4/nYrc3xov1KsPonwicsfJ9yaPV445PpU7/l+ZrL4Nh5Pf///0va/mDrA30an//Rc965Qs/ODVfbV9cp+y2Rst+wdjRp93xtJ19XIbms1Vic5YVqYzlpXpjGVlOmNZmc6YWT/IdMbOOGfwOGQz3rKowuOSrmiatlrSTklbJR2TNNYSs1LSXklPS9ohaUlT2Yqy7JmyfGE5fVjSZkmHJR2S9LHZXlEzMzMzM7N+M+O/tSIiJK0D/kLSl4ABYANwOfAO4E/50WyIW4DfjIjHJK0BbgRuLRN53AdcHxFPSXobcPr68u8AxyJiWZkM5Kdmaf3MzMzMzKzf9eGzXb3S8T6DiBiTtAO4CRgB7omII8ARSee2CVkO7Cnf76bIrngrRSr8gxHxVLncF5ti1gDvKac3gMQDGGZmZmZmZnNLtzd+3w7spxjk+YIO844BVwEPAlcD55TTlwEhaRdwNnB/RNwh6SfK8t+XdAlwBPhERHy767UwMzMzM7O5y8+QzSwijgPbgXsj4tUOs68B1kt6ElhM0YmDovP3IeC68udHJV1aTn8n8JWIOJ8ilf4n2y1Y0lpJ+yTt27L9oW6abmZmZmZm1jVJl0v6mqRvSLq5Tfk/k/RFSQclPSrpnU1l/4ek/ynpq5KeneaOwtepkhqpUb5mFBGHKG5PRNIy4MqyaBx4LCJeKMseAc4H/hdwAnignO8vgBtoIyI2A5shl/bezMzMzMxsOpIGgD8Dfpmi//KEpIci4tmm2T5J8RjXf5X0S8B/Bq4vy+4BNkTEbklvoYv+U3pg6OlIWlr+rAG3AHeWRbuAFZIWlQk+Pgw8G8VAaDuAS8r5LgWexczMzMzMzgyNRu9eM/sg8I2IeC4iJoD7gY+0zPNe4Ivl+y+dLpf0XmAwInYDRMQrEdFxYL10h0zSNorbC5dLGpd0+qrWqKTDwCHgKHBX2aCXgI3AE8ABYH9EPFzG3ATcJukgRe/yN7LtMjMzMzMzS3oH8M2m38fLac2eAk4P0/VRYHGZQX4Z8D1JX5D0d5L+uLziNqOub1mMiNtafh+dZr5NwKZpyu6jSH3fOv3vgYu7bYuZmZmZmc0fEfWe1SVpLbC2adLm8tEoALUJaX1U6jeBP5X07yiyy38LmKLoW/0i8PPAP1Dk4Ph3wGdmak+VZ8jmvn4f3yDbvkxYrWNnfZq6enSw1HIXb5XYFjHrN+7OILleqbj0ig0l4xIy+/xA705bGlqQiouh4epB2X2jPtW7uhIZsLQgsS0ABhLnqKHEvpvM6qV69XOhFiSPrVq7vw06hCzslH+rvYFG9cezhyZy3wuNevX1Gl6Q2N+B4RPVP+cFyXPogqi+Xlm1xNP0C5JP4A8rsT2Sm2K48wWFH1FP/TEEw7Xq3ykTterH8vBAct9NtM86a85L0cY4P8wSD0XywaMt8UeBXwMonxP7WER8X9I48HcR8VxZ9pfARXTokM14dKnwuKQrmqatlrRT0lZJxySNtcSslLRX0tOSdkha0lS2oix7pixfKGmxpANNrxckfWqmdpmZmZmZ2TzSP8+QPQG8W9LPSRoGrgVel95d0tvLfBkAvw1sbYr9SUlnl7//El3kxpixQ1Ym3FgHbCw7TyPABmA9cDdweZuwLcDNEXEeRebEG8uGD1LcrrguIt5HkcRjMiJejohVp1/A3wNf6NRwMzMzMzOz2RQRU8AnKBISfhX4XEQ8I+n3JF1VznYJ8LUyb8ZPU/SPiOK+y98EvijpaYrrxH/eqc6O10EjYkzSDorEGyMUKR6PAEemyau/nOJeSoDd5crcSpEK/2BEPFUu98XWQEnvBpYCX+7ULjMzMzMzmyf66NGiiHgEeKRl2n9qev954PPTxO4GVlSpr9sbU28H9lMM8nxBh3nHgKuAB4Gr+eE9mMuAkLQLOBu4PyLuaIkdBbaXV+bMzMzMzMzmta6e0IyI4xRZQu6NiE5PCq8B1kt6ElhM0YmDovP3IeC68udHJV3aEnstsG26BUtaK2mfpH1btj803WxmZmZmZjaX9M8zZD1XJXVLgy7y+UXEIYrbE5G0DLiyLBoHHouIF8qyR4DzKQdVk7SSYiC1J2dY9msZUV49/LivopmZmZmZ2Zw26wm/JS0tf9aAW4A7y6JdwApJi8oEHx/m9VlHRpnh6piZmZmZmc1T0ejdq8+kO2SStgF7geWSxiXdUBaNlhlHDlHk7L8LICJeAjZSpIM8AOyPiIebFrkad8jMzMzMzOwM0vUtixFxW8vvo9PMtwnYNE3ZfRSp79uVvavbtpiZmZmZ2TzSh8929crcHf47NWJ89Rhl6gFi1m8GnWWNei6uNtCbupIHZfTyMnR9qnrMZKecOO2lHpjMtA+gPlk9JnmcpNo4NdF5nnYSbYzk58Vkoo3ZzytzrGS/9DJx9ey5JrFP9XBbRCYue35qVD8DRCIGIBK7YYRydTWqx2ViAIJcXEYv/6TMnHnP3D9524vcN2zPNPq8fTY75m6HzMzMzMzM5oc+fLarV2b854oKj0u6omnaakk7JW2VdEzSWEvMSkl7JT0taYekJU1lK8qyZ8ryheX00fL3g+Wy3z7bK2pmZmZmZtZvZuyQlQM0rwM2SlooaQTYAKwH7gYubxO2Bbg5Is4DHgBuBCgzK94HrIuI9wGXAJPl9E3Av4yIFcBB4BM//qqZmZmZmZn1t463LEbEmKQdwE3ACHBPRBwBjkg6t03IcmBP+X43Rbr7WynGJjsYEU+Vy30RQNIQIGBE0ovAEuAbP8Y6mZmZmZnZXOKkHh3dDuwHJoALOsw7BlwFPAhcDZxTTl8GhKRdwNnA/RFxR0RMSvo48DRwHPg6xRU4MzMzMzOzea2rBD0RcRzYDtwbEZ3Sjq0B1kt6ElhM0YmDovP3IeC68udHJV1aXiH7OPDzwM9S3LL42+0WLGmtpH2S9m25/8Fumm5mZmZmZv2u0ejdq89UybLYoItsqRFxiOL2RCQtA64si8aBxyLihbLsEeB84Adl3JFy+ueAm6dZ9mZgM8CrX/8b5wE1MzMzM7M5bdZHy5K0tPxZA24B7iyLdgErJC0qE3l8GHgW+BbwXklnl/P9MvDV2W6XmZmZmZn1qWj07tVn0h0ySduAvcBySeOSbiiLRiUdBg4BR4G7ACLiJWAj8ARwANgfEQ9HxFGKZ9T2SDoIrAL+MNsuMzMzMzOzuaLrWxYj4raW30enmW8TRRr7dmX3UaS+b51+Jz+8ktZXoj6VC6xPVo8ZmAPjdDfq1WNqA7mYxDZU5n8MyXuJo98/r8xnBaBZv3DeH3r5H7FMXdn21ROfc/b++UQbYyq3HyqzH2a24fAQnDxVPa5R/a75mEpu98TnFcmvrl7uupF48CATA108bzFLMdm47Fm3oWRgQp3qG7+R/MAy27CerKue2IEbUf28dtbAMC9PnqwcJ3r4Ib/Z+vDZrl6Zp3952ZyX6dCamVWV6YyZmVWU6YzZmWPGDpkKj0u6omnaakk7JW2VdEzSWEvMSkl7JT0taYekJU1lK8qyZ8ryheX0ayQdLKffMdsraWZmZmZmfczPkLUXEQGsAzZKWihpBNhAMU7Y3cDlbcK2ADdHxHnAA8CNAGUij/uAdRHxPuASYFLS24A/Bi4tp/+0pEtnYd3MzMzMzMz6WseHYCJiTNIO4CZgBLinTFF/RNK5bUKWA3vK97spsiveSpEK/2BEPFUu90UASe8CDkfEd8qYvwY+BnwxuU5mZmZmZjaXnMHPkHWbleB2YD/FIM8XdJh3DLgKeBC4GjinnL4MCEm7gLOB+yPiDuAbwHvKzt048G+A4e5XwczMzMzMbG7qKqlHRBwHtgP3RsSrHWZfA6yX9CSwmKITB0Xn70PAdeXPj0q6tEyH//Fy+V8Gngfa5oeStFbSPkn7ttz/YDdNNzMzMzOzfncGP0NWJW93gy4ykUbEIYrbE5G0DLiyLBoHHouIF8qyR4DzgS9GxA5gRzl9LdA2n2hEbAY2A7z69b9JJr81MzMzMzPrD7Oe9l7S0vJnDbiFH44vtgtYIWlRmeDjw8CzLTE/CfwHisQgZmZmZmZ2Jmg0evfqM+kOmaRtwF5guaRxSTeURaOSDgOHgKPAXQDlrYkbgSeAA8D+iHi4jNkk6VngK8AfRcThbLvMzMzMzMzmiq5vWYyI21p+H51mvk3ApmnK7qNIfd86ve2yzMzMzMzM5rMqz5D1lXj5hepBC0aqxwyfVT0GoJa4+Dg5lKpKA4mPMdM+yF3mzTw8OZDbFtQnc3EJGkwkAz1rca6y2kD1mMx+AaDEvpF8QDYmEuuVOY4h1UZltgUQZ72letDkROd52skck5PJ4yRRlQYTnzFATbm4yvUkz4U9fCg8Xm2b52rmmOohADQmq2/3yVO5zzga1es69Wruu+H7iXPoS4O5ffC7tcS5JlVTzsuZAxn4TuNU5ZiJaJsSoKMXp16pHHO83innXHvfm6he14mp6nUdn6i+/QAGM9//c1Uf3krYKzN+E6nwuKQrmqatlrRT0lZJxySNtcSslLRX0tOSdkhaUk6/TtKBpldD0qqy7APl/N+Q9CeSenluMjMzMzMze1PM2CGLiADWARslLZQ0AmwA1gN3A5e3CdsC3BwR5wEPADeWy/psRKyKiFXA9cDzEXGgjPk0sBZ4d/lqt1wzMzMzM5uPInr36jMd79WIiDGKlPQ3Ab8L3BMRRyJiD/DdNiHLgT3l+93Ax9rMMwpsA5D0M8CSiNhbdgDvoRgc2szMzMzMbF7r9iGT24H9FIM8X9Bh3jHgKuBB4GrgnDbzXAN8pHz/Dooxyk4bL6eZmZmZmdmZwM+QzSwijgPbgXsjotOTjGuA9ZKeBBZTdOJeI+lC4ER55Q3aP8va9lqipLWS9kna95kv7Oqm6WZmZmZmZn2rShq2Bl3k2IqIQ8BlAJKWAVe2zHIt5e2KpXHgnU2/v5Ni/LJ2y94MbAY4tf+h/rsB1MzMzMzMqvMVstkjaWn5swbcAtzZVFajuI3x/tPTIuIfgZclXVRmV/y/KG53NDMzMzMzm9fSHTJJ24C9wHJJ45JuKItGJR0GDlFc6bqrKexiYDwinmtZ3McpsjN+AzgC/FW2XWZmZmZmNsdEo3evPtP1LYsRcVvL76PTzLcJ2DRN2aPARW2m7wPe321bzMzMzMzM5oMqz5DZG62Wu2AZiZ6+kv8cSNWVuRBbn6weAzAwVD1G9VxdiW0RUxOdZ2pDAz08VHv5n6PEemlwQaqqiMTnnN3uJ1+uHpM8/lOf19BUrq56Im54OFfXYGLfWDRSOSaU2+7tslF1jDl+MlfXYPU2Dnwvea6pVX88Oxq5/alRr74VF03m1mvxS9WP/0Z9IFXXDxLHcmKzA7n9sFbLRMFPqPqxPJH8Y2NioPo+VUsey1OJ74aactswY7iX3/9vNj9D1p4Kj0u6omnaakk7JW1Y6dHeAAAgAElEQVSVdEzSWEvMSkl7JT0taYekJeX06yQdaHo1JK0qyzZI+qakV96IlTQzMzMzM+tHM3bIyoGa1wEbJS2UNAJsANYDdwOXtwnbAtwcEecBDwA3lsv6bESsiohVwPXA8xFxoIzZAXxwFtbHzMzMzMzmmojevfpMx+ugETEmaQdwEzAC3BMRR4Ajks5tE7Ic2FO+3w3sAm5tmWeUptT3EfG3AOrhJWAzMzMzM7M3W7c3pt4O7KcY5PmCDvOOAVdRpK6/GjinzTzXAB/psm4zMzMzM5vP/AzZzCLiOLAduDciXu0w+xpgvaQngcUUnbjXSLoQOBERY+2CZyJpraR9kvZ95gu7qoabmZmZmZn1lSqpWxrla0YRcQi4DEDSMuDKllmupel2xSoiYjOwGeDU/of67wZQMzMzMzOr7gy+QjbruTQlLY2IY5JqwC3AnU1lNYrbGC+e7XrNzMzMzMzmmuTANyBpG7AXWC5pXNINZdGopMPAIeAocFdT2MXAeEQ817KsOySNA4vKZd2WbZeZmZmZmdlc0fUVsoi4reX30Wnm2wRsmqbsUeCiNtN/C/itbttiZmZmZmbzSPiWxbkn86HVq4/8nt45MmE9vHc20tdGE3p5T7Dq1WNqA7m66j3aBwFU/QOLHp7YlGhfVjQmc4GZNmb33cznnN03Mm3Mrlcmrp44JgFqic9rKrPdk+2bSsRN5j7jmKheV+NU7jHr+qnqMZOncsd/Y6p63Kuncn+2nEic51+p5YbieUWJbZ8c9WcwUdUr5Pb541TffyciV9crjU75437UiXr1GIBXJk9Wjjk+Wf1AOTGZa9+r2b9RbE6Zux0yMzMzMzObF6Jx5ubrm/HfUyo8LumKpmmrJe2UtFXSMUljLTErJe2V9LSkHZKWlNOvk3Sg6dWQtErSIkkPSzok6RlJf/TGrKqZmZmZmVl/mbFDFhEBrAM2SlooaQTYAKwH7gYubxO2Bbg5Is4DHgBuLJf12YhYFRGrgOuB5yPiQBnzyYh4D/DzwC80dwDNzMzMzGyeazR69+ozHW9ZjIgxSTuAm4AR4J6IOAIckXRum5DlwJ7y/W5gF3BryzyjlGORRcQJ4Evl+wlJ+4F3Vl4TMzMzMzOzOabbZ8huB/YDE8AFHeYdA64CHqQYc+ycNvNcA3ykdaKknwD+NdNkaTQzMzMzs3noDM6y2FWKo4g4DmwH7o2ITmli1gDrJT0JLKboxL1G0oXAiYhoffZskOKq2Z+0jlPWNM9aSfsk7fvMF/5nN003MzMzMzPrW1WyLDboIpl7RBwCLgOQtAy4smWWaylvV2yxGfh6RHxqhmVvLufj1JN/eeamYjEzMzMzm0/O4CyLs572XtLSiDimYmCiW4A7m8pqFLcxXtwS8wfAW4F/P9vtMTMzMzMz61fp0VwlbQP2AssljUu6oSwalXQYOAQcBe5qCrsYGG++JVHSO4HfAd4L7C9T4rtjZmZmZmZ2pnCWxc4i4raW30enmW8T0yTliIhHgYtapo2TGaM+MeJ5DFS/IKjkyOrUEn3d+sJcXQNDubiM+lTlkMx2B9DgcPWgzAOh9eSBmdjuWvTWXF2J/UmJz6oITP+fpnpVU4nja+isXGWZfbeW3DeGE8fy5ETneWYrrp6rKnVeG0qenwYHqsdkjpNFi4hXE/thrfrXlhYkzmkAjertG1iUPY6r7/ODJ7PHSfW4Bady57VFJ6vv9K8q9921KKrvG1mZT/ms5P/iF5I4JpOb4ixVP29ELXe726LB5N9eFY0MLeT45KnKccPJv6FsbvGnbH0p1RkzM6so1RkzM6so0xk74/ThlatemfHfJCo83jxQs6TVknZK2irpmKTWbIkrJe2V9LSkHZKWlNOvK29HPP1qSFpVlu2U9JSkZyTdKSnxbxgzMzMzM7O5ZcYOWUQEsA7YKGmhpBFgA7AeuBu4vE3YFuDmiDgPeAC4sVzWZyNiVUSsAq4Hno+IA2XM6ohYCbwfOJsi8YeZmZmZmZ0JInr36jMdb1mMiDFJO4CbgBHgnog4AhyRdG6bkOXAnvL9bmAXcGvLPKM0pb6PiB80tWcY6L8tZWZmZmZmNsu6fYbsdmA/xSDPF3SYdwy4CniQ4krXOW3muQb4SPMESbuADwJ/BXy+y3aZmZmZmZnNWV2l2omI48B24N6I6PQE9BpgvaQngcUUnbjXSLoQOBERr3v2LCJ+BfgZYAHwS+0WLGmtpH2S9n3mL/+6m6abmZmZmVm/c9r7rjToIh9uRBwCLgOQtAy4smWWa2m6XbEl9pSkhyiunu1uU74Z2Axw6m+3+7ZGMzMzMzOb02Y97b2kpRFxTFINuAW4s6msRnEb48VN094CLI6If5Q0CPwq8OXZbpeZmZmZmfWpxpl7rSU9AqykbcBeYLmkcUk3lEWjkg4Dh4CjwF1NYRcD4xHxXNO0EeAhSQeBp4BjNHXizMzMzMzM5quur5BFxG0tv49OM98mYNM0ZY8CF7VM+zbwL7pth5mZmZmZzTPRf8929cqs37LYK/HiP1YPGlmSiHlr9RiAgaHqMfWpXF0LRqrH1JIXRyc75XSZJWctToXF1ETnmVolt7sWVd83tDDxWQE06tVjBnp3eEd2380YPisXV5+sHKLE7gTAW36qeszEyVRVqRs8dCJVV6qqn3pbz+piwYLKIRrq3XZXPXEcA9RUOWTgZ3K3/ujFxL7R6N3xX5/MHZRv/V6ijcmP61St+rm3h2dQasnv/+/XhivHnMpuxMTX18lG9fYBDCU+r1eHFlWOeWXoVOUYgKHaQCrO5pYZj0oVHpd0RdO01ZJ2Stoq6ZiksZaYlZL2Snpa0g5JS8rp10k60PRqSFrVEvtQ6/LMzMzMzGyea0TvXn1mxg5ZRASwDtgoaaGkEWADsB64G7i8TdgW4OaIOA94ALixXNZnI2JVRKwCrgeej4gDp4Mk/Rrwyo+/SmZmZmZmZnNDx+u0ETEmaQdwE0UCjnsi4ghwRNK5bUKWA3vK97uBXcCtLfOM0pT6vsy0+B+BtcDnqq2CmZmZmZnNZdGH44P1Src3zt4O7KcY5PmCDvOOAVcBD1KkuD+nzTzXUIw1dtrvA/8F6N2DDWZmZmZmZm+yrp7sjIjjwHbg3ojolNVhDbBe0pPAYopO3GskXQiciIix8vdVwD+PiAc6tUPSWkn7JO37zM6/6abpZmZmZmbW787gZ8iqpJZplK8ZRcQh4DIAScuAK1tmuZam2xWB/xP4gKTny/YslfRoRFzSZtmbgc0AJx/+VP9tTTMzMzMzswpmPS+2pKURcUxSDbiFpkGey2lXUwwQDUBEfBr4dFl+LvA/2nXGzMzMzMxsnjqDxyFLDkYFkrYBe4HlksYl3VAWjUo6DBwCjgJ3NYVdDIxHxHPZes3MzMzMzOaLrq+QRcRtLb+PTjPfJmDTNGWPAhfNUMfzwPu7bZOZmZmZmc0DffhsV6/M+i2LPTNYvekaWlC9noGh6jGABjN15T4OZeJquYujPTtUkiPTp7aFkheKM9uwUU/WldgePbzyn9ruQCSOE6VqInV8Zfd3JfaNdF2TE51nmqW6UhYkh5fMHF/DC3tTD6BEeuaYnEzVxVT184YmplJVaVH146R2KnleS5yjhs7K1TU8UD1uwVTue2gocYDlaso5lYwbTpx9G8kbsRYk4iaV/LwSddUTdQ0l/64ZTK6XzS0z7oUqPC7piqZpqyXtlLRV0jFJYy0xKyXtlfS0pB2SlpTTr5N0oOnVKDMsIulRSV9rKlv6RqysmZmZmZlZP5mxQxYRAawDNkpaKGkE2ACsB+4GLm8TtgW4OSLOAx4AbiyX9dmIWBURq4Drgecj4kBT3HWnyyPi2I+7YmZmZmZmNkc0Gr179ZmO9yZExJikHcBNwAhwT0QcAY6UWRFbLQf2lO93A7uAW1vmGeX1qe/NzMzMzMzOON3eOHs78OvAFcAdHeYdA64q318NnNNmnmv40Q7ZXeXtirdKSj8mYmZmZmZmc0wfDQwt6fLycapvSLq5Tfk/k/RFSQfLR6/e2VT2byV9vXz9225WvasOWUQcB7YD90bEqx1mXwOsl/QksBh43RPnki4ETkRE87Nn15W3OP5i+bq+3YIlrZW0T9K+zzzylW6abmZmZmZm1hVJA8CfUVyIei/FkF7vbZntkxR3Da4Afg/4z2XsTwG/C1wIfBD4XUk/2anOKqllGnSREykiDkXEZRHxAYqrYEdaZrmWlqtjEfGt8ufLwH+jWIF2y94cERdExAU3/OovVGi6mZmZmZn1rWj07jWzDwLfiIjnImICuB/4SMs87wW+WL7/UlP5rwC7I+K7EfESxeNb7XJuvE56YOjpnM6QKKkG3ALc2VRWo7iN8f6maYOS3l6+HwL+FcVtj2ZmZmZmZr30DuCbTb+Pl9OaPQV8rHz/UWCxpLd1Gfsj0h0ySduAvcBySeOSbiiLRiUdBg4BR4G7msIuBsYj4rmmaQuAXZIOAgeAbwF/nm2XmZmZmZnNMT18hqz5MajytbapJe1yWbQ+ePabwIcl/R3wYYr+y1SXsT+i6xEgI+K2lt9Hp5lvE7BpmrJHgYtaph0HPtBtO8zMzMzMzLIiYjOweZricV6flPCdFBeZmuOPAr8GIOktwMci4vuSxoFLWmIf7dSerjtkfWdqqnJITJysHKOFI5VjACLq1etKjosQ9erbgkheHM3U1ai+LRjo3a4Zne8lbkuZbZFdr0wTawPJuhKfV5IS2yP7eZHYHNl0r5k2anBBrq4FC6vXlaopd15juHr70jJ1ZcejGRpOxAylqtKCRF3DuXONFlRvY21h4lwIxFT1bV8byn1egwPV44bqubqGonMGt1aN5FFZvSYYygQBQ4k2RvJGrMFE3ALl6hquVT9W6l1k6Ws1qNx38lAybi6K/hkf7Ang3ZJ+juLK17UU2eZfUz5u9d0ovvB/G9haFu0C/rApkcdlZfmMZv0ZMjMzMzMzs7koIqaAT1B0rr4KfC4inpH0e5JOD+11CfC18jGtnwY2lLHfBX6folP3BPB75bQZzfhvgXI8sC8DGyLir8ppqylS2x+lSMBxLCLe3xSzkiKRx1uA5ylS2v9A0nXAjU2LXwGcHxEHJA0Df1quXAP4nYj4750ab2ZmZmZm80DiyuMbJSIeAR5pmfafmt5/Hvj8NLFb+eEVs67MeIUsIgJYB2yUtFDSCEUPcD1wN+3TOG4Bbi7HFXuAshMWEZ+NiFURsYpinLHnI+JAGfM7FB27ZRRpJB+rshJmZmZmZmZzUccbZyNiTNIO4CZghGIQtCPAEUnntglZDuwp3++muNx3a8s8o7x+LLI1wHvK+hrAC92vgpmZmZmZzWl9dIWs17p9kvF2YD8wAVzQYd4x4CrgQYoxx85pM881lAOoSfqJctrvS7qEYiDpT0TEt7tsm5mZmZmZ2ZzUVVKPMjX9duDeiHi1w+xrgPWSngQWU3TiXiPpQuBERJwe/HmQIiXkVyLifIqxzT7ZbsHNYwZ8ZuffdNN0MzMzMzPrd9Ho3avPVMn12aCL5NsRcYgixSOSlgFXtsxyLa+/XfFF4ATF82YAfwHcQBvNYwacfPhTZ+51TTMzMzMzmxdmPe29pKXlzxpwC0XGRZqmXQ3cf3pamThkBz8cRO1S4NnZbpeZmZmZmVm/SXfIJG2juL1wuaRxSaevao2WOfkPUaTGv6sp7GJgPCKea1ncTcBtkg5SZGD8jWy7zMzMzMxsjmlE7159putbFiPitpbfR6eZbxOwaZqyR4GL2kz/e4rOWvd6df/nZKdH5qaRGTF+YChXV30yEdTDuhLbIk4dR2ctrl5XL+8LznzGvdSo5+JqA4m6clWlArPbvZf7RuZYrk/l6spsj1puGyrxP7xI1tWz42vhIpic6Dxfq4Hqx4kGE8cWEIm6Mu0D0GBiuw8qV1di36gN5o7jgVr1uAFyf7TVEmG1ZF2NxKYfiNznNUj1uMnsNlT1upRcr1pivTIxSwbO4pX6qcpxSmwLm3uqPENm1jOpzpiZWVWZzpiZWUWZztiZJvrwylWvzPjvKRUel3RF07TVknZK2irpmKSxlpiVkvZKelrSDklLyunXSTrQ9GpIWiVpccv0FyR96o1ZXTMzMzMzs/4xY4esTLixDtgoaaGkEWADsB64G7i8TdgW4OaIOI8ic+KN5bI+GxGrImIVxXNiz0fEgYh4+fT0suzvgS/M0vqZmZmZmVm/8zNk04uIMUk7KBJvjAD3RMQR4Iikc9uELAf2lO93A7uAW1vmGeX1qe8BkPRuYCnw5S7bb2ZmZmZmNmd1+wzZ7cB+ikGeL+gw7xhwFfAgRYr7c9rMcw3wkTbTR4Ht5ZU5MzMzMzM7EzT6b8DmXukqxVFEHAe2A/dGRKe0g2uA9ZKeBBZTdOJeI+lC4EREjLWJbR00+nUkrZW0T9K+z+zc203TzczMzMzM+laVLIsNushRHRGHgMsAJC0DrmyZpW2nS9JKYDAinpxh2ZuBzQAn/8dGX0UzMzMzM5sP+vDZrl6Z9bT3kpZGxDFJNeAW4M6mshrFbYztxhxr+1yZmZmZmZnZfJUeeVPSNmAvsFzSuKQbyqJRSYeBQ8BR4K6msIuB8Yh4rs0iV+MOmZmZmZnZmcdZFjuLiNtafh+dZr5NwKZpyh4FLpqm7F3dtsXMzMzMzGw+mPVbFnsmk4mll9lbYp5milH6omo1Pdx+6tU6AVGfSsVpoIeHambT1wZmvRnTyu4bmbDsds98ztm6Boaqxwxlt2Eirpf77tBw9Zjs/pSpK7sthhOf8WDymByq3kYNJ+tK/Jdaw7lz6OBA9c95sJbbN4Z6+N/3BqocM5xs3kCirsFEzFyoa0CZmNzfGgP5m9nmnDM5yfqMn7IKj0u6omnaakk7JW2VdEzSWEvMSkl7JT0taYekJeX06yQdaHo1JK0qy0bL+Q+Wy377G7GyZmZmZmZm/WTGDlk5Htg6YKOkhZJGgA3AeuBu4PI2YVuAmyPiPOAB4MZyWZ+NiFURsQq4Hng+Ig5IGqS4xfFfRsQK4CDwiVlZOzMzMzMz639n8DNkHa+DluOF7QBuAn4XuCcijkTEHuC7bUKWA3vK97uBj7WZpzmjosrXiCQBSyiSgZiZmZmZmc1r3d4sfjuwn2KQ5ws6zDsGXAU8SJHi/pw281wDfAQgIiYlfRx4GjgOfJ3iCpyZmZmZmdm81tWTghFxHNgO3BsRr3aYfQ2wXtKTwGKKTtxrJF0InCivvCFpCPg48PPAz1Lcsvjb7RYsaa2kfZL2fWbX33bTdDMzMzMz63dn8C2LVdIpNegiT1lEHAIuA5C0DLiyZZZref14Y6vKuCNlzOeAm6dZ9mZgM8DJhz7Zf1vTzMzMzMysglnPRyxpaUQcU5FL/BbgzqayGsVtjBc3hXwLeK+ksyPiO8AvA1+d7XaZmZmZmVl/ij68ctUr6cENJG0D9gLLJY1LuqEsGpV0GDhEkZzjrqawi4HxiHju9ISIOErxjNoeSQcprpj9YbZdZmZmZmZmc0XXV8gi4raW30enmW8TRRr7dmWPAhe1mX4nTVfSzMzMzMzsDHIGXyGb9VsWe+bUieoxA4nVHT6rekyyrpjqlC+lvdTY9NHxccD26lO5uIpiYiAXmPmMk5T8vDJicEHlGKW3RXLfyKhV/5zT65XZpbJ1JY6TqOVuWFCj+ucV2fXKnDcWLsrVperbQwuqn6/T2yJjInmOH0jsvMdPpurK/EFUm8x9L8RU9f1p4C2TqboWnFW9jRNTue+hhad6dw6NqP4XwGTi2AJYlKhrMHkj1gkltn3qjyE4pXousKJ6LdfZGM5sC5tzZjxSVHhc0hVN01ZL2ilpq6RjksZaYlZK2ivpaUk7JC0pp18n6UDTqyFpVVl2jaSDkp6RdMcbsaJmZmZmZtanGj189ZkZO2QREcA6YKOkhZJGgA0U44TdDVzeJmwLcHNEnAc8ANxYLuuzEbEqIlYB1wPPR8QBSW8D/hi4NCLeB/y0pEtnZ/XMzMzMzMz6V8d7NSJiTNIO4CZgBLinTFF/RNK5bUKWA3vK97uBXcCtLfOM8sPU9+8CDpcZFgH+GvgY8MXuV8PMzMzMzOaqMznLYrc3z98O7KcY5PmCDvOOAVcBD1KkuD+nzTzXAB8p338DeE/ZuRsH/g0w3GW7zMzMzMzM5qyunraMiOPAduDeiOj0VPIaYL2kJ4HFFJ2410i6EDgREWPlsl8CPl4u/8vA80Dbp28lrZW0T9K+z/z1vm6abmZmZmZm/a4RvXv1mSrppbp6DC4iDgGXAUhaBlzZMsu1/PB2xdMxO4AdZcxaoG3Km4jYDGwGOPm53+u/rWlmZmZmZlbBrOf7lbQ0Io5JqgG30DS+WDntaooBotvF/CTwH4DVs90uMzMzMzPrU32Y/bBXcgNEAJK2AXuB5ZLGJd1QFo1KOgwcAo4CdzWFXQyMR8RzLYvbJOlZ4CvAH0XE4Wy7zMzMzMzM5oqur5BFxG0tv49OM98mYNM0ZY8CF7WZ3nZZZmZmZmY2/znL4hwUL36n80wtNDlZvZ7KEaWpTrlPfpQGF6SqiqFEUsqB5Ec/NdF5ntmwYCQVltmG0ai+XwAwdFb1mOFEDKBETETy2r8SF86TdSmzHw4Mpeqi0fbR1Jll7yFIfM6q5/bDGGqbA2nmurL7RsbC3LGcMlj9XJg5tgCiXn27M5w7x9NIfF4jyXNNvfpxEgtyx6QGqq+XFg6k6hoYrF7XYKJ9AAsSfzlkj8jM3yhDyT9sFiTiQrkjbDhxZNaTJ+yzVP17SIn1qif/ohzMfCfbnONP2czMzMzM7E0yY4dMhcclXdE0bbWknZK2SjomaawlZqWkvZKelrRD0pJy+pCk/1pO/6qk326KuVzS1yR9Q9LNs72SZmZmZmbWxxo9fPWZGTtkERHAOmCjpIWSRoANwHrgbuDyNmFbgJsj4jzgAeDGcvrVwIJy+geA/1vSuZIGgD8DrgDeS5EU5L0/9pqZmZmZmZn1uY43zkbEmKQdwE3ACHBPRBwBjkg6t03IcmBP+X43sAu4leJW5xFJg8BZFANG/wD4IPCN05kXJd0PfAR4Nr9aZmZmZmY2VzipR2e3A/spOlEXdJh3DLgKeJDiqtg55fTPU3S0/hFYBPx/EfFdSe8AvtkUPw5c2GW7zMzMzMzM5qyuknpExHFgO3BvRHRKH7gGWC/pSWAxRScOiithdeBngZ8DfkPSu2if5KptF1nSWkn7JO3b+vhYu1nMzMzMzGyuOYOfIauS67OrVYiIQ8BlAJKWAVeWRb8O7IyISeCYpK9QXG37Jj+8igbwTooBpdstezOwGeDEp/+fM/e6ppmZmZmZzQuznvZe0tLyZw24BbizLPoH4JfKzI0jFANEHwKeAN4t6eckDQPXAg/NdrvMzOz/Z+/+4+yq7/vOv97zWxKSTeIoDzumBadBDmtV2NKybLNJqb1QFFJI6kWbofE2KxZMonQTSgnyo1BEW/rosjZB6XrDQ8UaDG1kEmIetraOCPU6VQElZlAtNCBFWC7GMmwmCSFYQtL8uJ/943wVpuM7c+/5IN/emXk/9bgP3fu953O+33PuOefe75xzPl8zM7PuFI3OPbpNukMmaRewD1gj6Zik68tbw5KOUHW2XgFGSvmngXOo7jF7BhiJiOciYgr4JarkH4eA34qI57PtMjMzMzMzWyjavmQxIrbNej08x3Tbge1Nyo9TJfloFvMl4EvttgVA/f11Jq/01R+NPRUDqG+wflDPAhinOzNifOZPEadPwMCy+lXFdP26MssEMD2ViJnM1dWb2A57c1WlPq/sX5sybWwkPmOAnkRlyeVS4vOK5P7f7CbclnVltieARmKFTLW67fjsSR13gUjsl0ocN2JyovVEzfQP1A5Rsq7MvQDZb66Yqr8v90wmjrvAsnPfSMVlnJpI7l8JEfWPAH1Tid9PwKmp+tvh6eTGkTmGHlfugN2v+uvwTepvu9/XO8CJqL/99p39i9m6VxeeueqUJfQp24KS6IyZmdWV6YyZmdWV6YzZ0jFvh6zc7/WkpI0zyjZJ2iNpp6RxSWOzYtZJ2ifpoKTdklaV8n5Jny3lhyR9YkZM03mZmZmZmdni53vI5hARAdwE3CtpqCTjuBvYAjwIXNkk7AFga0SsBR4Dbi3l1wKDpXw98PEZA0vPNS8zMzMzM7NFq+VFuhExJmk3cBuwAngoIo4CR2d0qGZaA+wtz5+gStZxB9Wl6Ssk9QHLqMYne6PUsXeOeZmZmZmZ2WLXhWeuOqXduybvAvZTdaI2tJh2DLga+ALVWbEzY4w9ClwDvAosB26OiNfqNtjMzMzMzGyxaCupR0ScAB4BHo6IVimzNgNbJD0LrKTqxAFcAkwD7wEuAG6R9L46jZV0o6RRSaOf2ftcnVAzMzMzM+tSS/kesjp5RRu0cTIxIg4DVwBIuhC4qrx1HbAnIiaBcUlPUZ1t+0a7DYiIHcAOgJMP/MNMdl4zMzMzM7OucdbT3ktaXf7vAW4H7i9vvQx8uGRuXAFcSjV4tJmZmZmZ2ZKU7pBJ2gXsA9ZIOibp+vLWsKQjVJ2tV4CRUv5p4Byqe8yeAUYi4rkW8zIzMzMzs0XOlyy2ISK2zXo9PMd024HtTcqPUyX5aBbTdF5mZmZmZmaLWZ17yLpKnDxVO0b9A/UrOvVm/Rgg+hJ19SY/junJ2iHqH0xVFZOtcrqcHdUVrwmZddjI/akkeurHaaL1NE3rSsQoV1VOdtvNxGXP62c+5p7eXF3TU7VDstt8JNqo5OcV1F+utMz6yCxX4viZrqsnufFm1kW2rsxy9Sb3k8SxV3255Uqtwr7cd0NvT/0jdmTvilf9wL5EDEBv4puoJ3LfRJlPuS9Zl1Q/Th38hu1JtG+h6sYzV50y7zZf7vd6UtLGGWWbJO2RtFPSuKSxWTHrJO2TdFDSbkmrSnm/pHafqDkAACAASURBVM+W8kOSPlHKz5P0lVL2vKRf/l4sqJmZmZmZWbeZt0MWEQHcBNwraagk47gb2AI8CFzZJOwBYGtErAUeA24t5dcCg6V8PfDxMhj0FHBLRPwoVaKPLZIuepvLZWZmZmZmC0Woc48u0/LahIgYk7QbuA1YATwUEUeBo6VDNdsaYG95/gTwOHAH1VVXKyT1Acuoxid7owwO/Wqp6zuSDgE/BLzwNpbLzMzMzMys67V7sfhdwH6qTtSGFtOOAVcDX6A6K3ZeKX8UuIaq87UcuLl0xv5S6eB9EPjDNttlZmZmZmYLnO8hayEiTgCPAA9HRKusDpupLjt8FlhJ1YkDuASYBt4DXADcIul9Z4IknQP8DvArEfFGsxlLulHSqKTRnU/5BJqZmZmZmS1sddIpNWgjT1lEHAauAJB0IXBVees6YE9ETALjkp6iOtv2DUn9VJ2xfxsRn59n3juAHQBv/qtfzOYkMjMzMzOzLhKN7ru3q1PSA0PPRdLq8n8PcDtwf3nrZeDDJXPjCqoEHodV5Rv9DHAoIu492+0xMzMzMzPrVukOmaRdwD5gjaRjkq4vbw1LOgIcBl4BRkr5p4FzqO4xewYYiYjngB8DPkbVWftaefxktl1mZmZmZrawRKNzj27T9iWLEbFt1uvhOabbDmxvUn6cKsnH7PIn6fAYtmZmZmZmZt2gzj1kXSX+5LXWE802OVk7JN1TbHSw+91b/2OM/oFcXZMTraf5rsrqr4tYdk79egBOfqd+zPRUrq6Bofox53xfqir11D+ZHdk/AfX214/JrsNM3MCyVFVK7Cfp5eofrB/TmM7Vlfmck3Wl1uHyd6bqSlH9/USJGKjGcald1znn5urqTRzXkvu/Mt8NPclvyqnEdtjI3T4+sLpprrB59fTl9v+p0ydrx0RyXKTp6fpxfSdz28bpk/X3lVPJ/auX3toxbya3w+U99Y9rpxLtO67cT+7eJXTOIrsfLAbz7inlfq8nJW2cUbZJ0h5JOyWNSxqbFbNO0j5JByXtlrSqlPdL+mwpPyTpE6V8SNJXJR2Q9Lyku74XC2pmZmZmZtZt5u2QRUQANwH3lo7TCuBuYAvwIHBlk7AHgK0RsRZ4DLi1lF8LDJby9cDHy7hjp4EPR8Q64GLgSkmXvs3lMjMzMzOzBcL3kM0jIsYk7QZuA1YAD0XEUeBo6VDNtgbYW54/ATwO3EF1hccKSX3AMqrxyd4onb7jZfr+8nBKezMzMzMzW/Tavbj3LqpxxDYC97SYdgy4ujy/FjivPH8UOAG8SpUC/5MR8RqApF5JXwPGgSci4g/bXgIzMzMzM7MFqq0OWUScAB4BHo6I0y0m3wxskfQssJLqTBjAJcA08B7gAuAWSe8r85+OiIuB9wKXSPpAsxlLulHSqKTRnfuPttN0MzMzMzPrctFQxx7dpk76m0Z5zCsiDkfEFRGxHtgFnOk5XQfsiYjJiBgHngI2zIp9Hfh9mt+bRkTsiIgNEbFh84d+uEbTzczMzMzMuk96YOi5SFpd/u8BbgfuL2+9TDX4s0pykEuBw5J+QNI7S8wy4H+kGlTazMzMzMyWgIjOPbpNukMmaRewD1gj6Zik68tbw5KOUHWqXgFGSvmngXOo7jF7BhiJiOeAdwNfkfRcKX8iIv6fbLvMzMzMzMwWirZHqYuIbbNeD88x3XZge5Py41RJPmaXPwd8sN12mJmZmZnZ4tKN93Z1Sm7Y8IWqkThH2UgOVtDJQQ6mp+rH9CRPjmbqyqyLyYnW0zSTWa7MMkGujRMnU1Vlzq6rbzBVV2p99OYOJZH4vDQ92bm6lNxPGtP1Y3p6U1Upse7TV2skjofKHkMzMutiKvcZK3Fci+SxJvMTJVtXSvIzVqaNk7n9v/fcoUTUqVRdy0/W/27I/hBtTNeP6+vLfV4TU/WPUaenct8NPYlNY1nyd01/b/11eFL1YwaSx/i+Lry8zs6+pdUhMzMzMzOzrrOUz5DN++eEkoDjSUkbZ5RtkrRH0k5J45LGZsWsk7RP0kFJuyWtKuX9kj5byg9J+sSsuF5J/0mS7x8zMzMzM7MlYd4OWUQEcBNwr6Shkh3xbmAL8CDN09M/AGyNiLXAY8CtpfxaYLCUrwc+Lun8GXG/DBxKL4mZmZmZmS1I3ZRlUdKVkv5I0tclbW3y/l+R9JVyMuk5ST/Z5P3jkv5RO8ve8oLbiBgDdgO3AXcCD0XE0YjYC7zWJGQNsLc8fwL46JlZASsk9QHLqAaMfqM0+r3AVVSdOTMzMzMzs46T1EuVHX4jcBFVBvmLZk12O/BbEfFB4GeB/3vW+78G/G67dbZ7D9ldwH6qTtSGFtOOAVcDX6A6K3ZeKX8UuAZ4FVgO3BwRZzp09wG/Cqxst+FmZmZmZrY4dNE9ZJcAX4+IbwBI+hxVH+aFGdMEsKo8fwfVUF+U6X8a+AZwot0K20pJExEngEeAhyPidIvJNwNbJD1L1cE6k27oEmAaeA9wAXCLpPdJ+ilgPCKebdUOSTdKGpU0unP/0XaabmZmZmZm1q4fAr414/WxUjbTNuDnJB0DvgT8A4Bye9dtVCez2lYnR2ijPOYVEYcj4oqIWA/sAs70nK4D9kTEZESMA09RnW37MeBqSS8BnwM+LOnfzDHvHRGxISI2bP7QD9doupmZmZmZdasIdewx8yRPedw4oynNTtXNvvNsGHgwIt4L/CTwsKqxcu4Cfq2Mv9y2s572XtLqiBgvjboduL+89TJvdbaWA5cC90XEbwGfKLGXAf8oIn7ubLfLzMzMzMwsInYAO+Z4+xhv3XIF8F5mXJJYXE9JbhgR+yQNAe8C/jvgf5J0D/BOoCHpVET8X/O1JznqKUjaBewD1kg6Jun68tawpCPA4dL4kVL+aeAcqnvMngFGIuK5bP1mZmZmZrY4RKNzjxaeAX5E0gWSBqiSdnxx1jQvAx8BkPSjwBDwJxHx4xFxfkScT5Uj41+06oxBjTNkEbFt1uvhOabbDmxvUn6cKsnHfHX8PvD7bbVncrKdyf4Lmp6uHUMjN6J9Ki7TvnRdUx2sK7Fcp09Df3/9uDb2su+S/YwnJ1pPM0sbmVabUqauwaFkZYm/0/QmPitAiXUf/bltN3OrcPT0purKbIfqTV6wkFj3ynzGkFqu7Daf0lN/udQ/CBMna8dF32D9uvrq78cAkTmu9Q2k6mIgUddQbrky30NaVv+zAtCK+sfDnuncd0P/G6dqx0Qjt6dE4nAo5eo653T9z3lgIve7plF/FdLfyF70Vf84399T/xtlVQPeSBx6z/qlbNZSRExJ+iXgcaoNZGdEPC/pnwKjEfFF4BbgX0u6meqr7ufLcGEp/pytO2U6Y2ZmdSU6Y2ZmdWU6Y/ZfT0R8iSpZx8yyfzLj+QtUeTDmm8e2duubd/NQ5UlJG2eUbZK0R9JOSeOSxmbFrJO0T9JBSbslrSrl/ZI+W8oPSfrEjJiXSvnXJI2223gzMzMzM1v4GqGOPbrNvB2ycurtJuBeSUMllePdwBbgQcrNbLM8AGyNiLXAY8CtpfxaYLCUrwc+Lun8GXF/KyIujohW45yZmZmZmZktCi0vWYyIMUm7qXLqrwAeioijwNFZHaoz1gB7y/MnqK6/vIPq+soVkvqAZVTjk73xdhfAzMzMzMwWtujCM1ed0u4VrXdRjSO2EbinxbRjwNXl+bW8lTbyUaoRq1+lykzyyYh4rbwXwO9JenbWOABmZmZmZmaLVlsdsog4ATwCPBwRp1tMvhnYIulZYCXVmTCAS4Bp4D3ABcAtkt5X3vuxiPgQVYdvi6SfaDbjmYO47fzaf26n6WZmZmZm1uWioY49uk2dnC+N8phXRByOiCsiYj2wCzha3roO2BMRkxExDjwFbCgxr5T/x6nuO7tkjnnviIgNEbFh88UX1Gi6mZmZmZlZ9znrSTglrS7/9wC3A/eXt14GPlwyN64ALgUOS1ohaWWJWQFcQXXZo5mZmZmZLQERnXt0m3SHTNIuYB+wRtIxSdeXt4YlHQEOA68AI6X808A5VJ2tZ4CRiHgO+EHgSUkHgK8C/y4i9mTbZWZmZmZmtlC0PTD07MHNImJ4jum2A9ublB+nSvIxu/wbwLp222FmZmZmZotLN97b1Sltd8i6jfr76wf1JD7oaHnbXHONRFwmBmB6qn5MT/LkaKeWa3KyfgxAf2JdpNd7IkZvpqrKnF1PH9Yy20Z/bh1Gb/1DkJL7ZKquRAwAjfobR/YKiurq8Jp6epO1JeImJ1pP00xiO8ysi+gbrB2Trms6d1xLbYfJuuivvz4i+32S+e5KHq97Vp9bO0ZDid8ZAI3E3pyJASIR1/dGYr0D6jlZO2bqdG7b6H+9/jH09ETueL3s9EDtmJNT9es6J3OsBvrT3w62kMy7dZT7vZ6UtHFG2SZJeyTtlDQuaWxWzDpJ+yQdlLRb0qpS3i/ps6X8kKRPzIh5p6RHJR0u7/33Z3tBzczMzMysOzVCHXt0m3k7ZBERwE3AvZKGStKNu4EtwIPAlU3CHgC2RsRaqoyJt5bya4HBUr4e+PiMgaW3U2VgfD/V5YuH3sYymZmZmZmZLQgtz7lGxJik3cBtwArgoYg4Chyd0aGaaQ2wtzx/AngcuIPqipwVkvqAZVTjk71RzqD9BPDzpb4J3hq7zMzMzMzMFrnowjNXndLuBa13UY0jthG4p8W0Y8DV5fm1wHnl+aPACeBVqhT4n4yI14D3AX8CjEj6T5IeKGfizMzMzMzMFrW2OmQRcQJ4BHg4Ik63mHwzsEXSs8BK3jrbdQlVGoT3ABcAt0h6H9VZug8BvxERH6TqtG1tNmNJN0oalTS6c//RZpOYmZmZmdkC43HI2tMoj3lFxOGIuCIi1gO7gDM9p+uo7hObjIhx4ClgA3AMOBYRf1ime5Sqg9Zs3jsiYkNEbNj8oR+u0XQzMzMzM7Pukx4Yei6SVpf/e4DbgfvLWy8DHy6ZG1cAlwKHI+L/A74laU2Z7iPAC2e7XWZmZmZmZt0m3SGTtAvYB6yRdEzS9eWtYUlHgMPAK8BIKf80cA7VPWbPACMR8Vx57x8A/1bSc8DFwL/ItsvMzMzMzBaWpZz2vu2R7SJi26zXw3NMt50qjf3s8uNUST6axXyN6vJFMzMzMzOzJSM3rHk3iJa3s52lanJ3/mm6/ijzTE+l6qKRWBeZmGxc5rPKfryZdZhdFz1n/YrfsyoisQ0Cypw4z67DDu3HQKqNQW6fVG/i0NrRddibqyshtS6gc/tXJOuJxDrsH8zVldHXwbomB3JxSqz7waFcXQOJNg7mlkuDmf0/+VsjE7c8V1ffsvrHQ/Xk6ho4mfv+ypicqr8vx3T9MyxTyUQSC/eHen1Oez+Hcr/Xk5I2zijbJGmPpJ2SxiWNzYpZJ2mfpIOSdpdxxpDUL+mzpfyQpE+U8jWSvjbj8YakX/leLKyZmZmZmVk3mbdDFhEB3ATcK2moJOO4G9gCPAhc2STsAWBrRKwFHgNuLeXXAoOlfD3wcUnnR8QfRcTFEXFxKX+zxJmZmZmZ2RKwlNPetzwTGhFjknYDtwErgIci4ihwVNL5TULWAHvL8yeAx4E7gABWSOoDllGNT/bGrNiPAEcj4pv1F8XMzMzMzGxhaffS1LuA/VSdqFbJN8aAq4EvUJ0VO6+UPwpcA7wKLAdujojXZsX+LNXYZWZmZmZmtkR0Y/bDTmnrjtqIOAE8AjwcEadbTL4Z2CLpWWAlVScO4BJgGngPcAFwi6T3nQmSNEDVkfvtuWYs6UZJo5JGd+7/RjtNNzMzMzMz61p1krc0aCP3XUQcBq4AkHQhcFV56zpgT0RMAuOSnqI623amZ7UR2B8RfzzPvHcAOwBO3LGpC68ANTMzMzOzupxl8SyStLr83wPcDtxf3noZ+HDJ3LgCuJRq8OgzhvHlimZmZmZmtoSkO2SSdgH7gDWSjkm6vrw1LOkIVWfrFWCklH8aOIfqHrNngJGIeK7MazlwOfD5bHvMzMzMzGxhaoQ69ug2bV+yGBHbZr0enmO67cD2JuXHqZJ8NIt5E/j+dttiZmZmZma2GCzYAcCnXv6z2jE973izfszJVjlM5nDyZO2QeLN+TJYGB3KB09O1Q2Kqfoz6emvHADCQWK7EMgHQ3187RN+X/LvD4PH6MQNDqaqiJ3HivDd5KBlanohZkatrKrkvZyx/Z+0QNVreottU6mbayYnW0zShzOfcP5iqi0Ziv4z667C6uj5RVSJOA8tydSW2DS1/R66u0yfq15WqCUgsVyQ+YwC9s/4+SV/uuNbTSOyVyf0/8/2l5adSVQ301f8NFady3699y+q3cepkbktcfrz+8XDyVP3fKCdP5n53SUsnZcLSWdLvdtbvITMzMzMzM7P2zNshKwk4npS0cUbZJkl7JO2UNC5pbFbMOkn7JB2UtFvSqlLeL+mzpfyQpE/MiLlZ0vOSxiTtkpT7076ZmZmZmS04S/kesnk7ZBERwE3AvZKGSnbEu4EtwIPAlU3CHgC2RsRa4DHg1lJ+LTBYytcDH5d0vqQfAv53YENEfADopRog2szMzMzMbFFreYF0RIxJ2g3cBqwAHoqIo8BRSec3CVkD7C3PnwAeB+6gujR0haQ+YBnVgNFvlOd9wDJJk8ByquyMZmZmZma2BCzlccjavWP1LmA/VSdqQ4tpx4CrgS9QnRU7r5Q/ClwDvErV6bo5Il4DkPRJqnHKTgK/FxG/V2MZzMzMzMzMFqS2knpExAngEeDhiGiVqmwzsEXSs8BKqk4cwCXANPAe4ALgFknvk3QuVUftgvLeCkk/12zGkm6UNCpp9MEj326n6WZmZmZmZl2rTk7XRnnMKyIOA1cASLoQuKq8dR2wJyImgXFJT1GdbQvgP0fEn5SYzwN/A/g3Tea9A9gB8Bd//yNLOTummZmZmdmikRz8YVE462nvJa0u//cAtwP3l7deBj5cMjeuAC4FDpfySyUtlyTgI8Chs90uMzMzMzOzbpPukEnaBewD1kg6Jun68tawpCNUna1XgJFS/mngHKp7zJ4BRiLiuYj4Q6r7y/YDB0ubdmTbZWZmZmZmC0ugjj26TduXLEbEtlmvh+eYbjuwvUn5caokH81i7gTubLctABqoP0p6JobeRAxAX52rQSvq78/VFYmTvNnl6qnfh69OlmbqSuwwifWeWaaqruQ6zMi2MSP7eXV7XRnd3r6s7PaUiWtMJ+tK7F/TiWNhdl1EIi7TPsi1cSpXl1R/vUd6P0m0cSHsk43EcjWSd2Fk4zpVV3KTb0zVj4lG7kd2Y7p+3HSj/nY4MDjFm28O1I7r7VnKF/ItHYlfr2YdkOmMmZmZmXWhTGdsqenk3xe6zbxd/HK/15OSNs4o2yRpj6SdksYljc2KWSdpn6SDknZLWlXK+yV9tpQfkvSJGTG/LGlM0vOSfuVsL6SZmZmZmVk3mrdDFhEB3ATcK2moJOO4G9gCPAhc2STsAWBrRKwFHgNuLeXXAoOlfD3wcUnnS/oAcANVWvx1wE9J+pG3vWRmZmZmZrYgNFDHHt2m5UWwETEG7AZuo7rP66GIOBoRe4HXmoSsAfaW508AHz0zK6oxxvqAZVTjk70B/CjwBxHxZkRMAf8B+Jn8IpmZmZmZmS0M7d5DdhdVFsQJqrHD5jMGXA18geqs2Hml/FGqAaBfBZYDN0fEa+WSx7slfT9wEvhJYLTOQpiZmZmZ2cLVjdkPO6WtNDERcQJ4BHg4Ik63mHwzsEXSs8BKqk4cVJckTgPvAS4AbpH0vog4BPwfVGfT9gAHgKb5dSTdKGlU0ujI4WPtNN3MzMzMzKxr1cnb2aCNBKYRcTgiroiI9cAu4Gh56zpgT0RMRsQ48BTlbFtEfCYiPhQRP0F1GeSLc8x7R0RsiIgN/+v731uj6WZmZmZm1q0aHXx0m7M+oIek1eX/HuB24P7y1svAh0vmxhXApVSDR8+M+SvA36XqyJmZmZmZmS1q6Q6ZpF3APmCNpGOSri9vDUs6QtXZegUYKeWfBs6husfsGWAkIp4r7/2OpBeokodsiYg/z7bLzMzMzMwWlkAde3SbtgeGjohts14PzzHddmB7k/LjVEk+msX8eLvtMDMzMzMzWyza7pB1G60YrB+zLBEzmBxZvb+/fkxPsseeGdo80z6ARuLK2+jc1bpavqJ+0FTTHDKt9SROMA/W3wYBGBjqTExWf24/0eCy+kF9ybr6Euu+N3mIVGLbyNaV2A6VaV9Wdv+fTsT1Jo5rjen6MeTWYeJI3fG6InLro2M6+H2yIGR/NyxC2U0jGl6H3WIp793zHuXL/V5PSto4o2yTpD2SdkoaL2nrZ8ask7RP0kFJuyWtKuUDkkZK+QFJl82IWV/Kvy7p1yV57zAzMzMzs0Vv3g5ZRARwE3CvpKGSjONuYAvwIHBlk7AHgK0RsRZ4DLi1lN9Q5rkWuBz4lN76s99vADcCP1IezeZrZmZmZma2qLS8DiIixqiSbdwG3Ak8FBFHI2IvVYr62dYAe8vzJ4CPlucXAV8u8xwHXgc2SHo3sCoi9pUO4EPAT+cXyczMzMzMFpKlnPa+3ZsW7gL2Uw3yvKHFtGPA1cAXqJJ4nFfKDwDXSPpcKVtf/m8AM0d5Pgb8UJvtMjMzMzMzW7DaulM4Ik4AjwAPR8TpFpNvBrZIehZYSdWJA9hJ1dkaBe4DngamoGnuyab3I0u6UdKopNGRg99sp+lmZmZmZtblnPa+PW2d5YuIw8AVAJIuBK4q5VPAzWemk/Q08CLw58B7Z8zivVTjlzWb9w5gB8B3fuXvZJNImZmZmZmZdYWznvtY0uryfw9wO3B/eb28JAVB0uXAVES8EBGvAt+RdGnJrvi/UF3uaGZmZmZmS0BDnXt0m3SHTNIuYB+wRtIxSdeXt4YlHQEOU53pGinlq4H9kg5RJQj52IzZ/QJVdsavA0eB3822y8zMzMzMbKFo+5LFiNg26/XwHNNtB7Y3KX+JKgNjs5hR4APttsXMzMzMzBaPRhfe29Upde4h6y4TU7VD4tRk/XqGJlpP04ROnqwfND2dqotG4na6RjLpZyYus1w9uZO3oURcdr339tYOUX9iu4Dc+sh+xr2Jw0Lk6opEXdnDdUwn9v9MDKDEdhhTuW1eiXUffYOpuoj6bcysCyC5zWeONfX347TkftLJujL7V/qG7un63+MazH0nx0D9bV5D9dsHwLKh2iGR/k6uv/azx9CeN+uv++jLfb/2TdSvq6cv+T0U9T/n3tOd25d7e7oxSbudbQu3Q2ZmZmZmZovCUs7WN++fIFV5UtLGGWWbJO2RtFPSuKSxWTHrJO2TdFDSbkmrSvmApJFSfkDSZTNi7pb0LUnHz/LymZmZmZmZda15O2QREcBNwL2ShkqWxLuBLcCDwJVNwh4AtkbEWuAx4NZSfkOZ51rgcuBTeutalt3AJW9vUczMzMzMbCFqdPDRbVpepB8RY1QdptuAO4GHIuJoROwFXmsSsgbYW54/AXy0PL8I+HKZ5zjwOrChvP6Dkv7ezMzMzMxsyWj3HrK7gP3ABKUTNY8x4GqqscSuBc4r5QeAayR9rpStL/9/tWabzczMzMxsEWlo6WZZbCuNVUScAB4BHo6I0y0m3wxskfQssJKqEwewEzgGjAL3AU8DtVLbSLpR0qik0ZEXvlUn1MzMzMzMrOvUybLY1mWXEXEYuAJA0oXAVaV8Crj5zHSSngZerNPYiNgB7AD4zi9uXMrJWMzMzMzMFo2l/MM+OUDM3CStLv/3ALcD95fXy0tSECRdDkxFxAtnu34zMzMzM7OFIt0hk7QL2AeskXRM0vXlrWFJR4DDwCvASClfDeyXdIgqQcjHZszrHknHgOVlXtuy7TIzMzMzM1so2r5kMSK2zXo9PMd024HtTcpfosrA2CzmV4FfbbctADGZGP399GTtEJ06Vb8egL7e2iExlRvRnun6cUrEAEQjkSy0kTgJHbmkpKnbQbPrvad+bdnT8cqs9/6BXGW99bfddF0JMV3r1tO/9NYoGzX01rmq+y2Zz1nJbT76BuvXlVkXAJE4rqXrqh+XXq6MnvrrItu+aCSOUZOtbveeK26i9TSzJbddJk7WryoRk9aX2/8z3w3K/n28L/E9dDpbVyJuOrdt9Czv3G8oqf4Ru6e3fkymHoDe/m5M0v69sXSW9Lt18NvLzMzMzMzMZpq3Q6bKk5I2zijbJGmPpJ2SxiWNzYpZJ2mfpIOSdktaVcoHJI2U8gOSLivlyyX9O0mHJT0v6V9+D5bTzMzMzMy6VEOde3SbeTtkERHATcC9koZKUo67gS3Ag8CVTcIeALZGxFrgMeDWUn5Dmeda4HLgU3rr+o1PRsT7gQ8CPzazA2hmZmZmZrZYtbxAOiLGJO2mSsSxAngoIo4CRyWd3yRkDbC3PH8CeBy4A7gI+HKZ57ik14ENEfFV4CulfELSfuC9b2ehzMzMzMxs4WjkMgEsCu3eQ3YXcB2wEbinxbRjwNXl+bXAeeX5AeAaSX2SLgDWz3gPAEnvBP4OpeNmZmZmZma2mLXVIYuIE8AjwMMR0Sp102Zgi6RngZXAmZRNO4FjwChwH/A08Jfp0iT1AbuAX4+IbzSbsaQbJY1KGh05fKydppuZmZmZWZeLDj66TZ2crg3ayEgZEYeBKwAkXQhcVcqngJvPTCfpaeDFGaE7gBcj4r555r2jTMcbN1zRjevTzMzMzMysbclBNuYmaXW5R6wHuB24v5QvBxQRJyRdDkxFxAvlvX8OvAP43852e8zMzMzMrLt1Y/bDTkmPQyZpF7APWCPpmKTry1vDko4Ah4FXgJFSvhrYL+kQVYKQj5X5vBf4x1RJP/ZL+pokd8zMzMzMzGzRa/sMWURsm/V6eI7ptgPbm5S/RJWBcXb5MaifVmXqT1vdyvbdepZPtZ5otolEDKBTk7VjYjJXF43EiPGD/bm6ov446jHVubHXM/N/bgAAIABJREFUdeJk/aDketfgQP2Y6elUXTFZf3uiP/cZq6+3flBv8mT7RP39mIHBVFUxOdF6otl6cn+z0jnn1o6J6eR22Fd/uWI6sT0B9Ndf9xpYlqtrOnGsydQzNZHaft8ataWGxPoDUGY7TNbFZP19UsltN5Yn9sllK3N1ZY5Rp99M1aWhxDbf6OD35JsncnHf9536QacTnzEQJ0/Vjuk7mfg+AQb+ov7nHJP1v8vfwTSN44l9pW/pnDbq3F7QfdJnyMzMzBa87B8TzMxqSHXG7L8aSVdK+iNJX5e0tcn7v1au6vuapCNlOK8z790j6XlJhyT9uqSWvep5O2SqPDlzoGZJmyTtkbRT0riksVkx6yTtk3RQ0m5Jq0r5gKSRUn5A0mUzYvaUsucl3S8p8Sd6MzMzMzNbiLoly2Lph3yaarivi6hux7rov2hrxM0RcXFEXAz8K+DzJfZvAD8G/HXgA8B/C/zNVss+b4csIgK4CbhX0pCkFcDdwBbgQeDKJmEPAFsjYi3wGHBrKb+hzHMtcDnwKb11zcemiFhXGv4DVOOXmZmZmZmZddIlwNcj4hsRMQF8DrhmnumHqYbugqq/NwQMAINAP/DHrSpsecliRIwBu6kScdwJPBQRRyNiL/Bak5A1wN7y/Ango+X5RZQBnyNiHHgd2FBev1Gm6SsL4JT2ZmZmZmZLREOde7TwQ8C3Zrw+Vsq+i6S/ClwA/L8AEbEP+Arwank8HhGHWlXY7j1kdwHXUZ26u6fFtGPA1eX5tcB55fkB4BpJfZIuANbPeA9JjwPjwHeAR9tsl5mZmZmZWdsk3ShpdMbjxplvNwmZ62TRzwKPRsR0me9fA34UeC9VJ+7Dkn6iVXva6pBFxAngEeDhiGiVxmYzsEXSs8BK4EyKnZ1UPcxR4D7gaeAv73CMiL8NvJvq9N6Hm8145sr77EuvttN0MzMzMzOzvxQROyJiw4zHjhlvH2PGSSOqztUrc8zqZ3nrckWAnwH+ICKOR8Rx4HeBS1u1p06WxQZtZKSMiMMRcUVErC8NPFrKp2bcAHcN8E7gxVmxp4AvMsd1mjNX3t8//901mm5mZmZmZt2q0cFHC88APyLpAkkDVJ2uL86eSNIa4FyqcZnPeBn4m+WKwH6qhB5n7ZLFtklaXf7vAW4H7i+vl5ekIEi6HJiKiBcknSPp3aW8D/hJqkGlzczMzMzMOiYipoBfAh6n6kz9VkQ8L+mfSrp6xqTDwOdKEsQzHqU6GXWQ6natAxGxu1Wd6QFYJO0CLgPeJekYcGdEfIYqNeSWMtnngZHyfDXwuKQG8G3gY6V8BfBFSYNAL9VNcfdn22VmZmZmZgtLNw0MHRFfAr40q+yfzHq9rUncNPDxuvW13SGbXWlEDM8x3XZge5Pyl6gyMM4u/2OqHP1mZmZmZmZLSvoM2YI0VT+bfkwn++uTiRHZJ3KjuKfa2NM652dTjcSIBI367YvTuXWhvvpX4cbEdKouGq3y2zSRXe9T9duowYFUVdGbGJd9oD9VlzJ1JbYnAPoT60O5q7qj9zv1q0rVBBH114d6O3foj+zn1VN/3Sv5eWVEI7FPJpYJgN76+5ey631gWe2QmE4er7PrI+P0ifoxifUOEFOJ9ZHYj4Hc8bA/ebxOfF5xOvE9Cag/cYxKfudlvpeV+I2n/ty6YGDp/FSP7BfhIjDv3qXKk5I2zijbJGmPpJ2SxiWNzYpZJ2mfpIOSdktaVcoHJI2U8gOSLmtS3xdnz8/MzMzMzGyxmrdDVm5Suwm4V9JQScpxN7AFeBC4sknYA8DWiFgLPAbcWspvKPNcC1wOfEoz/pwp6e8Cx9/W0piZmZmZ2YLTRVkWO67l+eeIGAN2A7cBdwIPRcTRiNgLvNYkZA2wtzx/AvhoeX4R8OUyz3HgdWADgKRzgH8I/PP0kpiZmZmZmS0w7V6Yehewn2qQ5w0tph0Drga+AFzLWwOrHQCukfS5Ura+/P9V4J8BnwLerNN4MzMzMzNb+LrxzFWntHWHZkScAB4BHo6IVnclbga2SHoWWEnViQPYSTXy9ShwH/A0MCXpYuCvRcRjrdoh6UZJo5JGP/vSq+003czMzMzMrGvVSd3S1mWXEXEYuAJA0oXAVaV8Crj5zHSSngZepBrBer2kl0p7Vkv6/Yi4rMm8dwA7AF77mb+ZSPdnZmZmZmbdZin/sD/rOWclrS7/9wC3UwZ5lrS8JAVB0uXAVES8EBG/ERHviYjzgf8BONKsM2ZmZmZmZrbYpDtkknYB+4A1ko5Jur68NSzpCHAYeAUYKeWrgf2SDlElCPlYvtlmZmZmZrZYNNS5R7dp+5LFiNg26/XwHNNtB7Y3KX+JKgPjfHW8BHyg3TaZmZmZmZktZAt2+O/j36rf9P6h+vlb+t/Ijazeu3yi9USzNCaSV88m0tL0DOWWKxr12xj1B7RPxQD0vp5Y76dy6713ef0TzL3vztWlicQKGUju3r299WP6EjEAJ07Wj1mxLFWVJutvG/QkLyKI+jtlTCc3+r6B+jHTk8m6BmuHaPk7cnVNJdZhpp7EZwXAZOIY2l9//QGokWhjsq7MtqHkT4lI7F/pP2wPraodEr39ubpiun5M5jOG3PY7cSpXV+bzmkwea5bVP86njvFALE98p0zX/4zjZO53Fz1deDrne8RZFs3MzMzMzKzj5u2QqfKkpI0zyjZJ2iNpp6RxSWOzYtZJ2ifpoKTdklaV8gFJI6X8gKTLZsT8vqQ/kvS18lh9lpfTzMzMzMys68zbIYuIAG4C7pU0VLIk3g1sAR4ErmwS9gCwNSLWAo8Bt5byG8o81wKXA58qmRjP+HsRcXF5jL+NZTIzMzMzswWk0cFHt2l5yWJEjAG7qTIj3gk8FBFHI2Iv8FqTkDXA3vL8CeCj5flFwJfLPMeB14ENb6v1ZmZmZmZmC1i795DdBVwHbATuaTHtGHB1eX4tcF55fgC4RlKfpAuA9TPeAxgplyveIWnp3MFoZmZmZrbERQcf3aatDllEnAAeAR6OiFZpYjYDWyQ9C6wEzqS92QkcA0aB+4CngTNpxf5euZTxx8uj6Rhlkm6UNCpp9Df/5NvtNN3MzMzMzKxr1clV29ZllxFxGLgCQNKFwFWlfAq4+cx0kp4GXizvfbv8/x1JvwlcAjzUZN47gB0AL2/4SDd2cM3MzMzMrKZuHLC5U8562vszGRJLwo7bgfvL6+UlKQiSLgemIuKFcgnju0p5P/BTVJc9mpmZmZmZLWrpgaEl7QIuA94l6RhwZ0R8BhiWtKVM9nlgpDxfDTwuqQF8m7cuSxws5f1AL/DvgX+dbZeZmZmZmS0s3Zj9sFPa7pBFxLZZr4fnmG47sL1J+UtUGRhnl5+gSvBRS2Oq/sm9qcQg6T192Ssj68c1coPME9P1z/H2NnLLFVOtp/mumMQe1pjMnbdWT/3lmj6VqorMoUN/9maqJi2v/7cTDfbn6upLnDjvT/5tJ7Edano6VVVqi+/NLZf6B1JxKQOJHax/8Oy3Yw5x+kQqTuqtX1ckto2Jk2hgWf24ycQBezLxJQSQad/0ZK6u3sRxQ7l9Uokvh8isC4ChFbVD1JO8iKiRWB+ZL0qARmIdJo9rmboYSPxoAMjkdutLfuclYmKq/mes5cvhVOIHR2/9Y6EtPOkzZGZmZgtdqjNmZlZXpjO2xCzl5BDz/vlHlSclbZxRtknSHkk7JY1LGpsVs07SPkkHJe2WtKqUD0gaKeUHJF02I2ZA0g5JRyQdlvRRzMzMzMzMFrl5O2QREcBNwL2ShkpSjruBLcCDwJVNwh4AtpY09o8Bt5byG8o81wKXA58qiT8A/jEwHhEXUg0g/R/ezkKZmZmZmdnC0SA69ug2LS9ZjIgxSbuB24AVwEMRcRQ4Kun8JiFrgL3l+RPA48AdVB2tL5d5jkt6HdgAfJVq7LL3l/cawJ/mF8nMzMzMzGxhaPeO1buA64CNwD0tph0Dri7PrwXOK88PANeUNPcXUCXyOE/SO8v7/0zSfkm/LekH214CMzMzMzNb0BodfHSbtjpkJRPiI8DDEdEqTdRmYIukZ4GVwJlUVDuBY8AocB/wNDBFdZbuvcBTEfEhYB/wyWYzlnSjpFFJo7/5Z8faabqZmZmZmVnXqpNlsa1OZUQcBq4AkHQhcFUpnwJuPjOdpKeBF4E/A96kut8M4LeB6+eY9w5gB8BLF1/efReAmpmZmZlZbUv5h31ykI25SVpd/u8BbgfuL6+Xl6QgSLocmIqIF0rikN1Ug0wDfAR44Wy3y8zMzMzMrNukO2SSdlFdXrhG0jFJZ85qDUs6AhwGXgFGSvlqYL+kQ1QJQj42Y3a3AdskPVfKb8m2y8zMzMzMbKFo+5LFiNg26/XwHNNtB7Y3KX+JKgNjs5hvAj/RblsApibq9yUb05nx2HP6purfMjg9mWvf9GT9ddE/UX+UeYCI+m2M5N2Tk6fqj04fjalEPbm/S/SdTCxYon0APafqf149Q7m66Kv/GWug/mcF0DNZv40x2J+rKxPUm1suehL7ciO5owxNtJ5mluhJ/i1ucqB2SPaoGzrrF3A0r2fiJGQGh04c2DSd2ycjEadadyTMDEx8N/Qk95PEJq/e5HINDNUOyW6DqW0+uf9H1P+81D+YqgslvpOnJ3N19dc/1jBZ/1hY1VX/O0XTif3kHcCpk/Xjst9DC1A3JtvolM5845nVlOmMmZnVlumMmZnVlemM2ZIxb4dMlSclbZxRtknSHkk7JY1LGpsVs07SPkkHJe2WtKqUD0gaKeUHJF1WyldK+tqMx59Kuu97sKxmZmZmZtaFGurco9vM2yErCTduAu6VNFSSctwNbAEeBK5sEvYAsDUi1lJlTry1lN9Q5rkWuBz4lKSeiPhORFx85gF8E/j82180MzMzMzOz7tbyYuyIGJO0myrxxgrgoYg4ChyVdH6TkDXA3vL8CeBx4A7gIuDLZZ7jkl4HNgBfPRMo6Ueokn/8x+TymJmZmZnZAtNYwonv272H7C7gOmAjcE+LaceAq8vza4HzyvMDwDWS+iRdAKyf8d4Zw8Aj5cycmZmZmZnZotZWhywiTgCPAA9HxOkWk28Gtkh6FlgJnEl7sxM4BowC9wFPA7NTR/0ssGuuGUu6UdKopNHP/fmxdppuZmZmZmZdLjr46DZ18sc2aCMjZUQcBq4AkHQhcFUpnwJuPjOdpKeBF2e8Xgf0RcSz88x7B7AD4OsX/e1uXJ9mZmZmZmZtSw7oMTdJq8s9Yj3A7cD9pXw5oIg4IelyYCoiXpgROsw8Z8fMzMzMzGxx8jhkCZJ2AfuANZKOSbq+vDUs6QhwGHgFGCnlq4H9kg5RJQj52KxZbsIdMjMzMzMzW0LaPkMWEdtmvR6eY7rtwPYm5S9RZWCca/7va7ctZmZmZma2eCzlLItn/ZLFTpluZE7u1T8Z2pjOjR6XicvWFYkR7jpZVyZnZqYeSK73qeSJ4oEOnlxPVBVTufapJ7E+GrmDaKaN6s0tV0xN1w9qJD/jRF2anp3jqE2ZuGxdymwb2f2kQ/tXdl1MnKwdEssnWk/URGafjMx+DCgS6z37UfX0dq6uzLabXIe5upJVZb4bMu2D3PqIDq7D7HL1D9SPaZnfronexPYO0Ltgf6pbDfNuvao8KWnjjLJNkvZI2ilpXNLYrJh1kvZJOihpt6RVpXxA0kgpPyDpshkxw6X8uTLvd53l5TQzMzMzsy61lLMsztshK+OB3QTcK2lI0grgbmAL8CBwZZOwB4CtEbEWeAy4tZTfUOa5Frgc+JSkHkl9VJc4/q2I+OvAc8Avvd0FMzMzMzMz63Ytz+9GxBiwmyoRx53AQxFxNCL2Aq81CVkD7C3PnwA+Wp5fBHy5zHMceB3YAKg8VkgSsIoqGYiZmZmZmS0BjQ4+uk27F9zeBVwHbATuaTHtGHB1eX4tcF55fgC4RlKfpAuA9cB5ETEJ/AJwkKojdhHwmbaXwMzMzMzMbIFqq0MWESeAR4CHI1reybgZ2CLpWWAlcOYu5p3AMWAUuA94GpiS1E/VIfsg8B6qSxY/0WzGkm6UNCpp9JHXv9VO083MzMzMzLpWndQtbZ3li4jDwBUAki4ErirlU8DNZ6aT9DTwInBxef9oKf8tYOsc894B7AD4o/dv7MZ78szMzMzMrKalnPY+PTD0XCStLv/3ALcD95fXy0tSECRdDkxFxAvAt4GLJP1AmcXlwKGz3S4zMzMzM7Nukx7cQNIu4DLgXZKOAXdGxGeAYUlbymSfB0bK89XA45IaVJ2wjwFExCuS7gL2SpoEvgn8fLZdZmZmZma2sCzd82M1OmQRsW3W6+E5pttOlcZ+dvlLVBkYm8XcTzmTZmZmZmZmtlQs2OG/T57srx3To/p97/7J6doxAL0n6yfVnJ7KXUE6NVV/9PeBwalUXdFQ/ZjEnzxOna7/+QIsn5xoPdEsp0/ldoPBU/XX4XSifQD9y+pvhz39ucSuPX314zSQ2556z5msX9dQ/e0doGeyfhvVl7yqu5HY6CfrrwsALTtZP6iRTPo7OFQ7JCJZlxLrPlGXBnP7ZEwk1vuylam6MuofqSsxsKx+Xb3JnxKZTaMnt/8rsVzZujr6V/7EvqypgVRV0VN/n9R07ruB3vq/AWI6dwxl4lT9mMx3eaYegOz+tQB1Yzr6Tjnr95CZmZmZmZlZe+btkKnypKSNM8o2SdojaaekcUljs2LWSdon6aCk3ZJWlfIBSSOl/ICky2bE/M+SnpP0vKRW45yZmZmZmdkiEh38123m7ZBFRAA3AfdKGipZEu8GtgAPAlc2CXsA2BoRa4HHgFtL+Q1lnmupMil+SlKPpO8H/k/gIxHx3wA/KOkjb3vJzMzMzMzMulzLC1MjYkzSbuA2YAXwUBkz7Kik85uErAH2ludPAI8DdwAXAV8u8xyX9Dqwgepy6yMR8Scl5t8DHz0zrZmZmZmZLW6+h6y1u4DrgI1Aq0sKx4Cry/NrgfPK8wPANZL6JF0ArC/vfR14v6TzJfUBPz0jxszMzMzMbNFqq0MWESeAR4CHI+J0i8k3A1skPQusBM6kotkJHANGgfuAp6kGh/5z4BfK/P8j8BLQNC2PpBsljUoa/Z3j32yn6WZmZmZm1uUaRMce3aZOLs0GbZxNjIjDwBUAki4ErirlU8DNZ6aT9DTwYnlvN7C7lN8INM3xHRE7gB0AX/urV3ff2jQzMzMzM6vhrKe9l7S6/N8D3E4Z8FnS8pIUBEmXU50de2FWzLnAL1IlBjEzMzMzsyUgOvjoNukOmaRdwD5gjaRjkq4vbw1LOgIcBl4BRkr5amC/pENUCUI+NmN22yW9ADwF/MuIOJJtl5mZmZmZ2ULR9iWLEbFt1uvhOabbDmxvUv4SVQbGZjFN5zWfPzu1rG5IKntLz8lEEKBE/3si2T+eRrVjBt7M5bKJRF2Zmv6ipzcRBSv/vOnVrvN6M1nX8pP163rH601vj2xpoLd+XX29uc+4t6d+XLauwWX110dvX66uZee+UTtGyT9ZDayuX1fvuUOpurSiflzP6nNTdTEwUDtE73xnrq4OCYCBwc7U1VvnLoEZTp+oHzO0KlfX0Ir6MQO5bTezg2mg/nc/AP31P2MlYgCUXR8ZjfrHw5jOfQ9p2cqO1cVkq3QF302R/F0zkfihNzXReppmMnVljxsLUDfe29UpZ/2SRTMzswWjQ50xM1viMp0xWzLm7ZCp8qSkjTPKNkn6sqSvSDok6XlJvzzj/e+T9ISkF8v/586Y169L+vr/3969x9tV1ffe/3z3JeQGEhRiDChWY4W2CDRiTvGCUiyhl9g+h6g9hcjDaQ6VVqjYQw72QWgfeuJpm9PS9tjG4qtAsYKVSrCxkEawBoESQ4SErSbeIBKJBbnkurP3/p0/5tgw2azbHNlZe62d7zuv+craY87f+o0511xzrbHmnGNIekjSqaWYJWn5LZKWHIwVNTMzMzMz6zQNG2QREcBFwApJU1OnHNcAVwKXRcQJwAKKbu5PTGHLgLURMY9icOdlqXwhMC9NS4FPQNGAAz4GvAU4DfjYaCPOzMzMzMwmv5E2Tp2m6SWLEbGJokv6yykaTjdExD0RsSHNfw4YAOamkEXA9enx9RQDPY+W3xCF+4AjJc0BfgFYExFPpTHJ1gBnj8vamZmZmZmZdbBW7xS8GthAMcjz/PIMSccDpwD3p6LZEbEdICK2j3ZpT9Fge6wUui2V1Ss3MzMzM7NDQLhTj8YiYhdwM3BjRDzf9Y2kmcDngEsjolm3YrW654sG5S99AmmppPWS1n9hz7dbqbqZmZmZmVnHqtLL4osuu5TUT9EYuykibi0t90S6FJH0/45Uvg04rrTcsRTjlNUrf4mIWBkR8yNi/i9Ne12FqpuZmZmZWafyPWQVSRJwHTAQESvGzF4FjPaUuAS4rVR+fuptcQHwTLq08Q7g3ZJmpc483p3KzMzMzMzMJrXc0eZOB84DHpa0MZVdERGrgeXALZIuBB4Fzk3zVwPnAFuB3cAFABHxlKQ/BB5Iy/1BRDyVWS8zMzMzM+syh/I9ZC03yCLiqtLjddS+94uIeBI4s0Z5ABfXifkU8KlW6wKwU71VFi/yVI5or/2quUmb2pcRd1i0b0zw3FPDP+6rvl4jw9X3C4CdPdVz7VP13zN+TB+zhocqxx02VH29+ofztnxvxjulrycv12DGevX1tu9ig56+vFw9fdVfY9iblyvjddbU/qxcHDalekxf7u9+7bITTZ1aPSxnvb7/LXjlsdXjequ/XrFvL0w/vHKceqp/NoQyP08yctGTd4xXfxsHAM/dHjkyUinzt/iIjGNN7rbIiIuMz1YAjWQc5zO+g9I/jdifMTh0b6cfQ208+FW2jpTTGMuV0xjLldMYM7ODJ6sxliunMZYrozFmZgdPVmPsENOJ93a1S8OfINL9XuskLSyVLZa0VtJdkgYkbZZ0SWn+UZLWSNqS/p9Veq5rJW2V9JCkU0sx/yLpaUlfOBgraWZmZmZm1okaNsjSZYYXASskTZU0A7gGuBK4LCJOABYAF0s6MYUtA9ZGxDxgbfobYCEwL01LgU+UUv0xxT1pZmZmZmZ2iBmJaNvUaZpepBsRm4DbgcuBjwE3RMQ9EbEhzX8OGOCFwZwXAdenx9cD7ymV3xCF+4AjR7vHj4i1wHPjs0pmZmZmZmbdodV7yK4GNgCDwPzyDEnHA6cA96ei2ak7eyJiu6RjUvlc4LFS6LZUtj2n4mZmZmZmNjl03nmr9mmpG5uI2AXcDNwYEftGyyXNpBgc+tKIeLbJ09TqOaHStpe0VNJ6Sevv2L21SqiZmZmZmVnHqdKv6IsGt5bUT9EYuykibi0t98TopYjp/x2pfBtwXGm5Y4HHq1Q2IlZGxPyImP8L019fJdTMzMzMzDrUCNG2qdNkDRAhScB1wEBErBgzexWwJD1eAtxWKj8/9ba4AHhm9NJGMzMzMzOzQ1HuOGSnU/SK+LCkjansiohYDSwHbpF0IfAocG6avxo4B9gK7AYuGH0ySV8B3gjMlLQNuDAi7sism5mZmZmZWVdouUEWEVeVHq+j9j1hRMSTwJk1ygO4uE7M21qth5mZmZmZTS7RQZcSSjob+HOgF/jbiFg+Zv7/Bt6Z/pwOHBMRR0o6mWJoryOAYeCaiLi5Wb7cM2QTbkdf9asth2s2IRvLHTU8J25/Rv1y4w6LvGQ565UT81RP3pZ/tqf6frFTeQeA6RnbcG9P3luuP6OK/ZnjbPTk5BrJyzV1b/XX+bDMA/bewerbvjdnYwBD+/ZUjpm+ZzArV/+ze6sHZb5eOqz6NuzJzMVI7tG3omlT8+J6qr//NXVaVqoYGsoIGs7KxUj1uMyPLlD143Xu1zVNyXidM+oHQE9vXlyOnLdJb9565bzOEZnv44xtqN68z9fI+N7AcPX3ZG79rP0k9QJ/BZxF0QfGA5JWRcQjo8tExO+Wlv8dih7nobgK8PyI2CLpVcDXJN0REU83ytlwL0z3e62TtLBUtljSWkl3SRqQtFnSJaX5R0laI2lL+n9W6bmulbRV0kOSTk3lJ0u6Nz3PQ5Le29rmMjMzMzOzyWCkjVMTpwFbI+I7ETEIfIZiPOV63g/8A0BEfCsitqTHj1N0bnh0s4QNG2TpMsOLgBWSpkqaAVwDXAlcFhEnAAuAiyWdmMKWAWsjYh6wNv0NsBCYl6alFKfz4IWW5E8BZwN/JunIZhU3MzMzMzMbZ/XGTn4JSa8BXgt8qca804ApwLebJWx6/jQiNkm6HbgcmAHcEBH3lOY/J2kgVfQRihbkGWn29cDdKXZRig3gPklHSpoTEd8qPdfjkkZbkg1P7ZmZmZmZ2eTQzu7oJS2lOEE0amVErBydXSOkXuXeB/xjxIuvE09Df90ILIkWrt1t9YLWq4ENwCAwf0zC4ymum7w/Fc0e7c4+IrZLOiaV12ttPt/1fZWWpJmZmZmZWVWp8bWyzuwqYye/jzGdFko6Avhn4Pcj4r5W6tPSnYwRsQu4GbgxIvaVEs6kGBz60oh4tsnTNGxtllqSF9RrSUpaKmm9pPX/tmtLK1U3MzMzM7MOF23818QDwDxJr5U0haLRtWrsQpJ+EpgF3FsqmwL8E8VVgZ9tdd2rdC3zovvgJPVTNMZuiohbS8s9kRpXo42sHam8bmuz1ZZkRKyMiPkRMf/tM+ZVqLqZmZmZmVljETEE/DZwBzAA3BIRmyX9gaRfKS36fuAz6XasUYuBtwMfkLQxTSc3y5nVB6ckAdcBAxGxYszsVcASigGilwC3lcp/W9JngLcAz6RLGrNakmZmZmZmNjm0abCTlkTEamD1mLIrx/x9VY24vwf+vmq+zEE2OB04D3hXqfV3Tpq3HDhL0haK/vtHB1JbDXwH2Ap8EvhgKs9qSZqZmZmZmXW7ls+QlVuBEbGOOmMERsSTwJk1yoMxN72l8qyWpJlk2BYWAAAgAElEQVSZmZmZTQ4vvvLv0NK1w4bnnNobyXide3KGps+Ue7qy0+WsV+5m78l5L7fxNR7KjOvNiBnJXLGeNnY7m6OdlzTkfjZEVN/2MZL3ekXOgS0nJjduJPMVy61jRZFZP+Uc2XK3RfMek7sz12T90GunnoxPh5Hh5svUzFX9BVPubpgTlLMtAKn6euXVzzu81de1DTIzMzMzM5sc2jkOWadp2FxXYZ2khaWyxZLWSrpL0oCkzZIuKc0/StIaSVvS/7NKz3WtpK2SHpJ0aip/jaSvpXvHNku66GCtrJmZmZmZWSdp2CBL931dBKyQNFXSDOAa4Ergsog4AVgAXCzpxBS2DFgbEfOAtelvgIXAvDQtBT6RyrcDPxcRJ1P0vrhM0qvGawXNzMzMzKyzjbRx6jRNL1mMiE2SbgcuB2ZQdE9/T2n+c5IGgLnAI8Ai4Iw0+3rg7hS7KMUGcJ+kIyXNiYjtpXSH4avKzczMzMzsENHqPWRXAxuAQWB+eYak44FTgPtT0ezRRlYaZ+yYVD4XeKwUui2VbZd0HMXA0K8Hfi8iHq+8JmZmZmZmZl2mpbNREbELuBm4MSL2jZZLmgl8Drg0Ip5t8jS1uhCL9PyPRcRJFA2yJZJm13wCaamk9ZLWf3nXllaqbmZmZmZmHS7a+K/TVLk88EWXXUrqp2iM3RQRt5aWe0LSnLTMHGBHKt8GHFda7ljgRWfC0pmxzcDbalUgIlZGxPyImP+OGfMqVN3MzMzMzKzzZN2vJUnAdcBARKwYM3sVsCQ9XgLcVio/P/W2uAB4Jl3SeKykael5ZwGnA9/MqZeZmZmZmXWfEaJtU6fJHYfsdOA84GFJG1PZFRGxGlgO3CLpQuBR4Nw0fzVwDrAV2A1ckMpPAP5UUlBc1vgnEfFwZr3MzMzMzMy6RssNsoi4qvR4HbXvCSMingTOrFEewMU1ytcAJ7Vaj1G9GY3bkZo1bhKT2YjuycjVk5srJ6aNuXK2e66cVH1t3BbtlPv7T9b7JGvLQ0T1uNz1ysmF8rIND1fPNZIRAxBDGTGZBzblxA0PZ+XKOvjmHHh374GpU6vH9bXxwDaS0UlzZHbsnJErIu81Vk4Vc7ZFblzuQT6nij29mcnamGu4jZ2FK2PjZ+7zkfteqaq3H/bva77cWD2d/m1j/BRNhUPTofMqm5mZjZXTGDMzqyqnMWaHjIYNsnS/1zpJC0tliyWtlXSXpAFJmyVdUpp/lKQ1krak/2eVnutaSVslPSTp1DG5jpD0A0l/Od4raWZmZmZmnetQHhi6YYMsXWZ4EbBC0lRJM4BrgCuByyLiBGABcLGkE1PYMmBtRMwD1qa/ARYC89K0FPjEmHR/CHz5wFfJzMzMzMysOzS9hywiNkm6HbgcmAHcEBH3lOY/J2mAYpDnR4BFwBlp9vXA3Sl2UYoN4D5JR0qak3pa/FlgNvAvjBl42szMzMzMJrdOHB+sXVrt1ONqYAMwyJgGk6TjgVOA+1PR7IjYDpAaW8ek8rnAY6XQbcBcSU8Af0rRa+NLOgMxMzMzMzObrFrq1CMidgE3AzdGxPN3JUqaSTE49KUR8WyTp6nVJVUAHwRWR8RjNea/+AmkpZLWS1p/964trVTdzMzMzMw6nMcha82L7oOT1E/RGLspIm4tLfdE6VLEOcCOVL4NOK603LHA48B/At4m6YPATGCKpJ0RsYwxImIlsBLg7+b+RudtTTMzMzMzswqyur2XJOA6YCAiVoyZvQpYkh4vAW4rlZ+feltcADwTEdsj4r9ExKsj4njgIxT3mb2kMWZmZmZmZpNTRLRt6jRVzpCVnU5xz9fDkjamsisiYjWwHLhF0oXAo8C5af5q4BxgK7AbuCC71mZmZmZmZpOAOrGV2Iq/PK76JYv7a93F1oLhjJiRzFz7M65r3ZeZ67CMl76dYzf8h6pv+ZfRm5VrZ8arPC1zXPVZI9Xj+rMyQX/Ga9ybeUiYkhE3NfP4k7NeR43sz8rVp+rJjpy6NyvXzMOrDxw69fC89Zo2p/p69UzPe3/1Hj0jK65dNCNjcGjlvf97XnNs9aCXHZmVi8Mz4qbNzEqlGRm5Mrehph1ePebwV+Tl6s343TonJldP3nsyy0jOtyEgqn9ziOGhvFwjGd9ShvOOoTE0mJErc70yHPaGt2Z+O5w47zz2rLY1Su7atqajtk/e0fAQknn4yZLTGMuV0xhrp5zGWK6cxliunMZYrpxGS66cxliudq5XTmMsV05jLFdOYyzXpGyMZcpqjOXKaYxlymqM5ebKaIxl52pnw2qyymiMZctpjGXq9MaYdZ+G3w7T/V7rJC0slS2WtFbSXZIGJG2WdElp/lGS1kjakv6fVXquayVtlfSQpFNLMcOSNqZp1cFYUTMzMzMz60zRxn+dpmGDLA3ifBGwQtJUSTOAa4Argcsi4gRgAXCxpBNT2DJgbUTMA9amvwEWAvPStBT4RCnVnog4OU2/Mk7rZmZmZmZm1tGano+PiE2SbgcuB2ZQ9IJ4T2n+c5IGKAZ+fgRYBJyRZl8P3J1iF6XYAO6TdORo9/jjuD5mZmZmZmZdo9ULpK8GNgCDwPzyDEnHA6cA96ei2aONrDQW2TGpfC5QHvx5WyrbDkyVtB4YApZHxOcrr4mZmZmZmXWlkS7taHA8tNQgi4hdkm4GdkbE83eeS5pJMTj0pRHxbJOnqdWbyeiWf3VEPC7pJ4AvSXo4Ir79kieQllJc7sj7jjyN02fOa6X6ZmZmZmZmHalKl28jlHo9l9RP0Ri7KSJuLS33hKQ5aZk5wI5Uvg04rrTcscDjABEx+v93KC5xPKVWBSJiZUTMj4j5boyZmZmZmU0O0cap02T1wS1JwHXAQESsGDN7FbAkPV4C3FYqPz/1trgAeCZd0jhL0mHpeV9BMej0Izn1MjMzMzMz6ya5g2ycDpwHPCxpYyq7IiJWA8uBWyRdCDwKnJvmrwbOAbYCu4ELUvkJwN9IGqFoIC6PCDfIzMzMzMwOESMdee6qPVpukEXEVaXH66h9TxgR8SRwZo3yAC6uUf5V4GdarYeZmZmZmdlk0bXD0D/aO1w5Zn9Gyzt33PecQef2ZGYbzIiboqyrVbMMZ2yLH43szcp1pKZUjtnFUFauqfRWjnmmp3r9AKbU/v2jof6MGIC+jLjezFzTo3rcYZk/oO0dqr7tezN/rdu3p/r7a3Co+v4EMHPfYOUY9ezJytU3rfp7ZUrf7qxcjLTnl9Ke3dW3HwB91V9jHfVcVir1ZByvc2IARjI+h5S37+bUMTLXS9MOr54r8j6Ts46Gua/XcM7rlZmrJ+d1zts3lFPHzNeL3oyvwr391WOG9jVf5hB3KJ8ha7jHp/u91klaWCpbLGmtpLskDUjaLOmS0vyjJK2RtCX9P6v0XNdK2irpIUmnlmJeLenO9HyPpK70zczMzMzMJrWGDbJ0meFFwApJUyXNAK4BrgQui4gTgAXAxZJOTGHLgLURMQ9Ym/4GWAjMS9NS4BOlVDcAf5ye7zRe6JnRzMzMzMwmuYho29Rpmp6njYhNkm4HLgdmADdExD2l+c9JGqAY5PkRYBFwRpp9PUU39pen8htSI+8+SUembvFnAX0RsSY9385xWjczMzMzM7OO1uqFs1cDG4BBYH55Rrq88BTg/lQ0OyK2A6Ru7Y9J5XOBx0qh21LZscDTkm4FXgv8K7AsIqrfJGZmZmZmZl3H95A1ERG7gJuBGyPi+bsSJc2kGBz60oh4tsnT1LrPNSgahW8DPgK8GfgJ4AM1n0BaKmm9pPVff25rK1U3MzMzMzPrWFW6sRmh1OmgpH6KxthNEXFrabkn0qWIpP9H7wfbBhxXWu5Y4PFU/mBEfCcihoDPA6dSQ0SsjIj5ETH/TYe/vkLVzczMzMysU0Ub/3WarL5PJQm4DhiIiBVjZq8ClqTHS4DbSuXnp94WFwDPpEsbHwBmSTo6LfcuinvRzMzMzMzMJrXccchOB84DHpa0MZVdERGrgeXALZIuBB4Fzk3zVwPnAFuB3cAFABExLOkjwNrU0Psa8MnMepmZmZmZWZfpxN4P26XlBllEXFV6vI46Yx9GxJPAmTXKA7i4Tswa4KRW62JmZmZmZjYZ5J4hm3BDGdd/7s+Iye3xZTgjbpC8Ueb35nRIWbM5fXCMZPziMZjZyeagqm/D3Fw523AveblGMq4ujrwrkrPeJ32ZO1RfznopL9e+jM3RE3m59qp6sn1DeYfjKYPV96mhnI0BqKf6vhF7M99feYfDyqIvs37DGRXcN5iVKvbta77QGNq/PysXU4Yqh8RwZq6ovh9quHr9ACIjThnvY4CI6vtGxkdXvrzVAnrHsxbjL/P1atvBJrt+dijo2gaZmZmZmZlNDu72vo7UAcc6SQtLZYslrZV0l6QBSZslXVKaf5SkNZK2pP9nlZ7rWklbJT0k6dRU/k5JG0vTXknvOVgrbGZmZmZm1ikaniGLiJB0EfBZSXdRnK++hmKcsD0RsUHS4cDXJK2JiEeAZcDaiFguaVn6+3JgITAvTW8BPgG8JSLuAk6GojFH0enHneO/qmZmZmZm1oncqUcDEbFJ0u0UjaoZwA0RcU9p/nOSBoC5FN3VLwLOSLOvB+5OsYtSbAD3STpS0pzU9f2o/wx8MSJ2H/CamZmZmZmZdbhW7yG7GtgADALzyzMkHQ+cAtyfimaPNrIiYrukY1L5XOCxUui2VFZukL0PGDuumZmZmZmZTWK+h6yJiNgF3AzcGBHPd/ckaSbwOeDSiHi2ydPU6q7s+S0vaQ7wM8AddZ9AWippvaT1Dz337VaqbmZmZmZm1rGq9ME5QqlvUEn9FI2xmyLi1tJyT6TG1Wgja0cq3wYcV1ruWODx0t+LgX+KiLr950bEyoiYHxHzTzr8dRWqbmZmZmZmnSra+K/TZA2KIEnAdcBARIy9xHAVsCQ9XgLcVio/P/W2uAB4Zsz9Y+8H/iGnPmZmZmZmZt0odxyy04HzgIclbUxlV0TEamA5cIukC4FHgXPT/NXAORS9KO4GLhh9snQf2nHAlzPrY2ZmZmZmXWrEvSw2FxFXlR6vo/Y9YUTEk8CZNcoDuLhOzPcoOvho2Y9isMriAAxmjMY+nDmCe07UnpG6V2s2NBjDlWOmqDcrV468LQhPDu2sHDPYO1Q5ZufIvuYL1TBN/dWDMn8COSzjZHZf3glwelTzrd1Qb+3DQVO7M/bDKZm51Ft94+dtQeil+nr1VN91ARjZWz2m/+nqxwyAKXuqx/VNy6ggMJK5PSr7j0H6jqge1jO9+msce/K2hfozDhzTpmXlIuP9T/+UzFwZ77DejOMuwP6M43xO/QB6MvaNvEx5dYy89VLu9siRsQ2zRfVvKcr5MO/tI4YzDmw9bdzuNmFyz5CZHVQ5jTEzs6pyGmNmZlVlNcYOMZ14b1e7NGx2p/u91klaWCpbLGmtpLskDUjaLOmS0vyjJK2RtCX9P6v0XNdK2irpIUmnlmL+V3qegbRM3k/gZmZmZmZmXaRhgyxdZngRsELSVEkzgGuAK4HLIuIEYAFwsaQTU9gyYG1EzAPWpr8BFgLz0rQU+ASApJ+juCftJOCngTcD7xi3NTQzMzMzs442EtG2qdM0vWQxIjZJuh24HJgB3BAR95TmPydpgOIesEeARcAZafb1wN0pdlGKDeA+SUembvEDmApMobgvrR94YlzWzszMzMzMrIO1eg/Z1cAGYBCYX56Rekg8Bbg/Fc0e7c4+IrZLOiaVzwUeK4VuA+ZGxL2S7gK2UzTI/jIiBqqvipmZmZmZdSPfQ9ZEROwCbgZujIjnuyqSNJNicOhLI+LZJk9T676wkPR64ASKgaLnAu+S9PaaTyAtlbRe0votO7/bStXNzMzMzMw6VpW+NEco9WAuqZ+iMXZTRNxaWu6JdCki6f8dqXwbxVhjo44FHgd+FbgvInZGxE7gixT3pb1ERKyMiPkRMX/ezNdWqLqZmZmZmVnnyRrcIPWCeB0wEBErxsxeBSxJj5cAt5XKz0+9LS4AnkmXNj4KvENSX2rkvQPwJYtmZmZmZoeIQ7lTj9zR5k4HzqO4vHBjms5J85YDZ0naApyV/gZYDXwH2Ap8EvhgKv9H4NvAw8DXga9HxO2Z9TIzMzMzM+saLQ8MHRFXlR6vo/Y9YUTEk8CZNcoDuLhG+TDw31qth5mZmZmZTS6HcqceLTfIOs0uqo94vj9Gmi80xjDVYwAi43TorpHBrFz7M+qYu145hnO2xfC+5gvV0KPqJ313Z+aKnurrtWdkSlau/eqtHHNYxrYAUFQfl72v9u8zLSSrHjKceWJ/p6rv830Z2wJgd0/1uGk9eevVP1L9ML5vsH2H/qE9edswRqrHZRzi6enLPMYPDVeO6duTd6zhsOrHDe3P+zyhr796TG6ujGNUDO/PS5Wxc8Rw9e8ZAOrNeH/1VD/GA3k7fe7Hf06uzM+hturN2Oepvh+qe79yWxs0fKek+73WSVpYKlssaa2kuyQNSNos6ZLS/KMkrZG0Jf0/q/Rc10raKukhSaeWYj4uaVOa3nswVtTMzMzMzDqT7yGrI11meBGwQtJUSTOAa4Argcsi4gSKHhEvlnRiClsGrI2IecDa9DfAQmBempYCnwCQ9IvAqcDJwFuA35N0xPitopmZmZmZWWdqev40IjZJuh24HJgB3BAR95TmPydpgGIMsUeARcAZafb1wN0pdlGKDeA+SUembvFPBL4cEUPAkKSvA2cDt4zPKpqZmZmZWSfzPWTNXQ1sAAaB+eUZko4HTgHuT0WzU3f2RMR2Scek8rnAY6XQbans68DHJK0ApgPvpGjYmZmZmZmZTWotNcgiYpekm4GdEfH8XcmSZlIMDn1pRDzb5Glq3aEdEXGnpDcDXwV+BNwLtXvskLSU4nJHTj7qJF478zWtVN/MzMzMzDpY5HQcM0lU6f5mhFLfPGkQ588BN0XEraXlnkiXIpL+35HKtwHHlZY7FngcICKuiYiTI+IsiobblloViIiVETE/Iua7MWZmZmZmZt0uqz9SSQKuAwYiYsWY2auAJenxEuC2Uvn5qbfFBcAz6ZLGXkkvT897EnAScGdOvczMzMzMrPuMEG2bOk3uoAinA+cBD0vamMquiIjVwHLgFkkXAo8C56b5q4FzgK3AbuCCVN4PfKVo4/Es8Bupgw8zMzMzM7NJreUGWURcVXq8jjpDukbEk8CZNcoDuLhG+V6KnhbNzMzMzOwQFB04Pli7dO2w4T8e3lM5ZjCGK8fkntYczrgxce/IYFau/SPV12tKT95Ln9Mlac62eHpwZ+UYgKGM13jn/ur7EsD0vqmVY/ozt3t/xtXFua9xT+3fWhrqzYgB2Kvqr9c0ZW5DVa+jMmIApmds+/7evFzQWzli2r4pWZn2D1XPNX1n3nFtZLj69oiRjJjMCzKk6sfCKc/szspFT8Z6TZ+WlSprL+zvz8pFf8Z+OLg3K1UMVj/OaySvg4HoqX68lrLuIMnqBEF9ee9/enOOvZmdNOR07tCbuR/myMmV8XkH5G0L6zoNjwDpfq91khaWyhZLWivpLkkDkjZLuqQ0/yhJayRtSf/PSuVvlHSvpH2SPjImz9mSvilpq6RlmJmZmZnZIeNQvoesYYMsXWZ4EbBC0lRJM4BrgCuByyLiBGABcLGk0csOlwFrI2IesDb9DfAU8CHgT8o5JPUCfwUspLh08f2l5zIzMzMzM5u0mp4jj4hNwO3A5cDHgBsi4p6I2JDmPwcMUAzyDLAIuD49vh54T1puR0Q8AOwfk+I0YGtEfCciBoHPpOcwMzMzMzOb1Fq9IPhqYAMwCMwvz5B0PHAKcH8qmh0R2wFSt/bHNHnuucBjpb+3AW9psV5mZmZmZtblDuVOPVq6izQidgE3AzdGxL7RckkzKQaHvjQins2sQ617iGu+IpKWSlovaf3ju7ZlpjMzMzMzM+sMVbr1GaHUXY6kforG2E0RcWtpuSckzUnLzAF2NHnebcBxpb+PBR6vtWBErIyI+REx/1Uzjq1QdTMzMzMz61QjEW2bOk1WP6sq+oK+DhiIiBVjZq8ClqTHS4DbmjzdA8A8Sa+VNAV4X3oOMzMzMzOzSS1v4As4HTgPeJekjWk6J81bDpwlaQtwVvobSa+UtA34MPD7krZJOiKKQWB+G7iDonOQWyJi8wGsk5mZmZmZdZFo479mWhmSKw0F9kgaAuzTpfJXS7ozDQ/2SOpvo6GWR/mLiKtKj9dRZ/zIiHgSOLNG+Q8pLkesFbMaWN1qXczMzMzMzMZbaUiusyhurXpA0qqIeKS0zDzgfwCnR8SPx3RieANwTUSsSf1tNB3dO2fY9Y6wc2Rf84XGGBwZqhzTSiu6lpzrU3cPV18ngKGM9Rrsad+I9iNRfXT63UN526JHNX8naGjX/r1ZuXLs65+eFTes3uoxI3n7bk/t31oa6s3Y7rmUmWs31fdDZWwLgL1Uf732ZK5Xf0/1uD1DeYf+GK6ea//e6tsCYHgk9wKOanr3Nf2crKmnt/r7K/ZX3wcBtL/6MZ7hvFwxlPE+ycxFZBzn9w/m5RrKiMs47gIwnPNdo32yc/W273uDsr6ejh1VqUXtWq+ezP0p7xDVlTqol8Xnh+QCkDQ6JNcjpWV+E/iriPgxFMN7pWVPBPoiYk0q39lKwvZ84pmZmZmZmXW+WkNyzR2zzBuAN0i6R9J9ks4ulT8t6VZJD0r643TGraGGDTIV1klaWCpbLGmtpLvStZGbJV1Smn+UpDWStqT/Z6XyN0q6V9I+SR8Zk+dTknZI2tSswmZmZmZmNrmMEG2bykNppWlpqSqtDMnVB8wDzgDeD/ytpCNT+duAjwBvBn4C+ECzdW/YIIvi3OFFwApJUyXNAK4BrgQui4gTgAXAxekUHcAyYG1EzAPWpr8BngI+BPxJjVR/B5xdo9zMzMzMzGzclIfSStPK0uxWhuTaBtwWEfsj4rvANykaaNuAByPiO6njws8DpzarT9NLFiNiE3A7cDnwMeCGiLgnIjak+c9R9I44eipvEXB9enw98J603I6IeIAaF/lGxL9RNNjMzMzMzOwQExFtm5poZUiuzwPvBJD0CopLFb+TYmdJOjot9y5efO9ZTa3eNXk1sAEYBOaXZ6SuHE8B7k9FsyNiO0BEbB/T64iZmZmZmVlHioghSaNDcvUCn4qIzZL+AFgfEavSvHdLegQYBn4v9TRPujVrbRq3+WvAJ5vlbKlBFhG7JN0M7Ix4oVuk1JXj54BLI+LZKiubI13fuRTgNS97PUdPn3OwU5qZmZmZ2UGW00P5wVJrSK6IuLL0OCjGVv5wjdg1wElV8lXpZXGEUuebkvopGmM3RcStpeWekDQnLTMH2FGlQo2Ur/d0Y8zMzMzMzLpdVrf36RTcdcBARKwYM3sVsCQ9XgLcll89MzMzMzOb7DroHrK2yx2H7HTgPOBdkjam6Zw0bzlwlqQtFCNcLweQ9EpJ2yhO7f2+pG2Sjkjz/gG4F/jJVH7hAayTmZmZmZlZV2h5KPSIuKr0eB21++gn3dB2Zo3yH1J0G1kr5v2t1mPUzqG9VUMYHBmqHBOZY9oPx3DlmN1D+5ovVCvXSPVh3Kf0Vt8WuYZGqm+L/p5ent676yDU5qV278/b7jl29lffb6HYHlX1NR+HsKae2m/thnqV99vOcE/199dw5nvysJ7c35+q26mWD63Pm5LxGueamfl6DWVs+j17puTlGm7P67V79xSmTx+sHCdV3xiH78w71qi/elzsycyV8z45bE9WLnoz9vnBvGMog9XrmPsbunqrv//JPT5lfP5ny/mOknmsydn2av0r7ZjA6t9RaOPxuq25bMJk7r1mB1e7GmNmdmjLaYyZmdn4G8n+GaT7NfzpQoV1khaWyhZLWivpLkkDkjZLuqQ0/yhJayRtSf/PSuVvlHSvpH2pO8jR5Y+r91xmZmZmZmaTWcMzZBERki4CPivpLoq++K8BPgDsiYgNkg4HviZpTUQ8AiwD1kbEcknL0t+XUwz8/CHSQNElQ8BldZ7LzMzMzMwmuU7sbKNdml7cGxGbgNspGlUfA26IiHsiYkOa/xwwAMxNIYuA69Pj60kNsIjYEREPAPvHPP/2Bs9lZmZmZmY2abV6D9nVwAZgEJhfniHpeOAU4P5UNDsitkPR2JJ0TKuVqfFcZmZmZmY2yXXSwNDt1lKDLCJ2SboZ2BkRz3ezI2kmxeDQl0bEswdSkVaeS9JSYCnAK2e+hiOntdzWMzMzMzMz6zhV+iMdSRMAkvopGlA3RcStpeWekDQnLTMH2NHsiRs814tExMqImB8R890YMzMzMzObHKKN/zpN1gARkgRcBwxExIoxs1cBS9LjJcBtB/BcZmZmZmZmk1buOGSnA+cBD0vamMquiIjVwHLgFkkXAo8C5wJIeiWwHjgCGJF0KXAicFKD5zIzMzMzs0nO95C1ICKuKj1eB6jOck8CZ9Yo/yFwbI2Qus9lZmZmZmY2meWeIZtwU3qqVz3nmtHc1nqvql8NOtQznJVrWCPNFxojZ/tB3ijqymhv9/X0Vo4BmNJbfb32tTFXf2auPlWP68+IASiuIq6mN+/qZ6Zk1LEv470F0JdRx56MbQHQm7PPZ/4wmPNO7s+8fj4nl5R5DO2pflxrZ57e/oy4vszfHqdkbPmezFy9GceNnBiAjGNoVky7c7VTT97xsOO1c70i472cc9jI/Pw/lHgcsjpUWCdpYalssaS1ku6SNCBps6RLSvOPkrRG0pb0/6xU/kZJ90raJ+kjpeWnSvp3SV9Pz3X1wVhRMzMzMzOzTtOwQRZFU/UiYEVqOM0ArgGuBC6LiBOABcDFkk5MYcuAtRExD1ib/gZ4CvgQ8Cdj0uwD3hURbwJOBs6WtODAV83MzMzMzLrBodzLYtPz8RGxSdLtwOXADOCGiLinNP85SQPAXOARYBFwRpp9PXA3cHlE7CtyVn0AABZASURBVAB2SPrFMc8fwM70Z3+aOm9LmZmZmZmZjbNWL5C+GtgADALzyzMkHQ+cAtyfimZHxHaAiNguqemAYZJ6ga8Brwf+KiLubxJiZmZmZmaThO8hayIidgE3AzdGxL7RckkzKQZ0vjQins2tREQMR8TJFL0wnibpp2stJ2mppPWS1j+5+4ncdGZmZmZmZh2hSjc2I5T6lZHUT9EYuykibi0t94SkOWmZOcCOVhNExNMUlzieXWf+yoiYHxHzXz59doWqm5mZmZmZdZ6sfkVV9It9HTAQESvGzF4FLEmPlwC3NXmuoyUdmR5PA34e+EZOvczMzMzMrPtERNumTpM7yMbpwHnAw5I2prIrImI1sBy4RdKFwKPAuQCSXgmsB44ARiRdCpwIzAGuT/eR9QC3RMQXclfIzMzMzMysW7TcIIuIq0qP10HtkU8j4kngzBrlP6S4R2yshyg6BTEzMzMzs0NQ5523aqN2nh5s0ynIpe2Kcy7ncq7OytXp9XMu53KuyZGr0+vnXM7lqbumCa/AuK8QrG9XnHM5l3N1Vq5Or59zOZdzTY5cnV4/53IuT901ZXXqYWZmZmZmZgfODTIzMzMzM7MJMhkbZCvbGOdczuVcnZWr0+vnXM7lXJMjV6fXz7mcy7qI0jWoZmZmZmZm1maT8QyZmZmZmZlZV3CDzMzMzMzMbIK0PDC0mZmZWTeT9DLgbGAuxTi0jwN3RMTTE1qxRNIrASLih5KOBt4GfDMiNld8nj+KiCsORh3bSdLbgSci4puS3gosAAYi4p8nuGpm42pSniGTdGWT+b8g6UJJx48p/3/rLC9JiyWdmx6fKelaSR+UVGkbSvpSk/mvGPP3b6RcSyWpQdyvSjoqPT5a0g2SHpZ0s6Rj68SskHR6lfqnuKMkXSnpv6bt8VFJX5D0x5JmNYh7p6S/lHSbpM9JWi7p9S3k+wVJn5C0KsV+QtLZVeudnsv7xkHaN3L3ixRbed+Q9EZJl6dt8Ofp8QlV6jzm+S5okutMSTPHlDfcDyWdJunN6fGJkj4s6ZyK9bqhyvIp5q0p17sbLPMWSUekx9MkXS3pdkkfV/GltV7chyQdV7E+UySdL+nn09+/nl7viyX1N4l9naSPpNf4TyVd1Kh+KWbcjhnp+eoeN6oeM9K8cTluNDtmpGUqHzdyjhlp2bYdNzKPGecDG4AzgOnADOCdwNfSvEokndVk/hGSXlej/KQ6y/834F7gPkm/BXwB+CXgVkkXNshz7ZjpL4APjv7d4rq8VtKvSXpjk+VeLWlqeixJF0j6C0m/Janmj/ySfmU0pgpJfwYsB26U9IfA/wKmAb8r6Y8bxM2U9J8l/a6k35F0divvK43jZ4oafJ6UclX6TNE4fJ5Y55qUnXpIejQiXl1n3h8Bb6U4KP8y8GcR8Rdp3oaIOLVGzP8BjgGmAM8ChwG3A+dQ/HJzSZ1cD40tAt4AfBMgIl5yUC7XQdLvU/w69mmKg/K2iPjdOrkeiYgT0+ObgfuAzwI/D/yXiHjJB4ekHwHfB44Gbgb+ISIerPX8Y+JWAw8DRwAnpMe3AGcBb4qIRTVilgOzgbXAe4DvAt8CPgj8UUR8tk6uP6PYZjcA21LxscD5wJZ6275B3b1vHKR9I2e/SHGV9w1JlwPvBz7Di/eL9wGfiYjljepapx419w1JHwIuBgaAk4FLIuK2NK/mfpHmfQxYSHElwhrgLcDdFNv9joi4pkbMqrFFFF8YvwQQEb9SJ9e/R8Rp6fFvpvr+E/Bu4PZa20PSZorXZUjSSmA38I/Aman81+rkegbYBXwb+AfgsxHxo1rLlmJuotgO04GngZnArSmXImJJnbgPUbwXv0zxntoI/Bj4VeCDEXF3jZhxPWak56y3b1Q+ZqR5lY8bOceMsfVo9biRc8xIy7bluHEAnyffBN4y9mxYavjdHxFvaFTXGs/X6PNkMfBnwA6gH/hARDyQ5tX7PHmY4jgxjWI7vj6dKZsF3BURJ9fJtY3i2HInxX4B8CfARwAi4voaMZ+PiPekx4tSXe8Gfg74nxHxd3VybQJOi4jdkj4OvA74PPCulOslP0RI2kNxzPgixTHjjogYrvX8Y+I2Az9NsT1+AMxNefuBByPip2vELAZ+D/g6xbHzqxQnH36GYt99uE6ucf1MabJvVP5Myfk8sS4z0SNT504UH2K1pueAoQZxDwN96fGRwGrgf6e/H6wXk/7vB54EpqS/+0bn1YlbBfw98EbgNcDxwGPp8WvqxDxYerwBmFHK3SjXN0uPvzZm3sZGuYB5wP8HbAa+AXwMeEODXBvT/wJ+0GKuh0uP+4B70uNZwKYGub5Vp1wUX668b3TIvpGzX+TuGxRfvvprlE+pt1+k+Q/VmR4G9jXYL2amx8cD6yk+QOvuF6W4XopGyLPAEal8GvBQnZgNab84A3hH+n97evyOBrnK+8YDwNHp8Yx6+wbFZT/P563wej1I8QXn3cB1wI+AfwGWAIfX2+6l1/cJoLe0r9TcFuVtmB5PB+5Oj19db9uTccxI8ysfN8g4ZpT3eSocN8g4ZtTYN1o6bpBxzCjn4iAfNziAzxPgZTXKX1Zv30jbvdZ0O7CrQa6NwJz0+LS0HX6t0b5B6X0IfL3e61gj7nCKBtWnKRotAN+pt3yN/eKrwGvT41eMzT0m7pHyvgH01KtzOVd6bX6TohH9BPDXNDimpbhN6f+pFD/ETEt/95brMSbmIWB6aV3uSI9PAr7aZN+o9JlCxufJ6P5Lxc8UMj5PPHXX1M2XLD4NzIuII8ZMh1N8gamnLyKGAKL4leyXgSMkfZbijVfL6PL7gQciYjD9PQTU/ZUnil+zP0cxTsSbIuJ7wP6I+H5EfL9O2DRJp0j6WYovIrtKuRv9onS3pD+QNC09Hv3l653AM/WqmJ57S0T8YUT8FLCY4uC3ukGunvSL3XHATKVLdSS9nPrbcETpEhjgVRQHFiLix7zwi14teyWdVqP8zcDeOjHeN16sXftGzn4BefvGSFp2rDlpXj2zKc6U/HKN6ck6Mb0RsTPV6XsUjaSFklY0qB8UX+KHI2I38O2IeDY9x54GdZxP8SXno8AzUZwB2hMRX46ILzfI1SNpVtrWinTGKu0jQ3ViNpUuq/m6pPkAkt4A7G+QKyJiJCLujIgLKV6H/0NxX853GtRvCsUXx+kUX4ChODPU8JJFXrjX+bAUT0Q82iAu55gBeceNnGMGZBw3Mo8ZkHfcyDlmQPuOG7mfJ9cAG1RcwnpFmv6aoqFa7wzD24C/Af60xrSzQa7eiNie6vXvFGdrPprOjkSD9Rrdr39xtFDF5X51v69FxHMRcWmq099L+kij5UfDSo/7IuK76bn+g8bH0MckvSs9/h7F6zb6ejWoYvw4Ij4ZEWcCbwIeAZZLeqxB3D9L+grwFeBvgVskfZTiTNu/1YkRsCc93kVxJpqIeIjiLGw9OZ8pOZ8nkPeZkvN5Yt1koluEuRPw/1OcNq817+MN4r5AjV9l0vON1In5IunXjDHlrwT+vYW6zgBWUPyqtq3JsneNmUZ/YXs5sL5BXD9wFfBomkYoftn9NPDqOjF1f3FrUsf3U/zC9QTw/wD/mqYfAEvrxLyX4hKMO1P9fjGVHw18ukGunwXupzh435mmgVT2s4fYvnF3J+8bdfaLNY32i9x9g+LL/9a0/Vem6V9S2dkNcl0HvLXOvHq5vgScPKasj+KSuOEGue7nhV9qy78iv4wxZ6RqxB5LcYnYXwKPtrDtv0fRGPpu+v+VqXwm9c8yvAz4O4pLD++naIR9h+LywDc1yNXol/ppdcp/Nz3394EPUfxK/kmKX30/1uD5LqH4xXklxRmGC0r7xr/ViTmViseMFFf5uEHGMSPNzz5uUOGYkZav/JlCxjGj2b7RIKbycYPMz5O0zCyKy9Auo7ik733ArCav1TvrzKu5D6Z5XwVeN6bs8LTv1zsb/2pqn6WZC/x8i9tTFJfD/X2T5YZ54QzwIC8cM6bQ+Kz1cWk/+jeKs4Q/pjhGPgicWXW/oMHZ3TT/PwEL0uPXpddsMaVj6pjlPw7cAVxB0ZC7IpUfBWxukKfyZwoZnydpXuXPFA7g88RTd0yT8h6yRtIvfkTxq8LYeXMj4gcVnmsGxeUfO1pc/k3Af4qIv241Rym2B5gaxa8jzZZ9GcUvXo1+oUHSzEi/0mTUp5fil/ghFTfynkxxuUndM1DpF82fALZGxR6tVPQ8NZfiw2ZbRPwwp95NcnTrvtELHNYJ+0bOfpHiKu8b6T1xGqX9guJsQ9N7E6pQ0YnBUK19TtLpEXFPnbjDImJfjfJXUHwprnkvw5hlfxE4PTJ7S5M0HZgd6dfvOsscTrHt+yjeW080ec43RMS3MuryKoCIeFzSkRT3PjwaxdmDRnE/RXFv0aaI+EaFfF11zEgxLR83DuSYkeJbOm60esxIy7btuHGAnyezKfWy2Gyfz5Fen90RsWVMeT+wOCJuGu/6jcd6pffmCRFxb5PlTqC4h7GPF469Nc/USDojatzvWaFOldZLRUcXJ1JcQrkmlfVQNHZfckwuxXXsZ8p4fJ5YZ+vaBlm6/GV/pBVIl1KcSnFd8RfHM865JjTXSVFcatCynBjnmpiYA4x7NfBsRDydLnOaT3FfVMPuoevEfSMiNo1njHNNXK4UN5/i1/whintAWmrM5cQ518Tkqhoj6WSKe5deRvFlWxRno5+m6CRmQ4PYg95IGlO/0cb8aP1+K+p0kNIkbsLXKzdmItarznNV/qHhAH6caFsu6zDRAafpciaKHnRmpce/R3F5wO9TXOqwPDPuf45XzEHKdSiu1zDFJQN/CJzY4r5ROca5uq5+yyguz/sG8F/T/9dRdCLw4fGMc66uy/UOipvk/5XicqovAPdQXPJ7XINcleOca2JyHUD9NlL0sji2fAH1O6Q4haKXyQFeuDz/G6ns1Aa5Tm4Qd8p41e8grVfN+rWwXjW3R07MAaxXVq5GEy1cNj4eMe3O5amzpgmvQHbFSz0ppQPzaO87fTS+/rlynHNNaK4HKbq9vYbiS/vXKb6kHT+eMc7VdfXbTNG71Msp7oEo9yrYqJe1ynHO1XW5Hiwt91rgn9Ljs4A7m+yHleKca2JyHUD9GvWyubVOeTsbSZXr1yXrlZurnev14TrTZcBT4xXT7lyeumfq5l4Wn5U0OgbFf1D04gTFF/xG65UT51wTlysiYlNEfDQiXk/Rbe4xwFckfXUcY5yru+o3HMV9O09T9Kj1ZHqiXQ3y5MY5V3fl6o0XxkV7lKJbeKK4l2TuOMc518Tkyq3fFyX9s6T3Svq5NL1X0j9TdOBQy4yIuH9sYUTcR/HDQD05cTn164b1ys3VzvX6I4oOXw4fM82k/neUnJh257Iu0c33kJ0E3EjxazrA6RS9g50ErIiIT49XnHNNaK4HI+KUGuUC3h41ugLPiXGurqvf31H0BjaDYkDjIYoP6HdRjIW1uE6uynHO1XW5PkVx38haYBFF5xAfVtHByYaIeGOdXJXjnGticuXWL8UuTDHljhtWRUTNbvklXUvRu98NFOO+QXHf2vnAdyPit8c5rlL9umG9cnO1eb2+CvxORHytxrzHIuK48Yhpdy7rHl3bIANQ0TPTu3lxTz93RJMel3LinGtickn69XqNtfGMca6JiTmAXH3AuRRfyv4ReAtF99mPAn8Vdc6g5MQ5V9fl6qc4y3oixQ9An4qIYRU9Ih4TdcbsyolzronJlVu/XO1qJLVbO9erndsis34/SXHp349qzJsdNToFyYlpdy7rHl3dIDMzMzNrhYou/P8HxZf1Y1LxDuA2is6lKnWfP95y69fp65Vrsq6XWS1de92ppJmS/kDSZknPSPqRpPskfWC845zLuZyra+q3JDNX3Tjn6tpcmzL3w5bjnGticuXWD7iFolfGd0bEyyPi5cA7Ke5R/GydXC+TtFzSgKQn0zSQyo5sUMecuMr164b1ys01Qev1jYz1ajmm3bmse3TtGTJJtwH/RNGl6WKKeww+Q9GV+g+izkCqOXHO5VzO1f31cy7ncq7JkesA6vfNiPjJKvMk3QF8Cbg+0kC+KgYd/wBwZkScVef5Ksfl1K9L1is3Vyes1xLg5yuuV92YdueyLhId0NVjzsSY7kspRlOH4qzfN8Yzzrmcy7m6v37O5VzONTlyHUD97gT+OzC7VDYbuBz41zox32zwfOM6L6d+XbJeuc83Wderbbk8dc/UtZcsArskvRVA0i8DTwFExAigcY5zLudyru6vn3M5l3NNjly59XsvxZh2X5b0lKSnKAaTPoriTFst35f03yXNHi2QNFvS5bzQi994xeXUrxvWKzfXZF2vduaybjHRLcLciaK79H+nuJZ4HfCGVH408KHxjHMu53Ku7q+fczmXc02OXLn1y5koxn76OPANiobfU8BAKjtqvOPaNbVzvdq5LbphvTp9G3qamKlr7yEzMzMzq0LSGym6Q78vSsMmSDo7IhoNvtwWufXr9PXKNVnXy2ysbr5ksS5JF7Qrzrmcy7kOToxzOZdzOdd4xkj6EEWX6b8DbJa0qDT7jxrEvVHSmZJmjCk/u0ldKsUdQP06er0OIGZSrle7c1mXmOhTdAdjAh5tV5xzOZdzdX/9nMu5nGty5GoUAzwMzEyPjwfWA5ekvx+sE/Mh4JvA54HvAYtK8zY0yFU5Lqd+XbJeubkm63q1LZen7pn66FKSHqo3i6IXnnGLcy7ncq7ur59zOZdzTY5cufUDeiNiJ0BEfE/SGcA/SnpNiq3lN4GfjYidko5Pyx8fEX/eICY3Lqd+3bBeubkm63q1M5d1ia5tkFEcdH+BYtDAMgFfHec453Iu5+r++jmXcznX5MiVW78fSjo5IjYCpC+3vwR8CviZOjHtbCTl1K8b1is312Rdr3bmsi7RzQ2yL1Ccyt44doaku8c5zrmcy7m6v37O5VzONTly5dZvBJhaLoiIIeB8SX9TJ6adjaSc+nXDeuXmmqzr1c5c1iW6uVOPVwE/qDUjIn59nOOcy7mcq/vr51zO5VyTI1du/VYCN0j6qKT+MXH31Imp2SiIiPOBtzfIlROXU7/cuHauV26uybpe7cxl3SI64Ea2nIliUMBvAR8F+g9mnHM5l3N1f/2cy7mca3Lkyq1fip1BMXbT14GPAB8enSZ6W+TUrxvWa7K+Xt2Qy1P3TF09DpmKrj+vBM4GbqT4BQGAiFgxnnHO5VzO1f31cy7ncq7JkesA6jcFWAb8OnDzmLirxzlXznpVrl+XrNdkfb06Ppd1h26+hwxgP7ALOAw4nNLOeRDinMu5nKv76+dczuVckyNX5RgV4zWtAFYBp0bE7hby5Navclxu/Tp9vXJjJut6TUAu6wYTfYoud6L4heARYDkw/WDGOZdzOVf318+5nMu5JkeuA6jfV4CfanX5CdgWlevXJes1WV+vjs/lqXumCa9AdsXbe+ByLudyri6vn3M5l3NNjly59cuZ2rkt2jl1+ms8mder07ehp4mZuvoeMjMzMzMzs27Wzd3em5mZmZmZdTU3yMzMzMzMzCaIG2RmZmZmZmYTxA0yMzMzMzOzCeIGmZmZmZmZ2QRxg8zMzMzMzGyC/F91IG84yAlWbAAAAABJRU5ErkJggg==\n",
+      "text/plain": [
+       "<Figure size 1152x720 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "year_df = df.iloc[:,10:]\n",
+    "fig, ax = plt.subplots(figsize=(16,10))\n",
+    "sns.heatmap(year_df.corr(), ax=ax)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "_cell_guid": "43e1af94-ba07-4b95-8da3-1d774db940cd",
+    "_uuid": "70d2b0a7db9b8a5535b3c5b3c2eb927b904bf6d3"
+   },
+   "source": [
+    "So, we gather that a given year's production is more similar to its immediate previous and immediate following years."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {
+    "_cell_guid": "58cde27d-5ddc-4ebe-a8e1-80a8257f44c1",
+    "_uuid": "6f48b52c09ea6a207644044cace5a88c983bf316"
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/anaconda3/lib/python3.7/site-packages/scipy/stats/stats.py:1713: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n",
+      "  return np.add.reduce(sorted[indexer] * weights, axis=axis) / sumval\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 720x720 with 4 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "f, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, sharex='col', sharey='row', figsize=(10,10))\n",
+    "ax1.set(xlabel='Y1968', ylabel='Y1961')\n",
+    "ax2.set(xlabel='Y1968', ylabel='Y1963')\n",
+    "ax3.set(xlabel='Y1968', ylabel='Y1986')\n",
+    "ax4.set(xlabel='Y1968', ylabel='Y2013')\n",
+    "sns.jointplot(x=\"Y1968\", y=\"Y1961\", data=df, kind=\"reg\", ax=ax1)\n",
+    "sns.jointplot(x=\"Y1968\", y=\"Y1963\", data=df, kind=\"reg\", ax=ax2)\n",
+    "sns.jointplot(x=\"Y1968\", y=\"Y1986\", data=df, kind=\"reg\", ax=ax3)\n",
+    "sns.jointplot(x=\"Y1968\", y=\"Y2013\", data=df, kind=\"reg\", ax=ax4)\n",
+    "plt.close(2)\n",
+    "plt.close(3)\n",
+    "plt.close(4)\n",
+    "plt.close(5)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "_cell_guid": "8a297a06-977f-4ff7-a9ad-c7e8804930a8",
+    "_uuid": "6b738ce8b15a764fab90fac96f9534f94c14342e"
+   },
+   "source": [
+    "# Heatmap of production of food items over years\n",
+    "\n",
+    "This will detect the items whose production has drastically increased over the years"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {
+    "_cell_guid": "588cebd9-e97c-460d-8ed5-e663ac293711",
+    "_uuid": "16ce47d43a3038874a74d8bbb9a2e26f6ee54437"
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x1728 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "new_item_df = item_df.drop([\"Item_Name\",\"Sum\",\"Production_Rank\"], axis = 1)\n",
+    "fig, ax = plt.subplots(figsize=(12,24))\n",
+    "sns.heatmap(new_item_df,ax=ax)\n",
+    "ax.set_yticklabels(item_df.Item_Name.values[::-1])\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "_cell_guid": "825620f9-7ab5-4fe2-9529-c4f1a300138e",
+    "_uuid": "5c42595537332ea71089d8c3dc041d3bf7d41b55"
+   },
+   "source": [
+    "There is considerable growth in production of Palmkernel oil, Meat/Aquatic animals, ricebran oil, cottonseed, seafood, offals, roots, poultry meat, mutton, bear, cocoa, coffee and soyabean oil.\n",
+    "There has been exceptional growth in production of onions, cream, sugar crops, treenuts, butter/ghee and to some extent starchy roots."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "_cell_guid": "80428f51-2fd4-468d-9530-9279215b4218",
+    "_uuid": "4c9bb27cd76099c5348243a99448c509ef0c5ded"
+   },
+   "source": [
+    "Now, we look at clustering."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "_cell_guid": "a3f1db3a-1b82-4e42-8e7d-f1a26915693b",
+    "_uuid": "da167de5a5b92e164fc6993b32ebbfab4ef9a6e3",
+    "collapsed": true
+   },
+   "source": [
+    "# What is clustering?\n",
+    "Cluster analysis or clustering is the task of grouping a set of objects in such a way that objects in the same group (called a cluster) are more similar (in some sense) to each other than to those in other groups (clusters). It is a main task of exploratory data mining, and a common technique for statistical data analysis, used in many fields, including machine learning, pattern recognition, image analysis, information retrieval, bioinformatics, data compression, and computer graphics."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "_cell_guid": "136315a0-b37d-4d89-bd0d-037727062c34",
+    "_uuid": "04ab802ec92eaf6a27706f2008933dcf3865855a"
+   },
+   "source": [
+    "# Today, we will form clusters to classify countries based on productivity scale"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "_cell_guid": "27ba0b5d-c57e-485d-9588-017e16fe1904",
+    "_uuid": "659afdada04e8854765b5e7208394915b30f859a"
+   },
+   "source": [
+    "For this, we will use k-means clustering algorithm.\n",
+    "# K-means clustering\n",
+    "(Source [Wikipedia](https://en.wikipedia.org/wiki/K-means_clustering#Standard_algorithm) )\n",
+    "![http://gdurl.com/5BbP](http://gdurl.com/5BbP)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "_cell_guid": "7aeb3175-33bd-4f49-903a-57d43380e90e",
+    "_uuid": "6b0b4881e623ed3c133b68b98e6fb6755e18fd78"
+   },
+   "source": [
+    "This is the data we will use."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {
+    "_cell_guid": "a5b99ea8-975f-4467-9895-bffe1db876eb",
+    "_uuid": "57aba4000bfc422e848b14ad24b02a570d6c0554"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Y1961</th>\n",
+       "      <th>Y1962</th>\n",
+       "      <th>Y1963</th>\n",
+       "      <th>Y1964</th>\n",
+       "      <th>Y1965</th>\n",
+       "      <th>Y1966</th>\n",
+       "      <th>Y1967</th>\n",
+       "      <th>Y1968</th>\n",
+       "      <th>Y1969</th>\n",
+       "      <th>Y1970</th>\n",
+       "      <th>...</th>\n",
+       "      <th>Y2006</th>\n",
+       "      <th>Y2007</th>\n",
+       "      <th>Y2008</th>\n",
+       "      <th>Y2009</th>\n",
+       "      <th>Y2010</th>\n",
+       "      <th>Y2011</th>\n",
+       "      <th>Y2012</th>\n",
+       "      <th>Y2013</th>\n",
+       "      <th>Mean_Produce</th>\n",
+       "      <th>Rank</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>Afghanistan</th>\n",
+       "      <td>9481.0</td>\n",
+       "      <td>9414.0</td>\n",
+       "      <td>9194.0</td>\n",
+       "      <td>10170.0</td>\n",
+       "      <td>10473.0</td>\n",
+       "      <td>10169.0</td>\n",
+       "      <td>11289.0</td>\n",
+       "      <td>11508.0</td>\n",
+       "      <td>11815.0</td>\n",
+       "      <td>10454.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>18317.0</td>\n",
+       "      <td>19248.0</td>\n",
+       "      <td>19381.0</td>\n",
+       "      <td>20661.0</td>\n",
+       "      <td>21030.0</td>\n",
+       "      <td>21100.0</td>\n",
+       "      <td>22706.0</td>\n",
+       "      <td>23007.0</td>\n",
+       "      <td>13003.056604</td>\n",
+       "      <td>69.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Albania</th>\n",
+       "      <td>1706.0</td>\n",
+       "      <td>1749.0</td>\n",
+       "      <td>1767.0</td>\n",
+       "      <td>1889.0</td>\n",
+       "      <td>1884.0</td>\n",
+       "      <td>1995.0</td>\n",
+       "      <td>2046.0</td>\n",
+       "      <td>2169.0</td>\n",
+       "      <td>2230.0</td>\n",
+       "      <td>2395.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>6911.0</td>\n",
+       "      <td>6744.0</td>\n",
+       "      <td>7168.0</td>\n",
+       "      <td>7316.0</td>\n",
+       "      <td>7907.0</td>\n",
+       "      <td>8114.0</td>\n",
+       "      <td>8221.0</td>\n",
+       "      <td>8271.0</td>\n",
+       "      <td>4475.509434</td>\n",
+       "      <td>104.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Algeria</th>\n",
+       "      <td>7488.0</td>\n",
+       "      <td>7235.0</td>\n",
+       "      <td>6861.0</td>\n",
+       "      <td>7255.0</td>\n",
+       "      <td>7509.0</td>\n",
+       "      <td>7536.0</td>\n",
+       "      <td>7986.0</td>\n",
+       "      <td>8839.0</td>\n",
+       "      <td>9003.0</td>\n",
+       "      <td>9355.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>51067.0</td>\n",
+       "      <td>49933.0</td>\n",
+       "      <td>50916.0</td>\n",
+       "      <td>57505.0</td>\n",
+       "      <td>60071.0</td>\n",
+       "      <td>65852.0</td>\n",
+       "      <td>69365.0</td>\n",
+       "      <td>72161.0</td>\n",
+       "      <td>28879.490566</td>\n",
+       "      <td>38.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Angola</th>\n",
+       "      <td>4834.0</td>\n",
+       "      <td>4775.0</td>\n",
+       "      <td>5240.0</td>\n",
+       "      <td>5286.0</td>\n",
+       "      <td>5527.0</td>\n",
+       "      <td>5677.0</td>\n",
+       "      <td>5833.0</td>\n",
+       "      <td>5685.0</td>\n",
+       "      <td>6219.0</td>\n",
+       "      <td>6460.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>28247.0</td>\n",
+       "      <td>29877.0</td>\n",
+       "      <td>32053.0</td>\n",
+       "      <td>36985.0</td>\n",
+       "      <td>38400.0</td>\n",
+       "      <td>40573.0</td>\n",
+       "      <td>38064.0</td>\n",
+       "      <td>48639.0</td>\n",
+       "      <td>13321.056604</td>\n",
+       "      <td>68.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Antigua and Barbuda</th>\n",
+       "      <td>92.0</td>\n",
+       "      <td>94.0</td>\n",
+       "      <td>105.0</td>\n",
+       "      <td>95.0</td>\n",
+       "      <td>84.0</td>\n",
+       "      <td>73.0</td>\n",
+       "      <td>64.0</td>\n",
+       "      <td>59.0</td>\n",
+       "      <td>68.0</td>\n",
+       "      <td>77.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>110.0</td>\n",
+       "      <td>122.0</td>\n",
+       "      <td>115.0</td>\n",
+       "      <td>114.0</td>\n",
+       "      <td>115.0</td>\n",
+       "      <td>118.0</td>\n",
+       "      <td>113.0</td>\n",
+       "      <td>119.0</td>\n",
+       "      <td>83.886792</td>\n",
+       "      <td>172.0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>5 rows × 55 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                      Y1961   Y1962   Y1963    Y1964    Y1965    Y1966  \\\n",
+       "Afghanistan          9481.0  9414.0  9194.0  10170.0  10473.0  10169.0   \n",
+       "Albania              1706.0  1749.0  1767.0   1889.0   1884.0   1995.0   \n",
+       "Algeria              7488.0  7235.0  6861.0   7255.0   7509.0   7536.0   \n",
+       "Angola               4834.0  4775.0  5240.0   5286.0   5527.0   5677.0   \n",
+       "Antigua and Barbuda    92.0    94.0   105.0     95.0     84.0     73.0   \n",
+       "\n",
+       "                       Y1967    Y1968    Y1969    Y1970  ...      Y2006  \\\n",
+       "Afghanistan          11289.0  11508.0  11815.0  10454.0  ...    18317.0   \n",
+       "Albania               2046.0   2169.0   2230.0   2395.0  ...     6911.0   \n",
+       "Algeria               7986.0   8839.0   9003.0   9355.0  ...    51067.0   \n",
+       "Angola                5833.0   5685.0   6219.0   6460.0  ...    28247.0   \n",
+       "Antigua and Barbuda     64.0     59.0     68.0     77.0  ...      110.0   \n",
+       "\n",
+       "                       Y2007    Y2008    Y2009    Y2010    Y2011    Y2012  \\\n",
+       "Afghanistan          19248.0  19381.0  20661.0  21030.0  21100.0  22706.0   \n",
+       "Albania               6744.0   7168.0   7316.0   7907.0   8114.0   8221.0   \n",
+       "Algeria              49933.0  50916.0  57505.0  60071.0  65852.0  69365.0   \n",
+       "Angola               29877.0  32053.0  36985.0  38400.0  40573.0  38064.0   \n",
+       "Antigua and Barbuda    122.0    115.0    114.0    115.0    118.0    113.0   \n",
+       "\n",
+       "                       Y2013  Mean_Produce   Rank  \n",
+       "Afghanistan          23007.0  13003.056604   69.0  \n",
+       "Albania               8271.0   4475.509434  104.0  \n",
+       "Algeria              72161.0  28879.490566   38.0  \n",
+       "Angola               48639.0  13321.056604   68.0  \n",
+       "Antigua and Barbuda    119.0     83.886792  172.0  \n",
+       "\n",
+       "[5 rows x 55 columns]"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "new_df.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {
+    "_cell_guid": "66964df2-892d-4e55-a4b1-f94d10e4c7dd",
+    "_uuid": "19bdd89a3ad9df962959ad6b996946f6f3916d58"
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:4: FutureWarning: convert_objects is deprecated.  To re-infer data dtypes for object columns, use DataFrame.infer_objects()\n",
+      "For all other conversions use the data-type specific converters pd.to_datetime, pd.to_timedelta and pd.to_numeric.\n",
+      "  after removing the cwd from sys.path.\n"
+     ]
+    }
+   ],
+   "source": [
+    "X = new_df.iloc[:,:-2].values\n",
+    "\n",
+    "X = pd.DataFrame(X)\n",
+    "X = X.convert_objects(convert_numeric=True)\n",
+    "X.columns = year_list"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "_cell_guid": "461e5bcc-0101-4ea1-ae13-20600f883929",
+    "_uuid": "0d3e50235c9505ebc255053d4a5aae547fc17d8d"
+   },
+   "source": [
+    "# Elbow method to select number of clusters\n",
+    "This method looks at the percentage of variance explained as a function of the number of clusters: One should choose a number of clusters so that adding another cluster doesn't give much better modeling of the data. More precisely, if one plots the percentage of variance explained by the clusters against the number of clusters, the first clusters will add much information (explain a lot of variance), but at some point the marginal gain will drop, giving an angle in the graph. The number of clusters is chosen at this point, hence the \"elbow criterion\". This \"elbow\" cannot always be unambiguously identified. Percentage of variance explained is the ratio of the between-group variance to the total variance, also known as an F-test. A slight variation of this method plots the curvature of the within group variance.\n",
+    "# Basically, number of clusters = the x-axis value of the point that is the corner of the \"elbow\"(the plot looks often looks like an elbow)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {
+    "_cell_guid": "06271223-bd32-48ac-a373-6c1e6bbf7c7b",
+    "_uuid": "c57d7277510a8c11fdc3d311e4d8a22539617ed9"
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from sklearn.cluster import KMeans\n",
+    "wcss = []\n",
+    "for i in range(1,11):\n",
+    "    kmeans = KMeans(n_clusters=i,init='k-means++',max_iter=300,n_init=10,random_state=0)\n",
+    "    kmeans.fit(X)\n",
+    "    wcss.append(kmeans.inertia_)\n",
+    "plt.plot(range(1,11),wcss)\n",
+    "plt.title('The Elbow Method')\n",
+    "plt.xlabel('Number of clusters')\n",
+    "plt.ylabel('WCSS')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "_cell_guid": "ad4bc40a-9540-497d-95e3-3fee6088ea95",
+    "_uuid": "6450dd1c3d7a8114931dc358d2f09a0424b52fd7"
+   },
+   "source": [
+    "As the elbow corner coincides with x=2, we will have to form **2 clusters**. Personally, I would have liked to select 3 to 4 clusters. But trust me, only selecting 2 clusters can lead to best results.\n",
+    "Now, we apply k-means algorithm."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {
+    "_cell_guid": "eed3f672-e089-4dbb-aad8-b9618967abf3",
+    "_uuid": "d92d758ee7213ddcd84e9b8b2f61c9e260ed6ba2"
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:4: FutureWarning: Method .as_matrix will be removed in a future version. Use .values instead.\n",
+      "  after removing the cwd from sys.path.\n"
+     ]
+    }
+   ],
+   "source": [
+    "kmeans = KMeans(n_clusters=2,init='k-means++',max_iter=300,n_init=10,random_state=0) \n",
+    "y_kmeans = kmeans.fit_predict(X)\n",
+    "\n",
+    "X = X.as_matrix(columns=None)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "_cell_guid": "ef07bd6d-679d-4375-b7b3-abeca3421e37",
+    "_uuid": "6f93a4bd3f17427f4b2dbe08af8e015a1e4a2f89"
+   },
+   "source": [
+    "Now, let's visualize the results."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {
+    "_cell_guid": "5a7fe139-13df-453b-8c16-891929bc595e",
+    "_uuid": "a57e0a38f4c0f0385be75fd9f71d4a2d8213aea3"
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.scatter(X[y_kmeans == 0, 0], X[y_kmeans == 0,1],s=100,c='red',label='Others')\n",
+    "plt.scatter(X[y_kmeans == 1, 0], X[y_kmeans == 1,1],s=100,c='blue',label='China(mainland),USA,India')\n",
+    "plt.scatter(kmeans.cluster_centers_[:,0],kmeans.cluster_centers_[:,1],s=300,c='yellow',label='Centroids')\n",
+    "plt.title('Clusters of countries by Productivity')\n",
+    "plt.legend()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "_cell_guid": "923d4536-2bce-4b99-b98a-33b801a56a8b",
+    "_uuid": "fe531e8c41eec0eb5dc52a9890871841f5d27211"
+   },
+   "source": [
+    "So, the blue cluster represents China(Mainland), USA and India while the red cluster represents all the other countries.\n",
+    "This result was highly probable. Just take a look at the plot of cell 3 above. See how China, USA and India stand out. That has been observed here in clustering too.\n",
+    "\n",
+    "You should try this algorithm for 3 or 4 clusters. Looking at the distribution, you will realise why 2 clusters is the best choice for the given data"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "_cell_guid": "6dee7acb-0f08-4ae1-85b4-f4704026694a",
+    "_uuid": "179a1ede21ae330664a0b7c63e36574acdc0428c"
+   },
+   "source": [
+    "This is not the end! More is yet to come."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Now, lets try to predict the production using regression for 2020. We will predict the production for USA,India and Pakistan.**\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "ename": "ValueError",
+     "evalue": "Expected 2D array, got scalar array instead:\narray=2020.\nReshape your data either using array.reshape(-1, 1) if your data has a single feature or array.reshape(1, -1) if it contains a single sample.",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
+      "\u001b[0;32m<ipython-input-24-da7cfa1c86d1>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     27\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mreset\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mpredictions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     28\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 29\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mreg\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpredict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m2020\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     30\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     31\u001b[0m \u001b[0mdf\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mArea\u001b[0m\u001b[0;34m==\u001b[0m\u001b[0;34m'India'\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m&\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mdf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mElement\u001b[0m\u001b[0;34m==\u001b[0m\u001b[0;34m'Food'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Y1961'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmean\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/base.py\u001b[0m in \u001b[0;36mpredict\u001b[0;34m(self, X)\u001b[0m\n\u001b[1;32m    211\u001b[0m             \u001b[0mReturns\u001b[0m \u001b[0mpredicted\u001b[0m \u001b[0mvalues\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    212\u001b[0m         \"\"\"\n\u001b[0;32m--> 213\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_decision_function\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    214\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    215\u001b[0m     \u001b[0m_preprocess_data\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mstaticmethod\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_preprocess_data\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/base.py\u001b[0m in \u001b[0;36m_decision_function\u001b[0;34m(self, X)\u001b[0m\n\u001b[1;32m    194\u001b[0m         \u001b[0mcheck_is_fitted\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"coef_\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    195\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 196\u001b[0;31m         \u001b[0mX\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcheck_array\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maccept_sparse\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'csr'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'csc'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'coo'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    197\u001b[0m         return safe_sparse_dot(X, self.coef_.T,\n\u001b[1;32m    198\u001b[0m                                dense_output=True) + self.intercept_\n",
+      "\u001b[0;32m/anaconda3/lib/python3.7/site-packages/sklearn/utils/validation.py\u001b[0m in \u001b[0;36mcheck_array\u001b[0;34m(array, accept_sparse, accept_large_sparse, dtype, order, copy, force_all_finite, ensure_2d, allow_nd, ensure_min_samples, ensure_min_features, warn_on_dtype, estimator)\u001b[0m\n\u001b[1;32m    543\u001b[0m                     \u001b[0;34m\"Reshape your data either using array.reshape(-1, 1) if \"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    544\u001b[0m                     \u001b[0;34m\"your data has a single feature or array.reshape(1, -1) \"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 545\u001b[0;31m                     \"if it contains a single sample.\".format(array))\n\u001b[0m\u001b[1;32m    546\u001b[0m             \u001b[0;31m# If input is 1D raise error\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    547\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0marray\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mndim\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;31mValueError\u001b[0m: Expected 2D array, got scalar array instead:\narray=2020.\nReshape your data either using array.reshape(-1, 1) if your data has a single feature or array.reshape(1, -1) if it contains a single sample."
+     ]
+    }
+   ],
+   "source": [
+    "india_list=[]\n",
+    "year_list = list(df.iloc[:,10:].columns)\n",
+    "for i in year_list:\n",
+    "    x=df[(df.Area=='India') & (df.Element=='Food')][i].mean()\n",
+    "    india_list.append(x)    \n",
+    "\n",
+    "reset=[]\n",
+    "for i in year_list:\n",
+    "    reset.append(int(i[1:]))\n",
+    "\n",
+    "\n",
+    "reset=np.array(reset)\n",
+    "reset=reset.reshape(-1,1)\n",
+    "\n",
+    "\n",
+    "india_list=np.array(india_list)\n",
+    "india_list=india_list.reshape(-1,1)\n",
+    "\n",
+    "\n",
+    "reg = LinearRegression()\n",
+    "reg.fit(reset,india_list)\n",
+    "predictions = reg.predict(reset)\n",
+    "plt.title(\"India\")\n",
+    "plt.xlabel(\"Year\")\n",
+    "plt.ylabel(\"Production\")\n",
+    "plt.scatter(reset,india_list)\n",
+    "plt.plot(reset,predictions)\n",
+    "plt.show()\n",
+    "print(reg.predict(2020))\n",
+    "\n",
+    "df[(df.Area=='India') & (df.Element=='Food')]['Y1961'].mean()\n",
+    "\n",
+    "df[(df.Area=='Pakistan') & (df.Element=='Food')]\n",
+    "\n",
+    "Pak_list=[]\n",
+    "year_list = list(df.iloc[:,10:].columns)\n",
+    "for i in year_list:\n",
+    "    yx=df[(df.Area=='Pakistan') & (df.Element=='Food')][i].mean()\n",
+    "    Pak_list.append(yx)   \n",
+    "\n",
+    "Pak_list=np.array(Pak_list)\n",
+    "Pak_list=Pak_list.reshape(-1,1)\n",
+    "Pak_list\n",
+    "reg = LinearRegression()\n",
+    "reg.fit(reset,Pak_list)\n",
+    "predictions = reg.predict(reset)\n",
+    "plt.title(\"Pakistan\")\n",
+    "plt.xlabel(\"Year\")\n",
+    "plt.ylabel(\"Production\")\n",
+    "plt.scatter(reset,Pak_list)\n",
+    "plt.plot(reset,predictions)\n",
+    "plt.show()\n",
+    "print(reg.predict(2020))\n",
+    "\n",
+    "\n",
+    "\n",
+    "usa_list=[]\n",
+    "year_list = list(df.iloc[:,10:].columns)\n",
+    "for i in year_list:\n",
+    "    xu=df[(df.Area=='United States of America') & (df.Element=='Food')][i].mean()\n",
+    "    usa_list.append(xu)\n",
+    "\n",
+    "usa_list=np.array(usa_list)\n",
+    "usa_list=india_list.reshape(-1,1)\n",
+    "\n",
+    "\n",
+    "reg = LinearRegression()\n",
+    "reg.fit(reset,usa_list)\n",
+    "predictions = reg.predict(reset)\n",
+    "plt.title(\"USA\")\n",
+    "plt.xlabel(\"Year\")\n",
+    "plt.ylabel(\"Production\")\n",
+    "plt.scatter(reset,usa_list)\n",
+    "plt.plot(reset,predictions)\n",
+    "plt.show()\n",
+    "print(reg.predict(2020))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}

From 628794d89de355e87ae51ed022cf242dac30ea47 Mon Sep 17 00:00:00 2001
From: obelisk0114 <obelisk0114@gmail.com>
Date: Sat, 13 Jul 2019 22:45:54 -0700
Subject: [PATCH 115/348] Add combinations (#1015)

* Update Bucket Sort time complexity analysis

* Add combinations

* Adding doctest

* Fix doctest problem
---
 backtracking/all_combinations.py | 41 ++++++++++++++++++++++++++++++++
 1 file changed, 41 insertions(+)
 create mode 100644 backtracking/all_combinations.py

diff --git a/backtracking/all_combinations.py b/backtracking/all_combinations.py
new file mode 100644
index 000000000000..63425aeabbd1
--- /dev/null
+++ b/backtracking/all_combinations.py
@@ -0,0 +1,41 @@
+# -*- coding: utf-8 -*-
+
+"""
+	In this problem, we want to determine all possible combinations of k
+	numbers out of 1 ... n. We use backtracking to solve this problem.
+	Time complexity: O(C(n,k)) which is O(n choose k) = O((n!/(k! * (n - k)!)))
+"""
+
+
+def generate_all_combinations(n: int, k: int) -> [[int]]:
+    """
+    >>> generate_all_combinations(n=4, k=2)
+    [[1, 2], [1, 3], [1, 4], [2, 3], [2, 4], [3, 4]]
+    """
+    
+    result = []
+    create_all_state(1, n, k, [], result)
+    return result
+
+
+def create_all_state(increment, total_number, level, current_list, total_list):
+    if level == 0:
+        total_list.append(current_list[:])
+        return
+
+    for i in range(increment, total_number - level + 2):
+        current_list.append(i)
+        create_all_state(i + 1, total_number, level - 1, current_list, total_list)
+        current_list.pop()
+
+
+def print_all_state(total_list):
+    for i in total_list:
+        print(*i)
+
+
+if __name__ == '__main__':
+    n = 4
+    k = 2
+    total_list = generate_all_combinations(n, k)
+    print_all_state(total_list)

From 3b2738ed89a4ecb1cfb6f16aa96bb90701914796 Mon Sep 17 00:00:00 2001
From: obelisk0114 <obelisk0114@gmail.com>
Date: Sun, 14 Jul 2019 23:48:35 -0700
Subject: [PATCH 116/348] Add rotate matrix problem (#1021)

* Add rotate matrix problem

* Fix doctest

* Adding return matrix to enable doctest
---
 matrix/rotate_matrix.py | 99 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 99 insertions(+)
 create mode 100644 matrix/rotate_matrix.py

diff --git a/matrix/rotate_matrix.py b/matrix/rotate_matrix.py
new file mode 100644
index 000000000000..e3495e647954
--- /dev/null
+++ b/matrix/rotate_matrix.py
@@ -0,0 +1,99 @@
+# -*- coding: utf-8 -*-
+
+"""
+	In this problem, we want to rotate the matrix elements by 90, 180, 270 (counterclockwise)
+	Discussion in stackoverflow: 
+   https://stackoverflow.com/questions/42519/how-do-you-rotate-a-two-dimensional-array
+"""
+
+
+def rotate_90(matrix: [[]]):
+    """
+    >>> rotate_90([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]])
+    [[4, 8, 12, 16], [3, 7, 11, 15], [2, 6, 10, 14], [1, 5, 9, 13]]
+    """
+    
+    transpose(matrix)
+    reverse_row(matrix)
+    return matrix
+    
+
+def rotate_180(matrix: [[]]):
+    """
+    >>> rotate_180([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]])
+    [[16, 15, 14, 13], [12, 11, 10, 9], [8, 7, 6, 5], [4, 3, 2, 1]]
+    """
+    
+    reverse_column(matrix)
+    reverse_row(matrix)
+    
+    """
+    OR
+    
+    reverse_row(matrix)
+    reverse_column(matrix)
+    """
+    
+    return matrix
+
+    
+def rotate_270(matrix: [[]]):
+    """
+    >>> rotate_270([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]])
+    [[13, 9, 5, 1], [14, 10, 6, 2], [15, 11, 7, 3], [16, 12, 8, 4]]
+    """
+    
+    transpose(matrix)
+    reverse_column(matrix)
+    
+    """
+    OR
+    
+    reverse_row(matrix)
+    transpose(matrix)
+    """
+    
+    return matrix
+
+
+def transpose(matrix: [[]]):
+    matrix[:] = [list(x) for x in zip(*matrix)]
+    return matrix
+    
+    
+def reverse_row(matrix: [[]]):
+    matrix[:] = matrix[::-1]
+    return matrix
+
+
+def reverse_column(matrix: [[]]):
+    matrix[:] = [x[::-1] for x in matrix]
+    return matrix
+    
+    
+def print_matrix(matrix: [[]]):
+    for i in matrix:
+        print(*i)
+
+
+if __name__ == '__main__':
+    matrix = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]]
+    print("\norigin:\n")
+    print_matrix(matrix)
+    rotate_90(matrix)
+    print("\nrotate 90 counterclockwise:\n")
+    print_matrix(matrix)
+
+    matrix = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]]
+    print("\norigin:\n")
+    print_matrix(matrix)
+    rotate_180(matrix)
+    print("\nrotate 180:\n")
+    print_matrix(matrix)
+
+    matrix = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]]
+    print("\norigin:\n")
+    print_matrix(matrix)
+    rotate_270(matrix)
+    print("\nrotate 270 counterclockwise:\n")
+    print_matrix(matrix)

From 1e55bfd4da5a15d8e8536a1a87ad148c69b16a1e Mon Sep 17 00:00:00 2001
From: Sanders Lin <45224617+SandersLin@users.noreply.github.com>
Date: Tue, 16 Jul 2019 00:17:41 +0800
Subject: [PATCH 117/348] Create climbing_stairs.py (#1002)

a simple dp problem seen on LeetCode:  https://leetcode.com/problems/climbing-stairs/
---
 dynamic_programming/climbing_stairs.py | 27 ++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 dynamic_programming/climbing_stairs.py

diff --git a/dynamic_programming/climbing_stairs.py b/dynamic_programming/climbing_stairs.py
new file mode 100644
index 000000000000..8a6213b22323
--- /dev/null
+++ b/dynamic_programming/climbing_stairs.py
@@ -0,0 +1,27 @@
+def climb_stairs(n: int) -> int:
+  """
+  LeetCdoe No.70: Climbing Stairs
+  Distinct ways to climb a n step staircase where
+  each time you can either climb 1 or 2 steps. 
+
+  Args:
+      n: number of steps of staircase
+
+  Returns:
+      Distinct ways to climb a n step staircase 
+
+  Raises:
+      AssertionError: n not positive integer
+
+  >>> climb_stairs(3) 
+  3
+  >>> climb_stairs(1)
+  1
+  """
+  assert isinstance(n,int) and n > 0, "n needs to be positive integer, your input {0}".format(0)
+  if n == 1: return 1 
+  dp = [0]*(n+1)
+  dp[0], dp[1] = (1, 1)
+  for i in range(2,n+1): 
+      dp[i] = dp[i-1] + dp[i-2]
+  return dp[n]

From 2fb3beeaf1215a1be4a7bc97097ef6a33fd65aeb Mon Sep 17 00:00:00 2001
From: cclauss <cclauss@me.com>
Date: Tue, 16 Jul 2019 07:26:28 +0200
Subject: [PATCH 118/348] Fix error message and format with python/black
 (#1025)

@SandersLin Your review please?
---
 dynamic_programming/climbing_stairs.py | 67 ++++++++++++++++----------
 1 file changed, 41 insertions(+), 26 deletions(-)

diff --git a/dynamic_programming/climbing_stairs.py b/dynamic_programming/climbing_stairs.py
index 8a6213b22323..79605261f981 100644
--- a/dynamic_programming/climbing_stairs.py
+++ b/dynamic_programming/climbing_stairs.py
@@ -1,27 +1,42 @@
+#!/usr/bin/env python3
+
+
 def climb_stairs(n: int) -> int:
-  """
-  LeetCdoe No.70: Climbing Stairs
-  Distinct ways to climb a n step staircase where
-  each time you can either climb 1 or 2 steps. 
-
-  Args:
-      n: number of steps of staircase
-
-  Returns:
-      Distinct ways to climb a n step staircase 
-
-  Raises:
-      AssertionError: n not positive integer
-
-  >>> climb_stairs(3) 
-  3
-  >>> climb_stairs(1)
-  1
-  """
-  assert isinstance(n,int) and n > 0, "n needs to be positive integer, your input {0}".format(0)
-  if n == 1: return 1 
-  dp = [0]*(n+1)
-  dp[0], dp[1] = (1, 1)
-  for i in range(2,n+1): 
-      dp[i] = dp[i-1] + dp[i-2]
-  return dp[n]
+    """
+    LeetCdoe No.70: Climbing Stairs
+    Distinct ways to climb a n step staircase where
+    each time you can either climb 1 or 2 steps.
+
+    Args:
+        n: number of steps of staircase
+
+    Returns:
+        Distinct ways to climb a n step staircase
+
+    Raises:
+        AssertionError: n not positive integer
+
+    >>> climb_stairs(3)
+    3
+    >>> climb_stairs(1)
+    1
+    >>> climb_stairs(-7)  # doctest: +ELLIPSIS
+    Traceback (most recent call last):
+        ...
+    AssertionError: n needs to be positive integer, your input -7
+    """
+    fmt = "n needs to be positive integer, your input {}"
+    assert isinstance(n, int) and n > 0, fmt.format(n)
+    if n == 1:
+        return 1
+    dp = [0] * (n + 1)
+    dp[0], dp[1] = (1, 1)
+    for i in range(2, n + 1):
+        dp[i] = dp[i - 1] + dp[i - 2]
+    return dp[n]
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()

From 267b5eff40409034322d046b3b0054ac3462cf9e Mon Sep 17 00:00:00 2001
From: Bruno Simas Hadlich <brunosimashadlich@gmail.com>
Date: Tue, 16 Jul 2019 20:09:53 -0300
Subject: [PATCH 119/348] Added doctest and more explanation about Dijkstra
 execution. (#1014)

* Added doctest and more explanation about Dijkstra execution.

* tests were not passing with python2 due to missing __init__.py file at number_theory folder

* Removed the dot at the beginning of the imported modules names because 'python3 -m doctest -v data_structures/hashing/*.py' and 'python3 -m doctest -v data_structures/stacks/*.py' were failing not finding hash_table.py and stack.py modules.

* Moved global code to main scope and added doctest for project euler problems 1 to 14.

* Added test case for negative input.

* Changed N variable to do not use end of line scape because in case there is a space after it the script will break making it much more error prone.

* Added problems description and doctests to the ones that were missing. Limited line length to 79 and executed python black over all scripts.

* Changed the way files are loaded to support pytest call.

* Added __init__.py to problems to make them modules and allow pytest execution.

* Added project_euler folder to test units execution

* Changed 'os.path.split(os.path.realpath(__file__))' to 'os.path.dirname()'
---
 .travis.yml                                   |   1 +
 data_structures/hashing/double_hash.py        |   2 +-
 .../hashing/hash_table_with_linked_list.py    |   2 +-
 .../hashing/number_theory/__init__.py         |   0
 data_structures/hashing/quadratic_probing.py  |   2 +-
 .../stacks/infix_to_postfix_conversion.py     |   2 +-
 graphs/dijkstra.py                            | 117 +++-
 project_euler/problem_01/__init__.py          |   0
 project_euler/problem_01/sol1.py              |  31 +-
 project_euler/problem_01/sol2.py              |  43 +-
 project_euler/problem_01/sol3.py              |  98 +--
 project_euler/problem_01/sol4.py              |  47 +-
 project_euler/problem_01/sol5.py              |  30 +-
 project_euler/problem_01/sol6.py              |  49 +-
 project_euler/problem_02/__init__.py          |   0
 project_euler/problem_02/sol1.py              |  57 +-
 project_euler/problem_02/sol2.py              |  46 +-
 project_euler/problem_02/sol3.py              |  63 +-
 project_euler/problem_02/sol4.py              |  48 +-
 project_euler/problem_03/__init__.py          |   0
 project_euler/problem_03/sol1.py              |  76 ++-
 project_euler/problem_03/sol2.py              |  52 +-
 project_euler/problem_04/__init__.py          |   0
 project_euler/problem_04/sol1.py              |  61 +-
 project_euler/problem_04/sol2.py              |  47 +-
 project_euler/problem_05/__init__.py          |   0
 project_euler/problem_05/sol1.py              |  59 +-
 project_euler/problem_05/sol2.py              |  60 +-
 project_euler/problem_06/__init__.py          |   0
 project_euler/problem_06/sol1.py              |  52 +-
 project_euler/problem_06/sol2.py              |  47 +-
 project_euler/problem_06/sol3.py              |  47 +-
 project_euler/problem_07/__init__.py          |   0
 project_euler/problem_07/sol1.py              |  73 ++-
 project_euler/problem_07/sol2.py              |  67 +-
 project_euler/problem_07/sol3.py              |  47 +-
 project_euler/problem_08/__init__.py          |   0
 project_euler/problem_08/sol1.py              |  75 ++-
 project_euler/problem_08/sol2.py              |  77 ++-
 project_euler/problem_09/__init__.py          |   0
 project_euler/problem_09/sol1.py              |  49 +-
 project_euler/problem_09/sol2.py              |  60 +-
 project_euler/problem_09/sol3.py              |  43 +-
 project_euler/problem_10/__init__.py          |   0
 project_euler/problem_10/sol1.py              |  78 ++-
 project_euler/problem_10/sol2.py              |  49 +-
 project_euler/problem_11/__init__.py          |   0
 project_euler/problem_11/sol1.py              |  97 ++-
 project_euler/problem_11/sol2.py              | 129 ++--
 project_euler/problem_12/__init__.py          |   0
 project_euler/problem_12/sol1.py              |  73 ++-
 project_euler/problem_12/sol2.py              |  59 +-
 project_euler/problem_13/__init__.py          |   0
 project_euler/problem_13/sol1.py              |  38 +-
 project_euler/problem_13/sol2.py              |   5 -
 project_euler/problem_14/__init__.py          |   0
 project_euler/problem_14/sol1.py              |  92 ++-
 project_euler/problem_14/sol2.py              |  83 ++-
 project_euler/problem_15/__init__.py          |   0
 project_euler/problem_15/sol1.py              |  71 ++-
 project_euler/problem_16/__init__.py          |   0
 project_euler/problem_16/sol1.py              |  37 +-
 project_euler/problem_16/sol2.py              |  34 +-
 project_euler/problem_17/__init__.py          |   0
 project_euler/problem_17/sol1.py              |  92 ++-
 project_euler/problem_19/__init__.py          |   0
 project_euler/problem_19/sol1.py              |  75 ++-
 project_euler/problem_20/__init__.py          |   0
 project_euler/problem_20/sol1.py              |  50 +-
 project_euler/problem_20/sol2.py              |  36 +-
 project_euler/problem_21/__init__.py          |   0
 project_euler/problem_21/sol1.py              |  69 ++-
 project_euler/problem_22/__init__.py          |   0
 project_euler/problem_22/sol1.py              |  59 +-
 project_euler/problem_22/sol2.py              | 572 ++----------------
 project_euler/problem_234/__init__.py         |   0
 project_euler/problem_234/sol1.py             |  52 +-
 project_euler/problem_24/__init__.py          |   0
 project_euler/problem_24/sol1.py              |  30 +-
 project_euler/problem_25/__init__.py          |   0
 project_euler/problem_25/sol1.py              |  84 ++-
 project_euler/problem_25/sol2.py              |  67 +-
 project_euler/problem_28/__init__.py          |   0
 project_euler/problem_28/sol1.py              |  77 ++-
 project_euler/problem_29/__init__.py          |   0
 project_euler/problem_29/solution.py          |  64 +-
 project_euler/problem_31/__init__.py          |   0
 project_euler/problem_31/sol1.py              |  34 +-
 project_euler/problem_36/__init__.py          |   0
 project_euler/problem_36/sol1.py              |  61 +-
 project_euler/problem_40/__init__.py          |   0
 project_euler/problem_40/sol1.py              |  47 +-
 project_euler/problem_48/__init__.py          |   0
 project_euler/problem_48/sol1.py              |  26 +-
 project_euler/problem_52/__init__.py          |   0
 project_euler/problem_52/sol1.py              |  46 +-
 project_euler/problem_53/__init__.py          |   0
 project_euler/problem_53/sol1.py              |  46 +-
 project_euler/problem_76/__init__.py          |   0
 project_euler/problem_76/sol1.py              |  57 +-
 100 files changed, 2651 insertions(+), 1468 deletions(-)
 create mode 100644 data_structures/hashing/number_theory/__init__.py
 create mode 100644 project_euler/problem_01/__init__.py
 create mode 100644 project_euler/problem_02/__init__.py
 create mode 100644 project_euler/problem_03/__init__.py
 create mode 100644 project_euler/problem_04/__init__.py
 create mode 100644 project_euler/problem_05/__init__.py
 create mode 100644 project_euler/problem_06/__init__.py
 create mode 100644 project_euler/problem_07/__init__.py
 create mode 100644 project_euler/problem_08/__init__.py
 create mode 100644 project_euler/problem_09/__init__.py
 create mode 100644 project_euler/problem_10/__init__.py
 create mode 100644 project_euler/problem_11/__init__.py
 create mode 100644 project_euler/problem_12/__init__.py
 create mode 100644 project_euler/problem_13/__init__.py
 delete mode 100644 project_euler/problem_13/sol2.py
 create mode 100644 project_euler/problem_14/__init__.py
 create mode 100644 project_euler/problem_15/__init__.py
 create mode 100644 project_euler/problem_16/__init__.py
 create mode 100644 project_euler/problem_17/__init__.py
 create mode 100644 project_euler/problem_19/__init__.py
 create mode 100644 project_euler/problem_20/__init__.py
 create mode 100644 project_euler/problem_21/__init__.py
 create mode 100644 project_euler/problem_22/__init__.py
 create mode 100644 project_euler/problem_234/__init__.py
 create mode 100644 project_euler/problem_24/__init__.py
 create mode 100644 project_euler/problem_25/__init__.py
 create mode 100644 project_euler/problem_28/__init__.py
 create mode 100644 project_euler/problem_29/__init__.py
 create mode 100644 project_euler/problem_31/__init__.py
 create mode 100644 project_euler/problem_36/__init__.py
 create mode 100644 project_euler/problem_40/__init__.py
 create mode 100644 project_euler/problem_48/__init__.py
 create mode 100644 project_euler/problem_52/__init__.py
 create mode 100644 project_euler/problem_53/__init__.py
 create mode 100644 project_euler/problem_76/__init__.py

diff --git a/.travis.yml b/.travis.yml
index 9afc0c93a037..3b55045ac33f 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -26,6 +26,7 @@ script:
       matrix
       networking_flow
       other
+      project_euler
       searches
       sorts
       strings
diff --git a/data_structures/hashing/double_hash.py b/data_structures/hashing/double_hash.py
index 60098cda0ce1..7a0ce0b3a67b 100644
--- a/data_structures/hashing/double_hash.py
+++ b/data_structures/hashing/double_hash.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 
-from .hash_table import HashTable
+from hash_table import HashTable
 from number_theory.prime_numbers import next_prime, check_prime
 
 
diff --git a/data_structures/hashing/hash_table_with_linked_list.py b/data_structures/hashing/hash_table_with_linked_list.py
index 9689e4fc9fcf..a45876df49bd 100644
--- a/data_structures/hashing/hash_table_with_linked_list.py
+++ b/data_structures/hashing/hash_table_with_linked_list.py
@@ -1,4 +1,4 @@
-from .hash_table import HashTable
+from hash_table import HashTable
 from collections import deque
 
 
diff --git a/data_structures/hashing/number_theory/__init__.py b/data_structures/hashing/number_theory/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/data_structures/hashing/quadratic_probing.py b/data_structures/hashing/quadratic_probing.py
index f7a9ac1ae347..1e61100a81fa 100644
--- a/data_structures/hashing/quadratic_probing.py
+++ b/data_structures/hashing/quadratic_probing.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 
-from .hash_table import HashTable
+from hash_table import HashTable
 
 
 class QuadraticProbing(HashTable):
diff --git a/data_structures/stacks/infix_to_postfix_conversion.py b/data_structures/stacks/infix_to_postfix_conversion.py
index 75211fed258d..e71dccf1f45c 100644
--- a/data_structures/stacks/infix_to_postfix_conversion.py
+++ b/data_structures/stacks/infix_to_postfix_conversion.py
@@ -2,7 +2,7 @@
 from __future__ import absolute_import
 import string
 
-from .Stack import Stack
+from stack import Stack
 
 __author__ = 'Omkar Pathak'
 
diff --git a/graphs/dijkstra.py b/graphs/dijkstra.py
index 4b6bc347b061..52354b5c916b 100644
--- a/graphs/dijkstra.py
+++ b/graphs/dijkstra.py
@@ -1,24 +1,50 @@
 """pseudo-code"""
 
 """
-DIJKSTRA(graph G, start vertex s,destination vertex d):
-// all nodes initially unexplored
-let H = min heap data structure, initialized with 0 and s [here 0 indicates the distance from start vertex]
-while H is non-empty:
-    remove the first node and cost of H, call it U and cost
-    if U is not explored
-    mark U as explored
-    if U is d:
-        return cost // total cost from start to destination vertex
-    for each edge(U, V): c=cost of edge(u,V) // for V in graph[U]
-        if V unexplored:
-            next=cost+c
-            add next,V to H (at the end)
+DIJKSTRA(graph G, start vertex s, destination vertex d):
+
+//all nodes initially unexplored
+
+1 -  let H = min heap data structure, initialized with 0 and s [here 0 indicates
+     the distance from start vertex s]
+2 -  while H is non-empty:
+3 -    remove the first node and cost of H, call it U and cost
+4 -    if U has been previously explored:
+5 -      go to the while loop, line 2 //Once a node is explored there is no need
+         to make it again
+6 -    mark U as explored
+7 -    if U is d:
+8 -      return cost // total cost from start to destination vertex
+9 -    for each edge(U, V): c=cost of edge(U,V) // for V in graph[U]
+10 -     if V explored:
+11 -       go to next V in line 9
+12 -     total_cost = cost + c
+13 -     add (total_cost,V) to H
+
+You can think at cost as a distance where Dijkstra finds the shortest distance
+between vertexes s and v in a graph G. The use of a min heap as H guarantees
+that if a vertex has already been explored there will be no other path with
+shortest distance, that happens because heapq.heappop will always return the
+next vertex with the shortest distance, considering that the heap stores not
+only the distance between previous vertex and current vertex but the entire
+distance between each vertex that makes up the path from start vertex to target
+vertex.
 """
+
 import heapq
 
 
 def dijkstra(graph, start, end):
+    """Return the cost of the shortest path between vertexes start and end.
+
+    >>> dijkstra(G, "E", "C")
+    6
+    >>> dijkstra(G2, "E", "F")
+    3
+    >>> dijkstra(G3, "E", "F")
+    3
+    """
+
     heap = [(0, start)]  # cost from start node,end node
     visited = set()
     while heap:
@@ -28,20 +54,65 @@ def dijkstra(graph, start, end):
         visited.add(u)
         if u == end:
             return cost
-        for v, c in G[u]:
+        for v, c in graph[u]:
             if v in visited:
                 continue
             next = cost + c
             heapq.heappush(heap, (next, v))
-    return (-1, -1)
+    return -1
+
+
+G = {
+    "A": [["B", 2], ["C", 5]],
+    "B": [["A", 2], ["D", 3], ["E", 1], ["F", 1]],
+    "C": [["A", 5], ["F", 3]],
+    "D": [["B", 3]],
+    "E": [["B", 4], ["F", 3]],
+    "F": [["C", 3], ["E", 3]],
+}
+
+"""
+Layout of G2:
+
+E -- 1 --> B -- 1 --> C -- 1 --> D -- 1 --> F
+ \                                         /\
+  \                                        ||
+    ----------------- 3 --------------------
+"""
+G2 = {
+    "B": [["C", 1]],
+    "C": [["D", 1]],
+    "D": [["F", 1]],
+    "E": [["B", 1], ["F", 3]],
+    "F": [],
+}
+
+"""
+Layout of G3:
+
+E -- 1 --> B -- 1 --> C -- 1 --> D -- 1 --> F
+ \                                         /\
+  \                                        ||
+    -------- 2 ---------> G ------- 1 ------
+"""
+G3 = {
+    "B": [["C", 1]],
+    "C": [["D", 1]],
+    "D": [["F", 1]],
+    "E": [["B", 1], ["G", 2]],
+    "F": [],
+    "G": [["F", 1]],
+}
+
+shortDistance = dijkstra(G, "E", "C")
+print(shortDistance)  # E -- 3 --> F -- 3 --> C == 6
 
+shortDistance = dijkstra(G2, "E", "F")
+print(shortDistance)  # E -- 3 --> F == 3
 
-G = {'A': [['B', 2], ['C', 5]],
-     'B': [['A', 2], ['D', 3], ['E', 1]],
-     'C': [['A', 5], ['F', 3]],
-     'D': [['B', 3]],
-     'E': [['B', 1], ['F', 3]],
-     'F': [['C', 3], ['E', 3]]}
+shortDistance = dijkstra(G3, "E", "F")
+print(shortDistance)  # E -- 2 --> G -- 1 --> F == 3
 
-shortDistance = dijkstra(G, 'E', 'C')
-print(shortDistance)
+if __name__ == "__main__":
+    import doctest
+    doctest.testmod()
diff --git a/project_euler/problem_01/__init__.py b/project_euler/problem_01/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/project_euler/problem_01/sol1.py b/project_euler/problem_01/sol1.py
index c9a8c0f1ebeb..1433129af303 100644
--- a/project_euler/problem_01/sol1.py
+++ b/project_euler/problem_01/sol1.py
@@ -1,13 +1,34 @@
-'''
+"""
 Problem Statement:
 If we list all the natural numbers below 10 that are multiples of 3 or 5,
 we get 3,5,6 and 9. The sum of these multiples is 23.
 Find the sum of all the multiples of 3 or 5 below N.
-'''
+"""
 from __future__ import print_function
+
 try:
-    raw_input          # Python 2
+    raw_input  # Python 2
 except NameError:
     raw_input = input  # Python 3
-n = int(raw_input().strip())
-print(sum([e for e in range(3, n) if e % 3 == 0 or e % 5 == 0]))
+
+
+def solution(n):
+    """Returns the sum of all the multiples of 3 or 5 below n.
+    
+    >>> solution(3)
+    0
+    >>> solution(4)
+    3
+    >>> solution(10)
+    23
+    >>> solution(600)
+    83700
+    >>> solution(-7)
+    0
+    """
+
+    return sum([e for e in range(3, n) if e % 3 == 0 or e % 5 == 0])
+
+
+if __name__ == "__main__":
+    print(solution(int(raw_input().strip())))
diff --git a/project_euler/problem_01/sol2.py b/project_euler/problem_01/sol2.py
index 2b7760e0bfff..e58fb03a8fb0 100644
--- a/project_euler/problem_01/sol2.py
+++ b/project_euler/problem_01/sol2.py
@@ -1,20 +1,39 @@
-'''
+"""
 Problem Statement:
 If we list all the natural numbers below 10 that are multiples of 3 or 5,
 we get 3,5,6 and 9. The sum of these multiples is 23.
 Find the sum of all the multiples of 3 or 5 below N.
-'''
+"""
 from __future__ import print_function
+
 try:
-    raw_input          # Python 2
+    raw_input  # Python 2
 except NameError:
     raw_input = input  # Python 3
-n = int(raw_input().strip())
-sum = 0
-terms = (n-1)//3
-sum+= ((terms)*(6+(terms-1)*3))//2 #sum of an A.P.
-terms = (n-1)//5
-sum+= ((terms)*(10+(terms-1)*5))//2
-terms = (n-1)//15
-sum-= ((terms)*(30+(terms-1)*15))//2
-print(sum)
+
+
+def solution(n):
+    """Returns the sum of all the multiples of 3 or 5 below n.
+    
+    >>> solution(3)
+    0
+    >>> solution(4)
+    3
+    >>> solution(10)
+    23
+    >>> solution(600)
+    83700
+    """
+
+    sum = 0
+    terms = (n - 1) // 3
+    sum += ((terms) * (6 + (terms - 1) * 3)) // 2  # sum of an A.P.
+    terms = (n - 1) // 5
+    sum += ((terms) * (10 + (terms - 1) * 5)) // 2
+    terms = (n - 1) // 15
+    sum -= ((terms) * (30 + (terms - 1) * 15)) // 2
+    return sum
+
+
+if __name__ == "__main__":
+    print(solution(int(raw_input().strip())))
diff --git a/project_euler/problem_01/sol3.py b/project_euler/problem_01/sol3.py
index f4f3aefcc5de..013ce5e54fdf 100644
--- a/project_euler/problem_01/sol3.py
+++ b/project_euler/problem_01/sol3.py
@@ -1,50 +1,66 @@
-from __future__ import print_function
-
-'''
+"""
 Problem Statement:
 If we list all the natural numbers below 10 that are multiples of 3 or 5,
 we get 3,5,6 and 9. The sum of these multiples is 23.
 Find the sum of all the multiples of 3 or 5 below N.
-'''
-'''
-This solution is based on the pattern that the successive numbers in the series follow: 0+3,+2,+1,+3,+1,+2,+3.
-'''
+"""
+from __future__ import print_function
 
 try:
-    raw_input          # Python 2
+    raw_input  # Python 2
 except NameError:
     raw_input = input  # Python 3
-n = int(raw_input().strip())
-sum=0
-num=0
-while(1):
-    num+=3
-    if(num>=n):
-        break
-    sum+=num
-    num+=2
-    if(num>=n):
-        break
-    sum+=num
-    num+=1
-    if(num>=n):
-        break
-    sum+=num
-    num+=3
-    if(num>=n):
-        break
-    sum+=num
-    num+=1
-    if(num>=n):
-        break
-    sum+=num
-    num+=2
-    if(num>=n):
-        break
-    sum+=num
-    num+=3
-    if(num>=n):
-        break
-    sum+=num
 
-print(sum);
+
+def solution(n):
+    """
+    This solution is based on the pattern that the successive numbers in the
+    series follow: 0+3,+2,+1,+3,+1,+2,+3.
+    Returns the sum of all the multiples of 3 or 5 below n.
+    
+    >>> solution(3)
+    0
+    >>> solution(4)
+    3
+    >>> solution(10)
+    23
+    >>> solution(600)
+    83700
+    """
+
+    sum = 0
+    num = 0
+    while 1:
+        num += 3
+        if num >= n:
+            break
+        sum += num
+        num += 2
+        if num >= n:
+            break
+        sum += num
+        num += 1
+        if num >= n:
+            break
+        sum += num
+        num += 3
+        if num >= n:
+            break
+        sum += num
+        num += 1
+        if num >= n:
+            break
+        sum += num
+        num += 2
+        if num >= n:
+            break
+        sum += num
+        num += 3
+        if num >= n:
+            break
+        sum += num
+    return sum
+
+
+if __name__ == "__main__":
+    print(solution(int(raw_input().strip())))
diff --git a/project_euler/problem_01/sol4.py b/project_euler/problem_01/sol4.py
index 7941f5fcd3fe..90403c3bd6a3 100644
--- a/project_euler/problem_01/sol4.py
+++ b/project_euler/problem_01/sol4.py
@@ -1,4 +1,30 @@
-def mulitples(limit):
+"""
+Problem Statement:
+If we list all the natural numbers below 10 that are multiples of 3 or 5,
+we get 3,5,6 and 9. The sum of these multiples is 23.
+Find the sum of all the multiples of 3 or 5 below N.
+"""
+from __future__ import print_function
+
+try:
+    raw_input  # Python 2
+except NameError:
+    raw_input = input  # Python 3
+
+
+def solution(n):
+    """Returns the sum of all the multiples of 3 or 5 below n.
+    
+    >>> solution(3)
+    0
+    >>> solution(4)
+    3
+    >>> solution(10)
+    23
+    >>> solution(600)
+    83700
+    """
+
     xmulti = []
     zmulti = []
     z = 3
@@ -6,7 +32,7 @@ def mulitples(limit):
     temp = 1
     while True:
         result = z * temp
-        if (result < limit):
+        if result < n:
             zmulti.append(result)
             temp += 1
         else:
@@ -14,17 +40,14 @@ def mulitples(limit):
             break
     while True:
         result = x * temp
-        if (result < limit):
+        if result < n:
             xmulti.append(result)
             temp += 1
         else:
             break
-    collection = list(set(xmulti+zmulti))
-    return (sum(collection))
-    
-    
-        
-        
-        
-    
-print (mulitples(1000))
+    collection = list(set(xmulti + zmulti))
+    return sum(collection)
+
+
+if __name__ == "__main__":
+    print(solution(int(raw_input().strip())))
diff --git a/project_euler/problem_01/sol5.py b/project_euler/problem_01/sol5.py
index e261cc8fc729..302fe44f8bfa 100644
--- a/project_euler/problem_01/sol5.py
+++ b/project_euler/problem_01/sol5.py
@@ -1,16 +1,34 @@
-'''
+"""
 Problem Statement:
 If we list all the natural numbers below 10 that are multiples of 3 or 5,
 we get 3,5,6 and 9. The sum of these multiples is 23.
 Find the sum of all the multiples of 3 or 5 below N.
-'''
+"""
 from __future__ import print_function
+
 try:
-    input = raw_input #python3
+    raw_input  # Python 2
 except NameError:
-    pass               #python 2
+    raw_input = input  # Python 3
 
 """A straightforward pythonic solution using list comprehension"""
-n = int(input().strip())
-print(sum([i for i in range(n) if i%3==0 or i%5==0]))
 
+
+def solution(n):
+    """Returns the sum of all the multiples of 3 or 5 below n.
+    
+    >>> solution(3)
+    0
+    >>> solution(4)
+    3
+    >>> solution(10)
+    23
+    >>> solution(600)
+    83700
+    """
+
+    return sum([i for i in range(n) if i % 3 == 0 or i % 5 == 0])
+
+
+if __name__ == "__main__":
+    print(solution(int(raw_input().strip())))
diff --git a/project_euler/problem_01/sol6.py b/project_euler/problem_01/sol6.py
index 54c3073f3897..cf6e751d4c05 100644
--- a/project_euler/problem_01/sol6.py
+++ b/project_euler/problem_01/sol6.py
@@ -1,9 +1,40 @@
-a = 3
-result = 0
-while a < 1000:
-    if(a % 3 == 0 or a % 5 == 0):
-        result += a
-    elif(a % 15 == 0):
-        result -= a
-    a += 1
-print(result)
+"""
+Problem Statement:
+If we list all the natural numbers below 10 that are multiples of 3 or 5,
+we get 3,5,6 and 9. The sum of these multiples is 23.
+Find the sum of all the multiples of 3 or 5 below N.
+"""
+from __future__ import print_function
+
+try:
+    raw_input  # Python 2
+except NameError:
+    raw_input = input  # Python 3
+
+
+def solution(n):
+    """Returns the sum of all the multiples of 3 or 5 below n.
+    
+    >>> solution(3)
+    0
+    >>> solution(4)
+    3
+    >>> solution(10)
+    23
+    >>> solution(600)
+    83700
+    """
+
+    a = 3
+    result = 0
+    while a < n:
+        if a % 3 == 0 or a % 5 == 0:
+            result += a
+        elif a % 15 == 0:
+            result -= a
+        a += 1
+    return result
+
+
+if __name__ == "__main__":
+    print(solution(int(raw_input().strip())))
diff --git a/project_euler/problem_02/__init__.py b/project_euler/problem_02/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/project_euler/problem_02/sol1.py b/project_euler/problem_02/sol1.py
index 44ea980f2df0..f61d04e3dfce 100644
--- a/project_euler/problem_02/sol1.py
+++ b/project_euler/problem_02/sol1.py
@@ -1,24 +1,47 @@
-'''
+"""
 Problem:
-Each new term in the Fibonacci sequence is generated by adding the previous two terms. By starting with 1 and 2,
-the first 10 terms will be:
-                1,2,3,5,8,13,21,34,55,89,..
-By considering the terms in the Fibonacci sequence whose values do not exceed n, find the sum of the even-valued terms.
-e.g. for n=10, we have {2,8}, sum is 10.
-'''
+Each new term in the Fibonacci sequence is generated by adding the previous two
+terms. By starting with 1 and 2, the first 10 terms will be:
+
+    1,2,3,5,8,13,21,34,55,89,..
+
+By considering the terms in the Fibonacci sequence whose values do not exceed
+n, find the sum of the even-valued terms. e.g. for n=10, we have {2,8}, sum is
+10.
+"""
 from __future__ import print_function
 
 try:
-    raw_input          # Python 2
+    raw_input  # Python 2
 except NameError:
     raw_input = input  # Python 3
 
-n = int(raw_input().strip())
-i=1
-j=2 
-sum=0
-while(j<=n):
-    if j%2 == 0:
-        sum+=j
-    i , j = j, i+j
-print(sum)
+
+def solution(n):
+    """Returns the sum of all fibonacci sequence even elements that are lower
+    or equals to n.
+    
+    >>> solution(10)
+    10
+    >>> solution(15)
+    10
+    >>> solution(2)
+    2
+    >>> solution(1)
+    0
+    >>> solution(34)
+    44
+    """
+    i = 1
+    j = 2
+    sum = 0
+    while j <= n:
+        if j % 2 == 0:
+            sum += j
+        i, j = j, i + j
+
+    return sum
+
+
+if __name__ == "__main__":
+    print(solution(int(raw_input().strip())))
diff --git a/project_euler/problem_02/sol2.py b/project_euler/problem_02/sol2.py
index a2772697bb79..3e103a6a4373 100644
--- a/project_euler/problem_02/sol2.py
+++ b/project_euler/problem_02/sol2.py
@@ -1,15 +1,45 @@
-def fib(n):
-    """
-    Returns a list of all the even terms in the Fibonacci sequence that are less than n.
+"""
+Problem:
+Each new term in the Fibonacci sequence is generated by adding the previous two
+terms. By starting with 1 and 2, the first 10 terms will be:
+
+    1,2,3,5,8,13,21,34,55,89,..
+
+By considering the terms in the Fibonacci sequence whose values do not exceed
+n, find the sum of the even-valued terms. e.g. for n=10, we have {2,8}, sum is
+10.
+"""
+from __future__ import print_function
+
+try:
+    raw_input  # Python 2
+except NameError:
+    raw_input = input  # Python 3
+
+
+def solution(n):
+    """Returns the sum of all fibonacci sequence even elements that are lower
+    or equals to n.
+    
+    >>> solution(10)
+    [2, 8]
+    >>> solution(15)
+    [2, 8]
+    >>> solution(2)
+    [2]
+    >>> solution(1)
+    []
+    >>> solution(34)
+    [2, 8, 34]
     """
     ls = []
     a, b = 0, 1
-    while b < n:
+    while b <= n:
         if b % 2 == 0:
             ls.append(b)
-        a, b = b, a+b
+        a, b = b, a + b
     return ls
 
-if __name__ == '__main__':
-    n = int(input("Enter max number: ").strip())
-    print(sum(fib(n)))
+
+if __name__ == "__main__":
+    print(solution(int(raw_input().strip())))
diff --git a/project_euler/problem_02/sol3.py b/project_euler/problem_02/sol3.py
index 0eb46d879704..abd9d6c753b8 100644
--- a/project_euler/problem_02/sol3.py
+++ b/project_euler/problem_02/sol3.py
@@ -1,18 +1,47 @@
-'''
+"""
 Problem:
-Each new term in the Fibonacci sequence is generated by adding the previous two terms. 
-                0,1,1,2,3,5,8,13,21,34,55,89,..
-Every third term from 0 is even So using this I have written a simple code
-By considering the terms in the Fibonacci sequence whose values do not exceed n, find the sum of the even-valued terms.
-e.g. for n=10, we have {2,8}, sum is 10.
-'''
-"""Python 3"""
-n = int(input())
-a=0
-b=2
-count=0
-while 4*b+a<n:
-    a, b = b, 4*b+a
-    count+= a
-print(count+b)
-   
+Each new term in the Fibonacci sequence is generated by adding the previous
+two terms. By starting with 1 and 2, the first 10 terms will be:
+
+    1,2,3,5,8,13,21,34,55,89,..
+
+By considering the terms in the Fibonacci sequence whose values do not exceed
+n, find the sum of the even-valued terms. e.g. for n=10, we have {2,8}, sum is
+10.
+"""
+from __future__ import print_function
+
+try:
+    raw_input  # Python 2
+except NameError:
+    raw_input = input  # Python 3
+
+
+def solution(n):
+    """Returns the sum of all fibonacci sequence even elements that are lower
+    or equals to n.
+    
+    >>> solution(10)
+    10
+    >>> solution(15)
+    10
+    >>> solution(2)
+    2
+    >>> solution(1)
+    0
+    >>> solution(34)
+    44
+    """
+    if n <= 1:
+        return 0
+    a = 0
+    b = 2
+    count = 0
+    while 4 * b + a <= n:
+        a, b = b, 4 * b + a
+        count += a
+    return count + b
+
+
+if __name__ == "__main__":
+    print(solution(int(raw_input().strip())))
diff --git a/project_euler/problem_02/sol4.py b/project_euler/problem_02/sol4.py
index 64bae65f49b4..ba13b12a15e9 100644
--- a/project_euler/problem_02/sol4.py
+++ b/project_euler/problem_02/sol4.py
@@ -1,13 +1,47 @@
+"""
+Problem:
+Each new term in the Fibonacci sequence is generated by adding the previous two
+terms. By starting with 1 and 2, the first 10 terms will be:
+
+    1,2,3,5,8,13,21,34,55,89,..
+
+By considering the terms in the Fibonacci sequence whose values do not exceed
+n, find the sum of the even-valued terms. e.g. for n=10, we have {2,8}, sum is
+10.
+"""
+from __future__ import print_function
 import math
 from decimal import *
 
-getcontext().prec = 100
-phi = (Decimal(5) ** Decimal(0.5) + 1) / Decimal(2)
+try:
+    raw_input  # Python 2
+except NameError:
+    raw_input = input  # Python 3
+
+
+def solution(n):
+    """Returns the sum of all fibonacci sequence even elements that are lower
+    or equals to n.
+    
+    >>> solution(10)
+    10
+    >>> solution(15)
+    10
+    >>> solution(2)
+    2
+    >>> solution(1)
+    0
+    >>> solution(34)
+    44
+    """
+    getcontext().prec = 100
+    phi = (Decimal(5) ** Decimal(0.5) + 1) / Decimal(2)
 
-n = Decimal(int(input()) - 1)
+    index = (math.floor(math.log(n * (phi + 2), phi) - 1) // 3) * 3 + 2
+    num = Decimal(round(phi ** Decimal(index + 1))) / (phi + 2)
+    sum = num // 2
+    return int(sum)
 
-index = (math.floor(math.log(n * (phi + 2), phi) - 1)  // 3) * 3 + 2
-num = round(phi ** Decimal(index + 1)) / (phi + 2)
-sum = num // 2
 
-print(int(sum))
+if __name__ == "__main__":
+    print(solution(int(raw_input().strip())))
diff --git a/project_euler/problem_03/__init__.py b/project_euler/problem_03/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/project_euler/problem_03/sol1.py b/project_euler/problem_03/sol1.py
index bb9f8ca9ad12..c2e601bd0040 100644
--- a/project_euler/problem_03/sol1.py
+++ b/project_euler/problem_03/sol1.py
@@ -1,39 +1,61 @@
-'''
+"""
 Problem:
-The prime factors of 13195 are 5,7,13 and 29. What is the largest prime factor of a given number N?
+The prime factors of 13195 are 5,7,13 and 29. What is the largest prime factor
+of a given number N?
+
 e.g. for 10, largest prime factor = 5. For 17, largest prime factor = 17.
-'''
+"""
 from __future__ import print_function, division
-
 import math
 
+try:
+    raw_input  # Python 2
+except NameError:
+    raw_input = input  # Python 3
+
+
 def isprime(no):
-    if(no==2):
+    if no == 2:
         return True
-    elif (no%2==0):
+    elif no % 2 == 0:
         return False
-    sq = int(math.sqrt(no))+1
-    for i in range(3,sq,2):
-        if(no%i==0):
+    sq = int(math.sqrt(no)) + 1
+    for i in range(3, sq, 2):
+        if no % i == 0:
             return False
     return True
 
-maxNumber = 0
-n=int(input())
-if(isprime(n)):
-    print(n)
-else:
-    while (n%2==0):
-        n=n/2
-    if(isprime(n)):
-        print(n)
+
+def solution(n):
+    """Returns the largest prime factor of a given number n.
+    
+    >>> solution(13195)
+    29
+    >>> solution(10)
+    5
+    >>> solution(17)
+    17
+    """
+    maxNumber = 0
+    if isprime(n):
+        return n
     else:
-        n1 = int(math.sqrt(n))+1
-        for i in range(3,n1,2):
-            if(n%i==0):
-                if(isprime(n/i)):
-                    maxNumber = n/i
-                    break
-                elif(isprime(i)):
-                    maxNumber = i
-        print(maxNumber)
+        while n % 2 == 0:
+            n = n / 2
+        if isprime(n):
+            return int(n)
+        else:
+            n1 = int(math.sqrt(n)) + 1
+            for i in range(3, n1, 2):
+                if n % i == 0:
+                    if isprime(n / i):
+                        maxNumber = n / i
+                        break
+                    elif isprime(i):
+                        maxNumber = i
+            return maxNumber
+    return int(sum)
+
+
+if __name__ == "__main__":
+    print(solution(int(raw_input().strip())))
diff --git a/project_euler/problem_03/sol2.py b/project_euler/problem_03/sol2.py
index 44f9c63dfb6a..497db3965cc3 100644
--- a/project_euler/problem_03/sol2.py
+++ b/project_euler/problem_03/sol2.py
@@ -1,18 +1,40 @@
-'''
+"""
 Problem:
-The prime factors of 13195 are 5,7,13 and 29. What is the largest prime factor of a given number N?
+The prime factors of 13195 are 5,7,13 and 29. What is the largest prime factor
+of a given number N?
+
 e.g. for 10, largest prime factor = 5. For 17, largest prime factor = 17.
-'''
+"""
+from __future__ import print_function, division
+import math
+
+try:
+    raw_input  # Python 2
+except NameError:
+    raw_input = input  # Python 3
+
+
+def solution(n):
+    """Returns the largest prime factor of a given number n.
+    
+    >>> solution(13195)
+    29
+    >>> solution(10)
+    5
+    >>> solution(17)
+    17
+    """
+    prime = 1
+    i = 2
+    while i * i <= n:
+        while n % i == 0:
+            prime = i
+            n //= i
+        i += 1
+    if n > 1:
+        prime = n
+    return int(prime)
+
 
-from __future__ import print_function
-n=int(input())
-prime=1
-i=2
-while(i*i<=n):
-    while(n%i==0):
-        prime=i
-        n//=i
-    i+=1
-if(n>1):
-    prime=n
-print(prime)
+if __name__ == "__main__":
+    print(solution(int(raw_input().strip())))
diff --git a/project_euler/problem_04/__init__.py b/project_euler/problem_04/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/project_euler/problem_04/sol1.py b/project_euler/problem_04/sol1.py
index 05fdd9ebab55..7a255f7308e6 100644
--- a/project_euler/problem_04/sol1.py
+++ b/project_euler/problem_04/sol1.py
@@ -1,29 +1,50 @@
-'''
+"""
 Problem:
-A palindromic number reads the same both ways. The largest palindrome made from the product of two 2-digit numbers is 9009 = 91 x 99.
-Find the largest palindrome made from the product of two 3-digit numbers which is less than N.
-'''
+A palindromic number reads the same both ways. The largest palindrome made from
+the product of two 2-digit numbers is 9009 = 91 x 99.
+
+Find the largest palindrome made from the product of two 3-digit numbers which
+is less than N.
+"""
 from __future__ import print_function
-limit = int(input("limit? "))
 
-# fetchs the next number
-for number in range(limit-1,10000,-1):
+try:
+    raw_input  # Python 2
+except NameError:
+    raw_input = input  # Python 3
+
+
+def solution(n):
+    """Returns the largest palindrome made from the product of two 3-digit
+    numbers which is less than n.
+    
+    >>> solution(20000)
+    19591
+    >>> solution(30000)
+    29992
+    >>> solution(40000)
+    39893
+    """
+    # fetchs the next number
+    for number in range(n - 1, 10000, -1):
 
-    # converts number into string.
-    strNumber = str(number)
+        # converts number into string.
+        strNumber = str(number)
 
-    # checks whether 'strNumber' is a palindrome.
-    if(strNumber == strNumber[::-1]):
+        # checks whether 'strNumber' is a palindrome.
+        if strNumber == strNumber[::-1]:
 
-        divisor = 999
+            divisor = 999
 
-        # if 'number' is a product of two 3-digit numbers
-        # then number is the answer otherwise fetch next number.
-        while(divisor != 99): 
-            
-            if((number % divisor == 0) and (len(str(number / divisor)) == 3)):
+            # if 'number' is a product of two 3-digit numbers
+            # then number is the answer otherwise fetch next number.
+            while divisor != 99:
+                if (number % divisor == 0) and (
+                    len(str(int(number / divisor))) == 3
+                ):
+                    return number
+                divisor -= 1
 
-                print(number)
-                exit(0)
 
-            divisor -=1
+if __name__ == "__main__":
+    print(solution(int(raw_input().strip())))
diff --git a/project_euler/problem_04/sol2.py b/project_euler/problem_04/sol2.py
index 70810c38986f..45c6b256daf8 100644
--- a/project_euler/problem_04/sol2.py
+++ b/project_euler/problem_04/sol2.py
@@ -1,17 +1,38 @@
-'''
+"""
 Problem:
-A palindromic number reads the same both ways. The largest palindrome made from the product of two 2-digit numbers is 9009 = 91 x 99.
-Find the largest palindrome made from the product of two 3-digit numbers which is less than N.
-'''
+A palindromic number reads the same both ways. The largest palindrome made from
+the product of two 2-digit numbers is 9009 = 91 x 99.
+
+Find the largest palindrome made from the product of two 3-digit numbers which
+is less than N.
+"""
 from __future__ import print_function
-n = int(input().strip())
-answer = 0
-for i in range(999,99,-1): #3 digit nimbers range from 999 down to 100
-    for j in range(999,99,-1):
-        t = str(i*j)
-        if t == t[::-1] and i*j < n:
-            answer = max(answer,i*j)
-print(answer)
-exit(0)
+
+try:
+    raw_input  # Python 2
+except NameError:
+    raw_input = input  # Python 3
+
+
+def solution(n):
+    """Returns the largest palindrome made from the product of two 3-digit
+    numbers which is less than n.
+    
+    >>> solution(20000)
+    19591
+    >>> solution(30000)
+    29992
+    >>> solution(40000)
+    39893
+    """
+    answer = 0
+    for i in range(999, 99, -1):  # 3 digit nimbers range from 999 down to 100
+        for j in range(999, 99, -1):
+            t = str(i * j)
+            if t == t[::-1] and i * j < n:
+                answer = max(answer, i * j)
+    return answer
 
 
+if __name__ == "__main__":
+    print(solution(int(raw_input().strip())))
diff --git a/project_euler/problem_05/__init__.py b/project_euler/problem_05/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/project_euler/problem_05/sol1.py b/project_euler/problem_05/sol1.py
index 7896d75e3456..609f02102a08 100644
--- a/project_euler/problem_05/sol1.py
+++ b/project_euler/problem_05/sol1.py
@@ -1,21 +1,46 @@
-'''
+"""
 Problem:
-2520 is the smallest number that can be divided by each of the numbers from 1 to 10 without any remainder.
-What is the smallest positive number that is evenly divisible(divisible with no remainder) by all of the numbers from 1 to N?
-'''
+2520 is the smallest number that can be divided by each of the numbers from 1
+to 10 without any remainder.
+
+What is the smallest positive number that is evenly divisible(divisible with no
+remainder) by all of the numbers from 1 to N?
+"""
 from __future__ import print_function
 
-n = int(input())
-i = 0
-while 1:
-    i+=n*(n-1)
-    nfound=0
-    for j in range(2,n):
-        if (i%j != 0):
-            nfound=1
+try:
+    raw_input  # Python 2
+except NameError:
+    raw_input = input  # Python 3
+
+
+def solution(n):
+    """Returns the smallest positive number that is evenly divisible(divisible
+    with no remainder) by all of the numbers from 1 to n.
+    
+    >>> solution(10)
+    2520
+    >>> solution(15)
+    360360
+    >>> solution(20)
+    232792560
+    >>> solution(22)
+    232792560
+    """
+    i = 0
+    while 1:
+        i += n * (n - 1)
+        nfound = 0
+        for j in range(2, n):
+            if i % j != 0:
+                nfound = 1
+                break
+        if nfound == 0:
+            if i == 0:
+                i = 1
+            return i
             break
-    if(nfound==0):
-        if(i==0):
-            i=1
-        print(i)
-        break
+
+
+if __name__ == "__main__":
+    print(solution(int(raw_input().strip())))
diff --git a/project_euler/problem_05/sol2.py b/project_euler/problem_05/sol2.py
index cd11437f30db..293dd96f2294 100644
--- a/project_euler/problem_05/sol2.py
+++ b/project_euler/problem_05/sol2.py
@@ -1,20 +1,50 @@
-#!/bin/python3
-'''
+"""
 Problem:
-2520 is the smallest number that can be divided by each of the numbers from 1 to 10 without any remainder.
-What is the smallest positive number that is evenly divisible(divisible with no remainder) by all of the numbers from 1 to N?
-'''
+2520 is the smallest number that can be divided by each of the numbers from 1
+to 10 without any remainder.
+
+What is the smallest positive number that is evenly divisible(divisible with no
+remainder) by all of the numbers from 1 to N?
+"""
+from __future__ import print_function
+
+try:
+    raw_input  # Python 2
+except NameError:
+    raw_input = input  # Python 3
 
 """ Euclidean GCD Algorithm """
-def gcd(x,y):
-    return x if y==0 else gcd(y,x%y)
+
+
+def gcd(x, y):
+    return x if y == 0 else gcd(y, x % y)
+
 
 """ Using the property lcm*gcd of two numbers = product of them """
-def lcm(x,y):
-    return (x*y)//gcd(x,y)
-
-n = int(input())
-g=1
-for i in range(1,n+1):
-    g=lcm(g,i)
-print(g)
+
+
+def lcm(x, y):
+    return (x * y) // gcd(x, y)
+
+
+def solution(n):
+    """Returns the smallest positive number that is evenly divisible(divisible
+    with no remainder) by all of the numbers from 1 to n.
+    
+    >>> solution(10)
+    2520
+    >>> solution(15)
+    360360
+    >>> solution(20)
+    232792560
+    >>> solution(22)
+    232792560
+    """
+    g = 1
+    for i in range(1, n + 1):
+        g = lcm(g, i)
+    return g
+
+
+if __name__ == "__main__":
+    print(solution(int(raw_input().strip())))
diff --git a/project_euler/problem_06/__init__.py b/project_euler/problem_06/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/project_euler/problem_06/sol1.py b/project_euler/problem_06/sol1.py
index 852d4e2f9fc4..728701e167c3 100644
--- a/project_euler/problem_06/sol1.py
+++ b/project_euler/problem_06/sol1.py
@@ -1,20 +1,48 @@
 # -*- coding: utf-8 -*-
-'''
+"""
 Problem:
+
 The sum of the squares of the first ten natural numbers is,
             1^2 + 2^2 + ... + 10^2 = 385
+
 The square of the sum of the first ten natural numbers is,
             (1 + 2 + ... + 10)^2 = 552 = 3025
-Hence the difference between the sum of the squares of the first ten natural numbers and the square of the sum is 3025 − 385 = 2640.
-Find the difference between the sum of the squares of the first N natural numbers and the square of the sum.
-'''
+
+Hence the difference between the sum of the squares of the first ten natural
+numbers and the square of the sum is 3025 − 385 = 2640.
+
+Find the difference between the sum of the squares of the first N natural
+numbers and the square of the sum.
+"""
 from __future__ import print_function
 
-suma = 0
-sumb = 0
-n = int(input())
-for i in range(1,n+1):
-    suma += i**2
-    sumb += i
-sum = sumb**2 - suma
-print(sum)
+try:
+    raw_input  # Python 2
+except NameError:
+    raw_input = input  # Python 3
+
+
+def solution(n):
+    """Returns the difference between the sum of the squares of the first n
+    natural numbers and the square of the sum.
+ 
+    >>> solution(10)
+    2640
+    >>> solution(15)
+    13160
+    >>> solution(20)
+    41230
+    >>> solution(50)
+    1582700
+    """
+    suma = 0
+    sumb = 0
+    for i in range(1, n + 1):
+        suma += i ** 2
+        sumb += i
+    sum = sumb ** 2 - suma
+    return sum
+
+
+if __name__ == "__main__":
+    print(solution(int(raw_input().strip())))
diff --git a/project_euler/problem_06/sol2.py b/project_euler/problem_06/sol2.py
index aa8aea58fd7b..2c64812d56f8 100644
--- a/project_euler/problem_06/sol2.py
+++ b/project_euler/problem_06/sol2.py
@@ -1,16 +1,45 @@
 # -*- coding: utf-8 -*-
-'''
+"""
 Problem:
+
 The sum of the squares of the first ten natural numbers is,
             1^2 + 2^2 + ... + 10^2 = 385
+
 The square of the sum of the first ten natural numbers is,
             (1 + 2 + ... + 10)^2 = 552 = 3025
-Hence the difference between the sum of the squares of the first ten natural numbers and the square of the sum is 3025 − 385 = 2640.
-Find the difference between the sum of the squares of the first N natural numbers and the square of the sum.
-'''
+
+Hence the difference between the sum of the squares of the first ten natural
+numbers and the square of the sum is 3025 − 385 = 2640.
+
+Find the difference between the sum of the squares of the first N natural
+numbers and the square of the sum.
+"""
 from __future__ import print_function
-n = int(input())
-suma = n*(n+1)/2
-suma **= 2
-sumb = n*(n+1)*(2*n+1)/6
-print(suma-sumb)
+
+try:
+    raw_input  # Python 2
+except NameError:
+    raw_input = input  # Python 3
+
+
+def solution(n):
+    """Returns the difference between the sum of the squares of the first n
+    natural numbers and the square of the sum.
+ 
+    >>> solution(10)
+    2640
+    >>> solution(15)
+    13160
+    >>> solution(20)
+    41230
+    >>> solution(50)
+    1582700
+    """
+    suma = n * (n + 1) / 2
+    suma **= 2
+    sumb = n * (n + 1) * (2 * n + 1) / 6
+    return int(suma - sumb)
+
+
+if __name__ == "__main__":
+    print(solution(int(raw_input().strip())))
diff --git a/project_euler/problem_06/sol3.py b/project_euler/problem_06/sol3.py
index b2d9f444d9a9..7d94b1e2254f 100644
--- a/project_euler/problem_06/sol3.py
+++ b/project_euler/problem_06/sol3.py
@@ -1,20 +1,45 @@
-'''
+# -*- coding: utf-8 -*-
+"""
 Problem:
+
 The sum of the squares of the first ten natural numbers is,
             1^2 + 2^2 + ... + 10^2 = 385
+
 The square of the sum of the first ten natural numbers is,
             (1 + 2 + ... + 10)^2 = 552 = 3025
-Hence the difference between the sum of the squares of the first ten natural numbers and the square of the sum is 3025 − 385 = 2640.
-Find the difference between the sum of the squares of the first N natural numbers and the square of the sum.
-'''
+
+Hence the difference between the sum of the squares of the first ten natural
+numbers and the square of the sum is 3025 − 385 = 2640.
+
+Find the difference between the sum of the squares of the first N natural
+numbers and the square of the sum.
+"""
 from __future__ import print_function
 import math
-def problem6(number=100):
-    sum_of_squares = sum([i*i for i in range(1,number+1)])
-    square_of_sum = int(math.pow(sum(range(1,number+1)),2))
+
+try:
+    raw_input  # Python 2
+except NameError:
+    raw_input = input  # Python 3
+
+
+def solution(n):
+    """Returns the difference between the sum of the squares of the first n
+    natural numbers and the square of the sum.
+ 
+    >>> solution(10)
+    2640
+    >>> solution(15)
+    13160
+    >>> solution(20)
+    41230
+    >>> solution(50)
+    1582700
+    """
+    sum_of_squares = sum([i * i for i in range(1, n + 1)])
+    square_of_sum = int(math.pow(sum(range(1, n + 1)), 2))
     return square_of_sum - sum_of_squares
-def main():
-    print(problem6())
 
-if __name__ == '__main__':
-    main()
\ No newline at end of file
+
+if __name__ == "__main__":
+    print(solution(int(raw_input().strip())))
diff --git a/project_euler/problem_07/__init__.py b/project_euler/problem_07/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/project_euler/problem_07/sol1.py b/project_euler/problem_07/sol1.py
index ea31d0b2bb2c..403ded568dda 100644
--- a/project_euler/problem_07/sol1.py
+++ b/project_euler/problem_07/sol1.py
@@ -1,30 +1,61 @@
-'''
+# -*- coding: utf-8 -*-
+"""
 By listing the first six prime numbers:
-2, 3, 5, 7, 11, and 13, we can see that the 6th prime is 13.
-What is the Nth prime number?
-'''
+
+    2, 3, 5, 7, 11, and 13
+
+We can see that the 6th prime is 13. What is the Nth prime number?
+"""
 from __future__ import print_function
 from math import sqrt
+
+try:
+    raw_input  # Python 2
+except NameError:
+    raw_input = input  # Python 3
+
+
 def isprime(n):
-    if (n==2):
+    if n == 2:
         return True
-    elif (n%2==0):
+    elif n % 2 == 0:
         return False
     else:
-        sq = int(sqrt(n))+1
-        for i in range(3,sq,2):
-            if(n%i==0):
+        sq = int(sqrt(n)) + 1
+        for i in range(3, sq, 2):
+            if n % i == 0:
                 return False
     return True
-n = int(input())
-i=0
-j=1
-while(i!=n and j<3):
-    j+=1
-    if (isprime(j)):
-        i+=1
-while(i!=n):
-    j+=2
-    if(isprime(j)):
-        i+=1
-print(j)
+
+
+def solution(n):
+    """Returns the n-th prime number.
+ 
+    >>> solution(6)
+    13
+    >>> solution(1)
+    2
+    >>> solution(3)
+    5
+    >>> solution(20)
+    71
+    >>> solution(50)
+    229
+    >>> solution(100)
+    541
+    """
+    i = 0
+    j = 1
+    while i != n and j < 3:
+        j += 1
+        if isprime(j):
+            i += 1
+    while i != n:
+        j += 2
+        if isprime(j):
+            i += 1
+    return j
+
+
+if __name__ == "__main__":
+    print(solution(int(raw_input().strip())))
diff --git a/project_euler/problem_07/sol2.py b/project_euler/problem_07/sol2.py
index fdf39cbc4d26..630e5196796d 100644
--- a/project_euler/problem_07/sol2.py
+++ b/project_euler/problem_07/sol2.py
@@ -1,16 +1,53 @@
-# By listing the first six prime numbers: 2, 3, 5, 7, 11, and 13, we can see that the 6th prime is 13. What is the Nth prime number?
+# -*- coding: utf-8 -*-
+"""
+By listing the first six prime numbers:
+
+    2, 3, 5, 7, 11, and 13
+
+We can see that the 6th prime is 13. What is the Nth prime number?
+"""
+from __future__ import print_function
+from math import sqrt
+
+try:
+    raw_input  # Python 2
+except NameError:
+    raw_input = input  # Python 3
+
+
 def isprime(number):
-	for i in range(2,int(number**0.5)+1):
-		if number%i==0:
-			return False
-	return True
-n = int(input('Enter The N\'th Prime Number You Want To Get: ')) # Ask For The N'th Prime Number Wanted
-primes = []
-num = 2
-while len(primes) < n:
-	if isprime(num):
-		primes.append(num)
-		num += 1
-	else:
-		num += 1
-print(primes[len(primes) - 1])
+    for i in range(2, int(number ** 0.5) + 1):
+        if number % i == 0:
+            return False
+    return True
+
+
+def solution(n):
+    """Returns the n-th prime number.
+ 
+    >>> solution(6)
+    13
+    >>> solution(1)
+    2
+    >>> solution(3)
+    5
+    >>> solution(20)
+    71
+    >>> solution(50)
+    229
+    >>> solution(100)
+    541
+    """
+    primes = []
+    num = 2
+    while len(primes) < n:
+        if isprime(num):
+            primes.append(num)
+            num += 1
+        else:
+            num += 1
+    return primes[len(primes) - 1]
+
+
+if __name__ == "__main__":
+    print(solution(int(raw_input().strip())))
diff --git a/project_euler/problem_07/sol3.py b/project_euler/problem_07/sol3.py
index 0001e4318cc9..bc94762604b3 100644
--- a/project_euler/problem_07/sol3.py
+++ b/project_euler/problem_07/sol3.py
@@ -1,28 +1,53 @@
-'''
+# -*- coding: utf-8 -*-
+"""
 By listing the first six prime numbers:
-2, 3, 5, 7, 11, and 13, we can see that the 6th prime is 13.
-What is the Nth prime number?
-'''
+
+    2, 3, 5, 7, 11, and 13
+
+We can see that the 6th prime is 13. What is the Nth prime number?
+"""
 from __future__ import print_function
-# from Python.Math import PrimeCheck
 import math
 import itertools
+
+try:
+    raw_input  # Python 2
+except NameError:
+    raw_input = input  # Python 3
+
+
 def primeCheck(number):
     if number % 2 == 0 and number > 2:
         return False
     return all(number % i for i in range(3, int(math.sqrt(number)) + 1, 2))
 
+
 def prime_generator():
     num = 2
     while True:
         if primeCheck(num):
             yield num
-        num+=1
+        num += 1
+
 
-def main():
-    n = int(input('Enter The N\'th Prime Number You Want To Get: '))  # Ask For The N'th Prime Number Wanted
-    print(next(itertools.islice(prime_generator(),n-1,n)))
+def solution(n):
+    """Returns the n-th prime number.
+ 
+    >>> solution(6)
+    13
+    >>> solution(1)
+    2
+    >>> solution(3)
+    5
+    >>> solution(20)
+    71
+    >>> solution(50)
+    229
+    >>> solution(100)
+    541
+    """
+    return next(itertools.islice(prime_generator(), n - 1, n))
 
 
-if __name__ == '__main__':
-    main()
\ No newline at end of file
+if __name__ == "__main__":
+    print(solution(int(raw_input().strip())))
diff --git a/project_euler/problem_08/__init__.py b/project_euler/problem_08/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/project_euler/problem_08/sol1.py b/project_euler/problem_08/sol1.py
index 817fd3f87507..6752fae3de60 100644
--- a/project_euler/problem_08/sol1.py
+++ b/project_euler/problem_08/sol1.py
@@ -1,15 +1,72 @@
+# -*- coding: utf-8 -*-
+"""
+The four adjacent digits in the 1000-digit number that have the greatest
+product are 9 × 9 × 8 × 9 = 5832.
+
+73167176531330624919225119674426574742355349194934
+96983520312774506326239578318016984801869478851843
+85861560789112949495459501737958331952853208805511
+12540698747158523863050715693290963295227443043557
+66896648950445244523161731856403098711121722383113
+62229893423380308135336276614282806444486645238749
+30358907296290491560440772390713810515859307960866
+70172427121883998797908792274921901699720888093776
+65727333001053367881220235421809751254540594752243
+52584907711670556013604839586446706324415722155397
+53697817977846174064955149290862569321978468622482
+83972241375657056057490261407972968652414535100474
+82166370484403199890008895243450658541227588666881
+16427171479924442928230863465674813919123162824586
+17866458359124566529476545682848912883142607690042
+24219022671055626321111109370544217506941658960408
+07198403850962455444362981230987879927244284909188
+84580156166097919133875499200524063689912560717606
+05886116467109405077541002256983155200055935729725
+71636269561882670428252483600823257530420752963450
+
+Find the thirteen adjacent digits in the 1000-digit number that have the
+greatest product. What is the value of this product?
+"""
 import sys
-def main():
-    LargestProduct = -sys.maxsize-1
-    number=input().strip()
-    for i in range(len(number)-12):
-        product=1
+
+N = """73167176531330624919225119674426574742355349194934\
+96983520312774506326239578318016984801869478851843\
+85861560789112949495459501737958331952853208805511\
+12540698747158523863050715693290963295227443043557\
+66896648950445244523161731856403098711121722383113\
+62229893423380308135336276614282806444486645238749\
+30358907296290491560440772390713810515859307960866\
+70172427121883998797908792274921901699720888093776\
+65727333001053367881220235421809751254540594752243\
+52584907711670556013604839586446706324415722155397\
+53697817977846174064955149290862569321978468622482\
+83972241375657056057490261407972968652414535100474\
+82166370484403199890008895243450658541227588666881\
+16427171479924442928230863465674813919123162824586\
+17866458359124566529476545682848912883142607690042\
+24219022671055626321111109370544217506941658960408\
+07198403850962455444362981230987879927244284909188\
+84580156166097919133875499200524063689912560717606\
+05886116467109405077541002256983155200055935729725\
+71636269561882670428252483600823257530420752963450"""
+
+
+def solution(n):
+    """Find the thirteen adjacent digits in the 1000-digit number n that have
+    the greatest product and returns it.
+ 
+    >>> solution(N)
+    23514624000
+    """
+    LargestProduct = -sys.maxsize - 1
+    for i in range(len(n) - 12):
+        product = 1
         for j in range(13):
-            product *= int(number[i+j])
+            product *= int(n[i + j])
         if product > LargestProduct:
             LargestProduct = product
-    print(LargestProduct)
+    return LargestProduct
 
 
-if __name__ == '__main__':
-    main()
+if __name__ == "__main__":
+    print(solution(N))
diff --git a/project_euler/problem_08/sol2.py b/project_euler/problem_08/sol2.py
index ae03f3ad0aa6..bae96e373d6c 100644
--- a/project_euler/problem_08/sol2.py
+++ b/project_euler/problem_08/sol2.py
@@ -1,8 +1,73 @@
+# -*- coding: utf-8 -*-
+"""
+The four adjacent digits in the 1000-digit number that have the greatest
+product are 9 × 9 × 8 × 9 = 5832.
+
+73167176531330624919225119674426574742355349194934
+96983520312774506326239578318016984801869478851843
+85861560789112949495459501737958331952853208805511
+12540698747158523863050715693290963295227443043557
+66896648950445244523161731856403098711121722383113
+62229893423380308135336276614282806444486645238749
+30358907296290491560440772390713810515859307960866
+70172427121883998797908792274921901699720888093776
+65727333001053367881220235421809751254540594752243
+52584907711670556013604839586446706324415722155397
+53697817977846174064955149290862569321978468622482
+83972241375657056057490261407972968652414535100474
+82166370484403199890008895243450658541227588666881
+16427171479924442928230863465674813919123162824586
+17866458359124566529476545682848912883142607690042
+24219022671055626321111109370544217506941658960408
+07198403850962455444362981230987879927244284909188
+84580156166097919133875499200524063689912560717606
+05886116467109405077541002256983155200055935729725
+71636269561882670428252483600823257530420752963450
+
+Find the thirteen adjacent digits in the 1000-digit number that have the
+greatest product. What is the value of this product?
+"""
+
 from functools import reduce
 
-def main():
-    number=input().strip()
-    print(max([reduce(lambda x,y: int(x)*int(y),number[i:i+13]) for i in range(len(number)-12)]))
-    
-if __name__ == '__main__':
-    main()
+N = (
+    "73167176531330624919225119674426574742355349194934"
+    "96983520312774506326239578318016984801869478851843"
+    "85861560789112949495459501737958331952853208805511"
+    "12540698747158523863050715693290963295227443043557"
+    "66896648950445244523161731856403098711121722383113"
+    "62229893423380308135336276614282806444486645238749"
+    "30358907296290491560440772390713810515859307960866"
+    "70172427121883998797908792274921901699720888093776"
+    "65727333001053367881220235421809751254540594752243"
+    "52584907711670556013604839586446706324415722155397"
+    "53697817977846174064955149290862569321978468622482"
+    "83972241375657056057490261407972968652414535100474"
+    "82166370484403199890008895243450658541227588666881"
+    "16427171479924442928230863465674813919123162824586"
+    "17866458359124566529476545682848912883142607690042"
+    "24219022671055626321111109370544217506941658960408"
+    "07198403850962455444362981230987879927244284909188"
+    "84580156166097919133875499200524063689912560717606"
+    "05886116467109405077541002256983155200055935729725"
+    "71636269561882670428252483600823257530420752963450"
+)
+
+
+def solution(n):
+    """Find the thirteen adjacent digits in the 1000-digit number n that have
+    the greatest product and returns it.
+ 
+    >>> solution(N)
+    23514624000
+    """
+    return max(
+        [
+            reduce(lambda x, y: int(x) * int(y), n[i : i + 13])
+            for i in range(len(n) - 12)
+        ]
+    )
+
+
+if __name__ == "__main__":
+    print(solution(str(N)))
diff --git a/project_euler/problem_09/__init__.py b/project_euler/problem_09/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/project_euler/problem_09/sol1.py b/project_euler/problem_09/sol1.py
index e54c543b4721..0f368e48d2e3 100644
--- a/project_euler/problem_09/sol1.py
+++ b/project_euler/problem_09/sol1.py
@@ -1,15 +1,36 @@
+"""
+Problem Statement:
+A Pythagorean triplet is a set of three natural numbers, a < b < c, for which,
+    a^2 + b^2 = c^2
+For example, 3^2 + 4^2 = 9 + 16 = 25 = 5^2.
+
+There exists exactly one Pythagorean triplet for which a + b + c = 1000.
+Find the product abc.
+"""
 from __future__ import print_function
-# Program to find the product of a,b,c which are Pythagorean Triplet that satisfice the following:
-# 1. a < b < c
-# 2. a**2 + b**2 = c**2
-# 3. a + b + c = 1000
-
-print("Please Wait...")
-for a in range(300):
-    for b in range(400):
-        for c in range(500):
-            if(a < b < c):
-                if((a**2) + (b**2) == (c**2)):
-                    if((a+b+c) == 1000):
-                        print(("Product of",a,"*",b,"*",c,"=",(a*b*c)))
-                        break
+
+
+def solution():
+    """
+     Returns the product of a,b,c which are Pythagorean Triplet that satisfies
+     the following:
+     1. a < b < c
+     2. a**2 + b**2 = c**2
+     3. a + b + c = 1000
+    
+    >>> solution()
+    31875000
+    """
+    for a in range(300):
+        for b in range(400):
+            for c in range(500):
+                if a < b < c:
+                    if (a ** 2) + (b ** 2) == (c ** 2):
+                        if (a + b + c) == 1000:
+                            return a * b * c
+                            break
+
+
+if __name__ == "__main__":
+    print("Please Wait...")
+    print(solution())
diff --git a/project_euler/problem_09/sol2.py b/project_euler/problem_09/sol2.py
index 933f5c557d71..674daae9ec8e 100644
--- a/project_euler/problem_09/sol2.py
+++ b/project_euler/problem_09/sol2.py
@@ -1,18 +1,44 @@
-"""A Pythagorean triplet is a set of three natural numbers, for which,
-a^2+b^2=c^2
-Given N, Check if there exists any Pythagorean triplet for which a+b+c=N
-Find maximum possible value of product of a,b,c among all such Pythagorean triplets, If there is no such Pythagorean triplet print -1."""
-#!/bin/python3
+"""
+Problem Statement:
+A Pythagorean triplet is a set of three natural numbers, a < b < c, for which,
+    a^2 + b^2 = c^2
+For example, 3^2 + 4^2 = 9 + 16 = 25 = 5^2.
 
-product=-1
-d=0
-N = int(input())
-for a in range(1,N//3):
-    """Solving the two equations a**2+b**2=c**2 and a+b+c=N eliminating c """
-    b=(N*N-2*a*N)//(2*N-2*a)
-    c=N-a-b
-    if c*c==(a*a+b*b):
-        d=(a*b*c)
-        if d>=product:
-            product=d
-print(product)
+There exists exactly one Pythagorean triplet for which a + b + c = 1000.
+Find the product abc.
+"""
+from __future__ import print_function
+
+try:
+    raw_input  # Python 2
+except NameError:
+    raw_input = input  # Python 3
+
+
+def solution(n):
+    """
+     Return the product of a,b,c which are Pythagorean Triplet that satisfies
+     the following:
+     1. a < b < c
+     2. a**2 + b**2 = c**2
+     3. a + b + c = 1000
+    
+    >>> solution(1000)
+    31875000
+    """
+    product = -1
+    d = 0
+    for a in range(1, n // 3):
+        """Solving the two equations a**2+b**2=c**2 and a+b+c=N eliminating c
+        """
+        b = (n * n - 2 * a * n) // (2 * n - 2 * a)
+        c = n - a - b
+        if c * c == (a * a + b * b):
+            d = a * b * c
+            if d >= product:
+                product = d
+    return product
+
+
+if __name__ == "__main__":
+    print(solution(int(raw_input().strip())))
diff --git a/project_euler/problem_09/sol3.py b/project_euler/problem_09/sol3.py
index 5ebf38e76e1a..f749b8a61f11 100644
--- a/project_euler/problem_09/sol3.py
+++ b/project_euler/problem_09/sol3.py
@@ -1,6 +1,37 @@
-def main():
-    print([a*b*c for a in range(1,999) for b in range(a,999) for c in range(b,999) 
-    if (a*a+b*b==c*c) and (a+b+c==1000 ) ][0])
-  
-if __name__ == '__main__':
-    main()
+"""
+Problem Statement:
+
+A Pythagorean triplet is a set of three natural numbers, a < b < c, for which,
+
+    a^2 + b^2 = c^2
+
+For example, 3^2 + 4^2 = 9 + 16 = 25 = 5^2.
+
+There exists exactly one Pythagorean triplet for which a + b + c = 1000.
+Find the product abc.
+"""
+from __future__ import print_function
+
+
+def solution():
+    """
+     Returns the product of a,b,c which are Pythagorean Triplet that satisfies
+     the following:
+
+     1. a**2 + b**2 = c**2
+     2. a + b + c = 1000
+
+    >>> solution()
+    31875000
+    """
+    return [
+        a * b * c
+        for a in range(1, 999)
+        for b in range(a, 999)
+        for c in range(b, 999)
+        if (a * a + b * b == c * c) and (a + b + c == 1000)
+    ][0]
+
+
+if __name__ == "__main__":
+    print(solution())
diff --git a/project_euler/problem_10/__init__.py b/project_euler/problem_10/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/project_euler/problem_10/sol1.py b/project_euler/problem_10/sol1.py
index 94e5b7362114..038da96e6352 100644
--- a/project_euler/problem_10/sol1.py
+++ b/project_euler/problem_10/sol1.py
@@ -1,38 +1,60 @@
+"""
+Problem Statement:
+The sum of the primes below 10 is 2 + 3 + 5 + 7 = 17.
+
+Find the sum of all the primes below two million.
+"""
 from __future__ import print_function
 from math import sqrt
 
 try:
-	xrange			#Python 2
+    raw_input  # Python 2
+except NameError:
+    raw_input = input  # Python 3
+
+try:
+    xrange  # Python 2
 except NameError:
-	xrange = range	#Python 3
+    xrange = range  # Python 3
+
 
 def is_prime(n):
-	for i in xrange(2, int(sqrt(n))+1):
-		if n%i == 0:
-			return False
+    for i in xrange(2, int(sqrt(n)) + 1):
+        if n % i == 0:
+            return False
+
+    return True
 
-	return True
 
 def sum_of_primes(n):
-	if n > 2:
-		sumOfPrimes = 2
-	else:
-		return 0
-
-	for i in xrange(3, n, 2):
-		if is_prime(i):
-			sumOfPrimes += i
-
-	return sumOfPrimes
-
-if __name__ == '__main__':
-	import sys
-
-	if len(sys.argv) == 1:
-		print(sum_of_primes(2000000))
-	else:
-		try:
-			n = int(sys.argv[1])
-			print(sum_of_primes(n))
-		except ValueError:
-			print('Invalid entry - please enter a number.')
+    if n > 2:
+        sumOfPrimes = 2
+    else:
+        return 0
+
+    for i in xrange(3, n, 2):
+        if is_prime(i):
+            sumOfPrimes += i
+
+    return sumOfPrimes
+
+
+def solution(n):
+    """Returns the sum of all the primes below n.
+    
+    >>> solution(2000000)
+    142913828922
+    >>> solution(1000)
+    76127
+    >>> solution(5000)
+    1548136
+    >>> solution(10000)
+    5736396
+    >>> solution(7)
+    10
+    """
+    return sum_of_primes(n)
+
+
+if __name__ == "__main__":
+    print(solution(int(raw_input().strip())))
diff --git a/project_euler/problem_10/sol2.py b/project_euler/problem_10/sol2.py
index 22df95c063e2..9e51d61b8749 100644
--- a/project_euler/problem_10/sol2.py
+++ b/project_euler/problem_10/sol2.py
@@ -1,22 +1,49 @@
-#from Python.Math import prime_generator
-import math 
-from itertools import takewhile 
+"""
+Problem Statement:
+The sum of the primes below 10 is 2 + 3 + 5 + 7 = 17.
+
+Find the sum of all the primes below two million.
+"""
+from __future__ import print_function
+import math
+from itertools import takewhile
+
+try:
+    raw_input  # Python 2
+except NameError:
+    raw_input = input  # Python 3
+
 
 def primeCheck(number):
     if number % 2 == 0 and number > 2:
         return False
     return all(number % i for i in range(3, int(math.sqrt(number)) + 1, 2))
-    
+
+
 def prime_generator():
     num = 2
     while True:
         if primeCheck(num):
             yield num
-        num+=1
-        
-def main():
-    n = int(input('Enter The upper limit of prime numbers: '))  
-    print(sum(takewhile(lambda x: x < n,prime_generator())))
+        num += 1
+
+
+def solution(n):
+    """Returns the sum of all the primes below n.
     
-if __name__ == '__main__':
-    main() 
+    >>> solution(2000000)
+    142913828922
+    >>> solution(1000)
+    76127
+    >>> solution(5000)
+    1548136
+    >>> solution(10000)
+    5736396
+    >>> solution(7)
+    10
+    """
+    return sum(takewhile(lambda x: x < n, prime_generator()))
+
+
+if __name__ == "__main__":
+    print(solution(int(raw_input().strip())))
diff --git a/project_euler/problem_11/__init__.py b/project_euler/problem_11/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/project_euler/problem_11/sol1.py b/project_euler/problem_11/sol1.py
index b882dc449156..3bdddc89d917 100644
--- a/project_euler/problem_11/sol1.py
+++ b/project_euler/problem_11/sol1.py
@@ -1,6 +1,6 @@
-from __future__ import print_function
-'''
-What is the greatest product of four adjacent numbers (horizontally, vertically, or diagonally) in this 20x20 array?
+"""
+What is the greatest product of four adjacent numbers (horizontally,
+vertically, or diagonally) in this 20x20 array?
 
 08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08
 49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00
@@ -22,47 +22,78 @@
 20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16
 20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54
 01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48
-'''
+"""
+
+from __future__ import print_function
+import os
 
 try:
-	xrange			#Python 2
+    xrange  # Python 2
 except NameError:
-	xrange = range	#Python 2
+    xrange = range  # Python 2
+
 
 def largest_product(grid):
-	nColumns = len(grid[0])
-	nRows = len(grid)
+    nColumns = len(grid[0])
+    nRows = len(grid)
+
+    largest = 0
+    lrDiagProduct = 0
+    rlDiagProduct = 0
+
+    # Check vertically, horizontally, diagonally at the same time (only works
+    # for nxn grid)
+    for i in xrange(nColumns):
+        for j in xrange(nRows - 3):
+            vertProduct = (
+                grid[j][i] * grid[j + 1][i] * grid[j + 2][i] * grid[j + 3][i]
+            )
+            horzProduct = (
+                grid[i][j] * grid[i][j + 1] * grid[i][j + 2] * grid[i][j + 3]
+            )
+
+            # Left-to-right diagonal (\) product
+            if i < nColumns - 3:
+                lrDiagProduct = (
+                    grid[i][j]
+                    * grid[i + 1][j + 1]
+                    * grid[i + 2][j + 2]
+                    * grid[i + 3][j + 3]
+                )
 
-	largest = 0
-	lrDiagProduct = 0
-	rlDiagProduct = 0
+            # Right-to-left diagonal(/) product
+            if i > 2:
+                rlDiagProduct = (
+                    grid[i][j]
+                    * grid[i - 1][j + 1]
+                    * grid[i - 2][j + 2]
+                    * grid[i - 3][j + 3]
+                )
 
-	#Check vertically, horizontally, diagonally at the same time (only works for nxn grid)
-	for i in xrange(nColumns):
-		for j in xrange(nRows-3):
-			vertProduct = grid[j][i]*grid[j+1][i]*grid[j+2][i]*grid[j+3][i]
-			horzProduct = grid[i][j]*grid[i][j+1]*grid[i][j+2]*grid[i][j+3]
+            maxProduct = max(
+                vertProduct, horzProduct, lrDiagProduct, rlDiagProduct
+            )
+            if maxProduct > largest:
+                largest = maxProduct
 
-			#Left-to-right diagonal (\) product
-			if (i < nColumns-3):
-				lrDiagProduct = grid[i][j]*grid[i+1][j+1]*grid[i+2][j+2]*grid[i+3][j+3]
+    return largest
 
-			#Right-to-left diagonal(/) product
-			if (i > 2):
-				rlDiagProduct = grid[i][j]*grid[i-1][j+1]*grid[i-2][j+2]*grid[i-3][j+3]
 
-			maxProduct = max(vertProduct, horzProduct, lrDiagProduct, rlDiagProduct)
-			if maxProduct > largest:
-				largest = maxProduct
+def solution():
+    """Returns the sum of all the multiples of 3 or 5 below n.
+    
+    >>> solution()
+    70600674
+    """
+    grid = []
+    with open(os.path.dirname(__file__) + "/grid.txt") as file:
+        for line in file:
+            grid.append(line.strip("\n").split(" "))
 
-	return largest
+    grid = [[int(i) for i in grid[j]] for j in xrange(len(grid))]
 
-if __name__ == '__main__':
-	grid = []
-	with open('grid.txt') as file:
-		for line in file:
-			grid.append(line.strip('\n').split(' '))
+    return largest_product(grid)
 
-	grid = [[int(i) for i in grid[j]] for j in xrange(len(grid))]
 
-	print(largest_product(grid))
\ No newline at end of file
+if __name__ == "__main__":
+    print(solution())
diff --git a/project_euler/problem_11/sol2.py b/project_euler/problem_11/sol2.py
index b03395f01697..0a5785b42b2c 100644
--- a/project_euler/problem_11/sol2.py
+++ b/project_euler/problem_11/sol2.py
@@ -1,39 +1,90 @@
-def main():
-	with open ("grid.txt", "r") as f:
-		l = []
-		for i in range(20):
-			l.append([int(x) for x in f.readline().split()])
-
-		maximum = 0
-
-		# right
-		for i in range(20):
-			for j in range(17):
-				temp = l[i][j] * l[i][j+1] * l[i][j+2] * l[i][j+3]
-				if temp > maximum:
-					maximum = temp
-
-		# down 
-		for i in range(17):
-			for j in range(20):
-				temp = l[i][j] * l[i+1][j] * l[i+2][j] * l[i+3][j]
-				if temp > maximum:
-					maximum = temp
-
-		#diagonal 1
-		for i in range(17):
-			for j in range(17):
-				temp = l[i][j] * l[i+1][j+1] * l[i+2][j+2] * l[i+3][j+3]
-				if temp > maximum:
-					maximum = temp
-				
-		#diagonal 2
-		for i in range(17):
-			for j in range(3, 20):
-				temp = l[i][j] * l[i+1][j-1] * l[i+2][j-2] * l[i+3][j-3]
-				if temp > maximum:
-					maximum = temp
-		print(maximum)
-
-if __name__ == '__main__':
-	main()
\ No newline at end of file
+"""
+What is the greatest product of four adjacent numbers (horizontally,
+vertically, or diagonally) in this 20x20 array?
+
+08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08
+49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00
+81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65
+52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91
+22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80
+24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50
+32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70
+67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21
+24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72
+21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95
+78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92
+16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57
+86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58
+19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40
+04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66
+88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69
+04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36
+20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16
+20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54
+01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48
+"""
+
+from __future__ import print_function
+import os
+
+try:
+    xrange  # Python 2
+except NameError:
+    xrange = range  # Python 2
+
+
+def solution():
+    """Returns the sum of all the multiples of 3 or 5 below n.
+    
+    >>> solution()
+    70600674
+    """
+    with open(os.path.dirname(__file__) + "/grid.txt") as f:
+        l = []
+        for i in xrange(20):
+            l.append([int(x) for x in f.readline().split()])
+
+        maximum = 0
+
+        # right
+        for i in xrange(20):
+            for j in xrange(17):
+                temp = l[i][j] * l[i][j + 1] * l[i][j + 2] * l[i][j + 3]
+                if temp > maximum:
+                    maximum = temp
+
+        # down
+        for i in xrange(17):
+            for j in xrange(20):
+                temp = l[i][j] * l[i + 1][j] * l[i + 2][j] * l[i + 3][j]
+                if temp > maximum:
+                    maximum = temp
+
+        # diagonal 1
+        for i in xrange(17):
+            for j in xrange(17):
+                temp = (
+                    l[i][j]
+                    * l[i + 1][j + 1]
+                    * l[i + 2][j + 2]
+                    * l[i + 3][j + 3]
+                )
+                if temp > maximum:
+                    maximum = temp
+
+        # diagonal 2
+        for i in xrange(17):
+            for j in xrange(3, 20):
+                temp = (
+                    l[i][j]
+                    * l[i + 1][j - 1]
+                    * l[i + 2][j - 2]
+                    * l[i + 3][j - 3]
+                )
+                if temp > maximum:
+                    maximum = temp
+        return maximum
+
+
+if __name__ == "__main__":
+    print(solution())
diff --git a/project_euler/problem_12/__init__.py b/project_euler/problem_12/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/project_euler/problem_12/sol1.py b/project_euler/problem_12/sol1.py
index 73d48a2ec897..baf9babab686 100644
--- a/project_euler/problem_12/sol1.py
+++ b/project_euler/problem_12/sol1.py
@@ -1,9 +1,9 @@
-from __future__ import print_function
-from math import sqrt
-'''
+"""
 Highly divisible triangular numbers
 Problem 12
-The sequence of triangle numbers is generated by adding the natural numbers. So the 7th triangle number would be 1 + 2 + 3 + 4 + 5 + 6 + 7 = 28. The first ten terms would be:
+The sequence of triangle numbers is generated by adding the natural numbers. So
+the 7th triangle number would be 1 + 2 + 3 + 4 + 5 + 6 + 7 = 28. The first ten
+terms would be:
 
 1, 3, 6, 10, 15, 21, 28, 36, 45, 55, ...
 
@@ -18,31 +18,48 @@
 28: 1,2,4,7,14,28
 We can see that 28 is the first triangle number to have over five divisors.
 
-What is the value of the first triangle number to have over five hundred divisors?
-'''
+What is the value of the first triangle number to have over five hundred
+divisors?
+"""
+from __future__ import print_function
+from math import sqrt
+
 try:
-	xrange		#Python 2
+    xrange  # Python 2
 except NameError:
-	xrange = range	#Python 3
+    xrange = range  # Python 3
+
 
 def count_divisors(n):
-	nDivisors = 0
-	for i in xrange(1, int(sqrt(n))+1):
-		if n%i == 0:
-			nDivisors += 2
-	#check if n is perfect square 
-	if n**0.5 == int(n**0.5): 
-        	nDivisors -= 1
-	return nDivisors
-
-tNum = 1
-i = 1
-
-while True:
-	i += 1
-	tNum += i
-
-	if count_divisors(tNum) > 500:
-		break
-
-print(tNum)
+    nDivisors = 0
+    for i in xrange(1, int(sqrt(n)) + 1):
+        if n % i == 0:
+            nDivisors += 2
+    # check if n is perfect square
+    if n ** 0.5 == int(n ** 0.5):
+        nDivisors -= 1
+    return nDivisors
+
+
+def solution():
+    """Returns the value of the first triangle number to have over five hundred
+    divisors.
+    
+    >>> solution()
+    76576500
+    """
+    tNum = 1
+    i = 1
+
+    while True:
+        i += 1
+        tNum += i
+
+        if count_divisors(tNum) > 500:
+            break
+
+    return tNum
+
+
+if __name__ == "__main__":
+    print(solution())
diff --git a/project_euler/problem_12/sol2.py b/project_euler/problem_12/sol2.py
index 479ab2b900cb..071d7516ac0f 100644
--- a/project_euler/problem_12/sol2.py
+++ b/project_euler/problem_12/sol2.py
@@ -1,8 +1,51 @@
-def triangle_number_generator(): 
-    for n in range(1,1000000):
-        yield n*(n+1)//2
-        
-def count_divisors(n): 
-    return sum([2 for i in range(1,int(n**0.5)+1) if n%i==0 and i*i != n])
-
-print(next(i for i in triangle_number_generator() if count_divisors(i) > 500))
+"""
+Highly divisible triangular numbers
+Problem 12
+The sequence of triangle numbers is generated by adding the natural numbers. So
+the 7th triangle number would be 1 + 2 + 3 + 4 + 5 + 6 + 7 = 28. The first ten
+terms would be:
+
+1, 3, 6, 10, 15, 21, 28, 36, 45, 55, ...
+
+Let us list the factors of the first seven triangle numbers:
+
+ 1: 1
+ 3: 1,3
+ 6: 1,2,3,6
+10: 1,2,5,10
+15: 1,3,5,15
+21: 1,3,7,21
+28: 1,2,4,7,14,28
+We can see that 28 is the first triangle number to have over five divisors.
+
+What is the value of the first triangle number to have over five hundred
+divisors?
+"""
+from __future__ import print_function
+
+
+def triangle_number_generator():
+    for n in range(1, 1000000):
+        yield n * (n + 1) // 2
+
+
+def count_divisors(n):
+    return sum(
+        [2 for i in range(1, int(n ** 0.5) + 1) if n % i == 0 and i * i != n]
+    )
+
+
+def solution():
+    """Returns the value of the first triangle number to have over five hundred
+    divisors.
+    
+    >>> solution()
+    76576500
+    """
+    return next(
+        i for i in triangle_number_generator() if count_divisors(i) > 500
+    )
+
+
+if __name__ == "__main__":
+    print(solution())
diff --git a/project_euler/problem_13/__init__.py b/project_euler/problem_13/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/project_euler/problem_13/sol1.py b/project_euler/problem_13/sol1.py
index faaaad5e88c1..983347675b3f 100644
--- a/project_euler/problem_13/sol1.py
+++ b/project_euler/problem_13/sol1.py
@@ -1,14 +1,36 @@
-'''
+"""
 Problem Statement:
-Work out the first ten digits of the sum of the N 50-digit numbers.
-'''
+Work out the first ten digits of the sum of the following one-hundred 50-digit
+numbers.
+"""
 from __future__ import print_function
+import os
 
-n = int(input().strip())
+try:
+    raw_input  # Python 2
+except NameError:
+    raw_input = input  # Python 3
 
-array = []
-for i in range(n):
-    array.append(int(input().strip()))
 
-print(str(sum(array))[:10])
+def solution(array):
+    """Returns the first ten digits of the sum of the array elements.
+    
+    >>> sum = 0
+    >>> array = []
+    >>> with open(os.path.dirname(__file__) + "/num.txt","r") as f:
+    ...     for line in f:
+    ...         array.append(int(line))
+    ...
+    >>> solution(array)
+    '5537376230'
+    """
+    return str(sum(array))[:10]
 
+
+if __name__ == "__main__":
+    n = int(input().strip())
+
+    array = []
+    for i in range(n):
+        array.append(int(input().strip()))
+    print(solution(array))
diff --git a/project_euler/problem_13/sol2.py b/project_euler/problem_13/sol2.py
deleted file mode 100644
index c1416bcd6e7d..000000000000
--- a/project_euler/problem_13/sol2.py
+++ /dev/null
@@ -1,5 +0,0 @@
-sum = 0
-with open("num.txt",'r') as f:
-    for line in f:
-        sum += int(line)
-print(str(sum)[:10])
diff --git a/project_euler/problem_14/__init__.py b/project_euler/problem_14/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/project_euler/problem_14/sol1.py b/project_euler/problem_14/sol1.py
index 9037f6eb8bd5..6b80cd7cb24b 100644
--- a/project_euler/problem_14/sol1.py
+++ b/project_euler/problem_14/sol1.py
@@ -1,21 +1,73 @@
+# -*- coding: utf-8 -*-
+"""
+Problem Statement:
+The following iterative sequence is defined for the set of positive integers:
+
+    n → n/2 (n is even)
+    n → 3n + 1 (n is odd)
+
+Using the rule above and starting with 13, we generate the following sequence:
+
+    13 → 40 → 20 → 10 → 5 → 16 → 8 → 4 → 2 → 1
+
+It can be seen that this sequence (starting at 13 and finishing at 1) contains
+10 terms. Although it has not been proved yet (Collatz Problem), it is thought
+that all starting numbers finish at 1.
+
+Which starting number, under one million, produces the longest chain?
+"""
 from __future__ import print_function
-largest_number = 0
-pre_counter = 0
-
-for input1 in range(750000,1000000):
-    counter = 1
-    number = input1
-
-    while number > 1:
-        if number % 2 == 0:
-            number /=2
-            counter += 1
-        else:
-            number = (3*number)+1
-            counter += 1
-
-    if counter > pre_counter:
-        largest_number = input1
-        pre_counter = counter
-
-print(('Largest Number:',largest_number,'->',pre_counter,'digits'))
+
+try:
+    raw_input  # Python 2
+except NameError:
+    raw_input = input  # Python 3
+
+
+def solution(n):
+    """Returns the number under n that generates the longest sequence using the
+    formula:
+    n → n/2 (n is even)
+    n → 3n + 1 (n is odd)
+ 
+    >>> solution(1000000)
+    {'counter': 525, 'largest_number': 837799}
+    >>> solution(200)
+    {'counter': 125, 'largest_number': 171}
+    >>> solution(5000)
+    {'counter': 238, 'largest_number': 3711}
+    >>> solution(15000)
+    {'counter': 276, 'largest_number': 13255}
+    """
+    largest_number = 0
+    pre_counter = 0
+
+    for input1 in range(n):
+        counter = 1
+        number = input1
+
+        while number > 1:
+            if number % 2 == 0:
+                number /= 2
+                counter += 1
+            else:
+                number = (3 * number) + 1
+                counter += 1
+
+        if counter > pre_counter:
+            largest_number = input1
+            pre_counter = counter
+    return {"counter": pre_counter, "largest_number": largest_number}
+
+
+if __name__ == "__main__":
+    result = solution(int(raw_input().strip()))
+    print(
+        (
+            "Largest Number:",
+            result["largest_number"],
+            "->",
+            result["counter"],
+            "digits",
+        )
+    )
diff --git a/project_euler/problem_14/sol2.py b/project_euler/problem_14/sol2.py
index b9de42be1108..59fa79515148 100644
--- a/project_euler/problem_14/sol2.py
+++ b/project_euler/problem_14/sol2.py
@@ -1,16 +1,69 @@
+# -*- coding: utf-8 -*-
+"""
+Collatz conjecture: start with any positive integer n. Next term obtained from
+the previous term as follows:
+
+If the previous term is even, the next term is one half the previous term.
+If the previous term is odd, the next term is 3 times the previous term plus 1.
+The conjecture states the sequence will always reach 1 regardless of starting
+n.
+
+Problem Statement:
+The following iterative sequence is defined for the set of positive integers:
+
+    n → n/2 (n is even)
+    n → 3n + 1 (n is odd)
+
+Using the rule above and starting with 13, we generate the following sequence:
+
+    13 → 40 → 20 → 10 → 5 → 16 → 8 → 4 → 2 → 1
+
+It can be seen that this sequence (starting at 13 and finishing at 1) contains
+10 terms. Although it has not been proved yet (Collatz Problem), it is thought
+that all starting numbers finish at 1.
+
+Which starting number, under one million, produces the longest chain?
+"""
+from __future__ import print_function
+
+try:
+    raw_input  # Python 2
+except NameError:
+    raw_input = input  # Python 3
+
+
 def collatz_sequence(n):
-  """Collatz conjecture: start with any positive integer n.Next termis obtained from the previous term as follows:
-  if the previous term is even, the next term is one half the previous term.
-  If the previous term is odd, the next term is 3 times the previous term plus 1.
-  The conjecture states the sequence will always reach 1 regaardess of starting n."""
-  sequence = [n]
-  while n != 1:
-    if n % 2 == 0:# even
-      n //= 2
-    else:
-      n = 3*n +1
-    sequence.append(n)
-  return sequence
-
-answer = max([(len(collatz_sequence(i)), i)  for i in range(1,1000000)])
-print("Longest Collatz sequence under one million is %d with length %d" % (answer[1],answer[0]))
\ No newline at end of file
+    """Returns the Collatz sequence for n."""
+    sequence = [n]
+    while n != 1:
+        if n % 2 == 0:
+            n //= 2
+        else:
+            n = 3 * n + 1
+        sequence.append(n)
+    return sequence
+
+
+def solution(n):
+    """Returns the number under n that generates the longest Collatz sequence.
+
+    >>> solution(1000000)
+    {'counter': 525, 'largest_number': 837799}
+    >>> solution(200)
+    {'counter': 125, 'largest_number': 171}
+    >>> solution(5000)
+    {'counter': 238, 'largest_number': 3711}
+    >>> solution(15000)
+    {'counter': 276, 'largest_number': 13255}
+    """
+
+    result = max([(len(collatz_sequence(i)), i) for i in range(1, n)])
+    return {"counter": result[0], "largest_number": result[1]}
+
+
+if __name__ == "__main__":
+    result = solution(int(raw_input().strip()))
+    print(
+        "Longest Collatz sequence under one million is %d with length %d"
+        % (result["largest_number"], result["counter"])
+    )
diff --git a/project_euler/problem_15/__init__.py b/project_euler/problem_15/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/project_euler/problem_15/sol1.py b/project_euler/problem_15/sol1.py
index d24748011ef9..de58bb436d68 100644
--- a/project_euler/problem_15/sol1.py
+++ b/project_euler/problem_15/sol1.py
@@ -1,20 +1,57 @@
-from __future__ import print_function
+"""
+Starting in the top left corner of a 2×2 grid, and only being able to move to
+the right and down, there are exactly 6 routes to the bottom right corner.
+How many such routes are there through a 20×20 grid?
+"""
 from math import factorial
 
+
 def lattice_paths(n):
-	n = 2*n #middle entry of odd rows starting at row 3 is the solution for n = 1, 2, 3,...
-	k = n/2
-
-	return factorial(n)/(factorial(k)*factorial(n-k))
-
-if __name__ == '__main__':
-	import sys
-
-	if len(sys.argv) == 1:
-		print(lattice_paths(20))
-	else:
-		try:
-			n = int(sys.argv[1])
-			print(lattice_paths(n))
-		except ValueError:
-			print('Invalid entry - please enter a number.')
+    """
+    Returns the number of paths possible in a n x n grid starting at top left
+    corner going to bottom right corner and being able to move right and down
+    only.
+
+bruno@bruno-laptop:~/git/Python/project_euler/problem_15$ python3 sol1.py 50
+1.008913445455642e+29
+bruno@bruno-laptop:~/git/Python/project_euler/problem_15$ python3 sol1.py 25
+126410606437752.0
+bruno@bruno-laptop:~/git/Python/project_euler/problem_15$ python3 sol1.py 23
+8233430727600.0
+bruno@bruno-laptop:~/git/Python/project_euler/problem_15$ python3 sol1.py 15
+155117520.0
+bruno@bruno-laptop:~/git/Python/project_euler/problem_15$ python3 sol1.py 1
+2.0
+
+    >>> lattice_paths(25)
+    126410606437752
+    >>> lattice_paths(23)
+    8233430727600
+    >>> lattice_paths(20)
+    137846528820
+    >>> lattice_paths(15)
+    155117520
+    >>> lattice_paths(1)
+    2
+
+    """
+    n = (
+        2 * n
+    )  # middle entry of odd rows starting at row 3 is the solution for n = 1,
+    # 2, 3,...
+    k = n / 2
+
+    return int(factorial(n) / (factorial(k) * factorial(n - k)))
+
+
+if __name__ == "__main__":
+    import sys
+
+    if len(sys.argv) == 1:
+        print(lattice_paths(20))
+    else:
+        try:
+            n = int(sys.argv[1])
+            print(lattice_paths(n))
+        except ValueError:
+            print("Invalid entry - please enter a number.")
diff --git a/project_euler/problem_16/__init__.py b/project_euler/problem_16/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/project_euler/problem_16/sol1.py b/project_euler/problem_16/sol1.py
index 05c7916bd10a..67c50ac87876 100644
--- a/project_euler/problem_16/sol1.py
+++ b/project_euler/problem_16/sol1.py
@@ -1,15 +1,34 @@
-power = int(input("Enter the power of 2: "))
-num = 2**power
+"""
+2^15 = 32768 and the sum of its digits is 3 + 2 + 7 + 6 + 8 = 26.
 
-string_num = str(num)
+What is the sum of the digits of the number 2^1000?
+"""
 
-list_num = list(string_num)
 
-sum_of_num = 0
+def solution(power):
+    """Returns the sum of the digits of the number 2^power.
+    >>> solution(1000)
+    1366
+    >>> solution(50)
+    76
+    >>> solution(20)
+    31
+    >>> solution(15)
+    26
+    """
+    num = 2 ** power
+    string_num = str(num)
+    list_num = list(string_num)
+    sum_of_num = 0
 
-print("2 ^",power,"=",num)
+    for i in list_num:
+        sum_of_num += int(i)
 
-for i in list_num:
-    sum_of_num += int(i)
+    return sum_of_num
 
-print("Sum of the digits are:",sum_of_num)
+
+if __name__ == "__main__":
+    power = int(input("Enter the power of 2: ").strip())
+    print("2 ^ ", power, " = ", 2 ** power)
+    result = solution(power)
+    print("Sum of the digits is: ", result)
diff --git a/project_euler/problem_16/sol2.py b/project_euler/problem_16/sol2.py
index cce3d2354bb1..88672e9a9e54 100644
--- a/project_euler/problem_16/sol2.py
+++ b/project_euler/problem_16/sol2.py
@@ -1,6 +1,28 @@
-from __future__ import print_function
-n = 2**1000
-r = 0
-while n:
-    r, n = r + n % 10, n // 10
-print(r)
+"""
+2^15 = 32768 and the sum of its digits is 3 + 2 + 7 + 6 + 8 = 26.
+
+What is the sum of the digits of the number 2^1000?
+"""
+
+
+def solution(power):
+    """Returns the sum of the digits of the number 2^power.
+    
+    >>> solution(1000)
+    1366
+    >>> solution(50)
+    76
+    >>> solution(20)
+    31
+    >>> solution(15)
+    26
+    """
+    n = 2 ** power
+    r = 0
+    while n:
+        r, n = r + n % 10, n // 10
+    return r
+
+
+if __name__ == "__main__":
+    print(solution(int(str(input()).strip())))
diff --git a/project_euler/problem_17/__init__.py b/project_euler/problem_17/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/project_euler/problem_17/sol1.py b/project_euler/problem_17/sol1.py
index 8dd6f1af2093..d585d81a0825 100644
--- a/project_euler/problem_17/sol1.py
+++ b/project_euler/problem_17/sol1.py
@@ -1,35 +1,63 @@
-from __future__ import print_function
-'''
+"""
 Number letter counts
 Problem 17
 
-If the numbers 1 to 5 are written out in words: one, two, three, four, five, then there are 3 + 3 + 5 + 4 + 4 = 19 letters used in total.
-
-If all the numbers from 1 to 1000 (one thousand) inclusive were written out in words, how many letters would be used?
-
-
-NOTE: Do not count spaces or hyphens. For example, 342 (three hundred and forty-two) contains 23 letters and 115 (one hundred and fifteen) 
-contains 20 letters. The use of "and" when writing out numbers is in compliance with British usage.
-'''
-
-ones_counts = [0, 3, 3, 5, 4, 4, 3, 5, 5, 4, 3, 6, 6, 8, 8, 7, 7, 9, 8, 8] #number of letters in zero, one, two, ..., nineteen (0 for zero since it's never said aloud)
-tens_counts = [0, 0, 6, 6, 5, 5, 5, 7, 6, 6] #number of letters in twenty, thirty, ..., ninety (0 for numbers less than 20 due to inconsistency in teens)
-
-count = 0
-
-for i in range(1, 1001):
-	if i < 1000:
-		if i >= 100:
-			count += ones_counts[i/100] + 7 #add number of letters for "n hundred"
-
-			if i%100 != 0:
-				count += 3 #add number of letters for "and" if number is not multiple of 100
-
-		if 0 < i%100 < 20:
-			count += ones_counts[i%100] #add number of letters for one, two, three, ..., nineteen (could be combined with below if not for inconsistency in teens)
-		else:
-			count += ones_counts[i%10] + tens_counts[(i%100-i%10)/10] #add number of letters for twenty, twenty one, ..., ninety nine
-	else:
-		count += ones_counts[i/1000] + 8
-
-print(count)
+If the numbers 1 to 5 are written out in words: one, two, three, four, five,
+then there are 3 + 3 + 5 + 4 + 4 = 19 letters used in total.
+
+If all the numbers from 1 to 1000 (one thousand) inclusive were written out in
+words, how many letters would be used?
+
+
+NOTE: Do not count spaces or hyphens. For example, 342 (three hundred and
+forty-two) contains 23 letters and 115 (one hundred and fifteen) contains 20
+letters. The use of "and" when writing out numbers is in compliance withBritish
+usage.
+"""
+
+
+def solution(n):
+    """Returns the number of letters used to write all numbers from 1 to n.
+    where n is lower or equals to 1000.
+    >>> solution(1000)
+    21124
+    >>> solution(5)
+    19
+    """
+    # number of letters in zero, one, two, ..., nineteen (0 for zero since it's
+    # never said aloud)
+    ones_counts = [0, 3, 3, 5, 4, 4, 3, 5, 5, 4, 3, 6, 6, 8, 8, 7, 7, 9, 8, 8]
+    # number of letters in twenty, thirty, ..., ninety (0 for numbers less than
+    # 20 due to inconsistency in teens)
+    tens_counts = [0, 0, 6, 6, 5, 5, 5, 7, 6, 6]
+
+    count = 0
+
+    for i in range(1, n + 1):
+        if i < 1000:
+            if i >= 100:
+                # add number of letters for "n hundred"
+                count += ones_counts[i // 100] + 7
+
+                if i % 100 != 0:
+                    # add number of letters for "and" if number is not multiple
+                    # of 100
+                    count += 3
+
+            if 0 < i % 100 < 20:
+                # add number of letters for one, two, three, ..., nineteen
+                # (could be combined with below if not for inconsistency in
+                # teens)
+                count += ones_counts[i % 100]
+            else:
+                # add number of letters for twenty, twenty one, ..., ninety
+                # nine
+                count += ones_counts[i % 10]
+                count += tens_counts[(i % 100 - i % 10) // 10]
+        else:
+            count += ones_counts[i // 1000] + 8
+    return count
+
+
+if __name__ == "__main__":
+    print(solution(int(input().strip())))
diff --git a/project_euler/problem_19/__init__.py b/project_euler/problem_19/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/project_euler/problem_19/sol1.py b/project_euler/problem_19/sol1.py
index 13e520ca76e4..6e4e29ec19c6 100644
--- a/project_euler/problem_19/sol1.py
+++ b/project_euler/problem_19/sol1.py
@@ -1,9 +1,9 @@
-from __future__ import print_function
-'''
+"""
 Counting Sundays
 Problem 19
 
-You are given the following information, but you may prefer to do some research for yourself.
+You are given the following information, but you may prefer to do some research
+for yourself.
 
 1 Jan 1900 was a Monday.
 Thirty days has September,
@@ -13,39 +13,52 @@
 Which has twenty-eight, rain or shine.
 And on leap years, twenty-nine.
 
-A leap year occurs on any year evenly divisible by 4, but not on a century unless it is divisible by 400.
+A leap year occurs on any year evenly divisible by 4, but not on a century
+unless it is divisible by 400.
 
-How many Sundays fell on the first of the month during the twentieth century (1 Jan 1901 to 31 Dec 2000)?
-'''
+How many Sundays fell on the first of the month during the twentieth century
+(1 Jan 1901 to 31 Dec 2000)?
+"""
 
-days_per_month = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
 
-day = 6
-month = 1
-year = 1901
+def solution():
+    """Returns the number of mondays that fall on the first of the month during
+    the twentieth century (1 Jan 1901 to 31 Dec 2000)?
 
-sundays = 0
+    >>> solution()
+    171
+    """
+    days_per_month = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
 
-while year < 2001:
-	day += 7
+    day = 6
+    month = 1
+    year = 1901
 
-	if (year%4 == 0 and not year%100 == 0) or (year%400 == 0):
-		if day > days_per_month[month-1] and month != 2:
-			month += 1
-			day = day-days_per_month[month-2]
-		elif day > 29 and month == 2:
-			month += 1
-			day = day-29
-	else:
-		if day > days_per_month[month-1]:
-			month += 1
-			day = day-days_per_month[month-2]
-	
-	if month > 12:
-		year += 1
-		month = 1
+    sundays = 0
 
-	if year < 2001 and day == 1:
-		sundays += 1
+    while year < 2001:
+        day += 7
 
-print(sundays)
+        if (year % 4 == 0 and not year % 100 == 0) or (year % 400 == 0):
+            if day > days_per_month[month - 1] and month != 2:
+                month += 1
+                day = day - days_per_month[month - 2]
+            elif day > 29 and month == 2:
+                month += 1
+                day = day - 29
+        else:
+            if day > days_per_month[month - 1]:
+                month += 1
+                day = day - days_per_month[month - 2]
+
+        if month > 12:
+            year += 1
+            month = 1
+
+        if year < 2001 and day == 1:
+            sundays += 1
+    return sundays
+
+
+if __name__ == "__main__":
+    print(solution(171))
diff --git a/project_euler/problem_20/__init__.py b/project_euler/problem_20/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/project_euler/problem_20/sol1.py b/project_euler/problem_20/sol1.py
index 73e41d5cc8fa..13b3c987f046 100644
--- a/project_euler/problem_20/sol1.py
+++ b/project_euler/problem_20/sol1.py
@@ -1,27 +1,51 @@
-# Finding the factorial.
+"""
+n! means n × (n − 1) × ... × 3 × 2 × 1
+
+For example, 10! = 10 × 9 × ... × 3 × 2 × 1 = 3628800,
+and the sum of the digits in the number 10! is 3 + 6 + 2 + 8 + 8 + 0 + 0 = 27.
+
+Find the sum of the digits in the number 100!
+"""
+
+
 def factorial(n):
     fact = 1
-    for i in range(1,n+1):
+    for i in range(1, n + 1):
         fact *= i
     return fact
 
-# Spliting the digits and adding it.
+
 def split_and_add(number):
+    """Split number digits and add them."""
     sum_of_digits = 0
-    while(number>0):
+    while number > 0:
         last_digit = number % 10
         sum_of_digits += last_digit
-        number = int(number/10) # Removing the last_digit from the given number.
+        number = number // 10  # Removing the last_digit from the given number
     return sum_of_digits
 
-# Taking the user input.
-number = int(input("Enter the Number: "))
 
-# Assigning the factorial from the factorial function.
-factorial = factorial(number)
+def solution(n):
+    """Returns the sum of the digits in the number 100!
+    >>> solution(100)
+    648
+    >>> solution(50)
+    216
+    >>> solution(10)
+    27
+    >>> solution(5)
+    3
+    >>> solution(3)
+    6
+    >>> solution(2)
+    2
+    >>> solution(1)
+    1
+    """
+    f = factorial(n)
+    result = split_and_add(f)
+    return result
 
-# Spliting and adding the factorial into answer.
-answer = split_and_add(factorial)
 
-# Printing the answer.
-print(answer)
+if __name__ == "__main__":
+    print(solution(int(input("Enter the Number: ").strip())))
diff --git a/project_euler/problem_20/sol2.py b/project_euler/problem_20/sol2.py
index bca9af9cb9ef..14e591795292 100644
--- a/project_euler/problem_20/sol2.py
+++ b/project_euler/problem_20/sol2.py
@@ -1,5 +1,33 @@
+"""
+n! means n × (n − 1) × ... × 3 × 2 × 1
+
+For example, 10! = 10 × 9 × ... × 3 × 2 × 1 = 3628800,
+and the sum of the digits in the number 10! is 3 + 6 + 2 + 8 + 8 + 0 + 0 = 27.
+
+Find the sum of the digits in the number 100!
+"""
 from math import factorial
-def main():
-	print(sum([int(x) for x in str(factorial(100))]))
-if __name__ == '__main__':
-	main()
\ No newline at end of file
+
+
+def solution(n):
+    """Returns the sum of the digits in the number 100!
+    >>> solution(100)
+    648
+    >>> solution(50)
+    216
+    >>> solution(10)
+    27
+    >>> solution(5)
+    3
+    >>> solution(3)
+    6
+    >>> solution(2)
+    2
+    >>> solution(1)
+    1
+    """
+    return sum([int(x) for x in str(factorial(n))])
+
+
+if __name__ == "__main__":
+    print(solution(int(input("Enter the Number: ").strip())))
diff --git a/project_euler/problem_21/__init__.py b/project_euler/problem_21/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/project_euler/problem_21/sol1.py b/project_euler/problem_21/sol1.py
index da29a5c7b631..9cf2a64cf2a9 100644
--- a/project_euler/problem_21/sol1.py
+++ b/project_euler/problem_21/sol1.py
@@ -1,30 +1,61 @@
-#-.- coding: latin-1 -.-
-from __future__ import print_function
+# -.- coding: latin-1 -.-
 from math import sqrt
-'''
+
+"""
 Amicable Numbers
 Problem 21
 
-Let d(n) be defined as the sum of proper divisors of n (numbers less than n which divide evenly into n).
-If d(a) = b and d(b) = a, where a ≠ b, then a and b are an amicable pair and each of a and b are called amicable numbers.
+Let d(n) be defined as the sum of proper divisors of n (numbers less than n
+which divide evenly into n).
+If d(a) = b and d(b) = a, where a ≠ b, then a and b are an amicable pair and
+each of a and b are called amicable numbers.
 
-For example, the proper divisors of 220 are 1, 2, 4, 5, 10, 11, 20, 22, 44, 55 and 110; therefore d(220) = 284. The proper divisors of 284 are 1, 2, 4, 71 and 142; so d(284) = 220.
+For example, the proper divisors of 220 are 1, 2, 4, 5, 10, 11, 20, 22, 44, 55
+and 110; therefore d(220) = 284. The proper divisors of 284 are 1, 2, 4, 71 and
+142; so d(284) = 220.
 
 Evaluate the sum of all the amicable numbers under 10000.
-'''
+"""
 try:
-	xrange		#Python 2
+    xrange  # Python 2
 except NameError:
-	xrange = range	#Python 3
+    xrange = range  # Python 3
+
 
 def sum_of_divisors(n):
-	total = 0
-	for i in xrange(1, int(sqrt(n)+1)):
-		if n%i == 0 and i != sqrt(n):
-			total += i + n//i
-		elif i == sqrt(n):
-			total += i
-	return total-n
-
-total = [i for i in range(1,10000) if sum_of_divisors(sum_of_divisors(i)) == i and sum_of_divisors(i) != i]
-print(sum(total))
+    total = 0
+    for i in xrange(1, int(sqrt(n) + 1)):
+        if n % i == 0 and i != sqrt(n):
+            total += i + n // i
+        elif i == sqrt(n):
+            total += i
+    return total - n
+
+
+def solution(n):
+    """Returns the sum of all the amicable numbers under n.
+
+    >>> solution(10000)
+    31626
+    >>> solution(5000)
+    8442
+    >>> solution(1000)
+    504
+    >>> solution(100)
+    0
+    >>> solution(50)
+    0
+    """
+    total = sum(
+        [
+            i
+            for i in range(1, n)
+            if sum_of_divisors(sum_of_divisors(i)) == i
+            and sum_of_divisors(i) != i
+        ]
+    )
+    return total
+
+
+if __name__ == "__main__":
+    print(solution(int(str(input()).strip())))
diff --git a/project_euler/problem_22/__init__.py b/project_euler/problem_22/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/project_euler/problem_22/sol1.py b/project_euler/problem_22/sol1.py
index 7754306583dc..aa779f222eaa 100644
--- a/project_euler/problem_22/sol1.py
+++ b/project_euler/problem_22/sol1.py
@@ -1,37 +1,52 @@
 # -*- coding: latin-1 -*-
-from __future__ import print_function
-'''
+"""
 Name scores
 Problem 22
 
-Using names.txt (right click and 'Save Link/Target As...'), a 46K text file containing over five-thousand first names, begin by sorting it 
-into alphabetical order. Then working out the alphabetical value for each name, multiply this value by its alphabetical position in the list 
-to obtain a name score.
+Using names.txt (right click and 'Save Link/Target As...'), a 46K text file
+containing over five-thousand first names, begin by sorting it into
+alphabetical order. Then working out the alphabetical value for each name,
+multiply this value by its alphabetical position in the list to obtain a name
+score.
 
-For example, when the list is sorted into alphabetical order, COLIN, which is worth 3 + 15 + 12 + 9 + 14 = 53, is the 938th name in the list. 
-So, COLIN would obtain a score of 938 × 53 = 49714.
+For example, when the list is sorted into alphabetical order, COLIN, which is
+worth 3 + 15 + 12 + 9 + 14 = 53, is the 938th name in the list. So, COLIN would
+obtain a score of 938 × 53 = 49714.
 
 What is the total of all the name scores in the file?
-'''
+"""
+import os
+
+
 try:
-	xrange		#Python 2
+    xrange  # Python 2
 except NameError:
-	xrange = range	#Python 3
+    xrange = range  # Python 3
+
+
+def solution():
+    """Returns the total of all the name scores in the file.
+
+    >>> solution()
+    871198282
+    """
+    with open(os.path.dirname(__file__) + "/p022_names.txt") as file:
+        names = str(file.readlines()[0])
+        names = names.replace('"', "").split(",")
 
-with open('p022_names.txt') as file:
-	names = str(file.readlines()[0])
-	names = names.replace('"', '').split(',')
+    names.sort()
 
-names.sort()
+    name_score = 0
+    total_score = 0
 
-name_score = 0
-total_score = 0
+    for i, name in enumerate(names):
+        for letter in name:
+            name_score += ord(letter) - 64
 
-for i, name in enumerate(names):
-	for letter in name:
-		name_score += ord(letter) - 64
+        total_score += (i + 1) * name_score
+        name_score = 0
+    return total_score
 
-	total_score += (i+1)*name_score
-	name_score = 0
 
-print(total_score)
\ No newline at end of file
+if __name__ == "__main__":
+    print(solution())
diff --git a/project_euler/problem_22/sol2.py b/project_euler/problem_22/sol2.py
index d7f9abf09d49..69acd2fb8ef3 100644
--- a/project_euler/problem_22/sol2.py
+++ b/project_euler/problem_22/sol2.py
@@ -1,533 +1,43 @@
-def main():
-	name = [  
-	"MARY", "PATRICIA", "LINDA", "BARBARA", "ELIZABETH", "JENNIFER", "MARIA", "SUSAN", "MARGARET", "DOROTHY",
-	"LISA", "NANCY", "KAREN", "BETTY", "HELEN", "SANDRA", "DONNA", "CAROL", "RUTH", "SHARON",
-	"MICHELLE", "LAURA", "SARAH", "KIMBERLY", "DEBORAH", "JESSICA", "SHIRLEY", "CYNTHIA", "ANGELA", "MELISSA",
-	"BRENDA", "AMY", "ANNA", "REBECCA", "VIRGINIA", "KATHLEEN", "PAMELA", "MARTHA", "DEBRA", "AMANDA",
-	"STEPHANIE", "CAROLYN", "CHRISTINE", "MARIE", "JANET", "CATHERINE", "FRANCES", "ANN", "JOYCE", "DIANE",
-	"ALICE", "JULIE", "HEATHER", "TERESA", "DORIS", "GLORIA", "EVELYN", "JEAN", "CHERYL", "MILDRED",
-	"KATHERINE", "JOAN", "ASHLEY", "JUDITH", "ROSE", "JANICE", "KELLY", "NICOLE", "JUDY", "CHRISTINA",
-	"KATHY", "THERESA", "BEVERLY", "DENISE", "TAMMY", "IRENE", "JANE", "LORI", "RACHEL", "MARILYN",
-	"ANDREA", "KATHRYN", "LOUISE", "SARA", "ANNE", "JACQUELINE", "WANDA", "BONNIE", "JULIA", "RUBY",
-	"LOIS", "TINA", "PHYLLIS", "NORMA", "PAULA", "DIANA", "ANNIE", "LILLIAN", "EMILY", "ROBIN",
-	"PEGGY", "CRYSTAL", "GLADYS", "RITA", "DAWN", "CONNIE", "FLORENCE", "TRACY", "EDNA", "TIFFANY",
-	"CARMEN", "ROSA", "CINDY", "GRACE", "WENDY", "VICTORIA", "EDITH", "KIM", "SHERRY", "SYLVIA",
-	"JOSEPHINE", "THELMA", "SHANNON", "SHEILA", "ETHEL", "ELLEN", "ELAINE", "MARJORIE", "CARRIE", "CHARLOTTE",
-	"MONICA", "ESTHER", "PAULINE", "EMMA", "JUANITA", "ANITA", "RHONDA", "HAZEL", "AMBER", "EVA",
-	"DEBBIE", "APRIL", "LESLIE", "CLARA", "LUCILLE", "JAMIE", "JOANNE", "ELEANOR", "VALERIE", "DANIELLE",
-	"MEGAN", "ALICIA", "SUZANNE", "MICHELE", "GAIL", "BERTHA", "DARLENE", "VERONICA", "JILL", "ERIN",
-	"GERALDINE", "LAUREN", "CATHY", "JOANN", "LORRAINE", "LYNN", "SALLY", "REGINA", "ERICA", "BEATRICE",
-	"DOLORES", "BERNICE", "AUDREY", "YVONNE", "ANNETTE", "JUNE", "SAMANTHA", "MARION", "DANA", "STACY",
-	"ANA", "RENEE", "IDA", "VIVIAN", "ROBERTA", "HOLLY", "BRITTANY", "MELANIE", "LORETTA", "YOLANDA",
-	"JEANETTE", "LAURIE", "KATIE", "KRISTEN", "VANESSA", "ALMA", "SUE", "ELSIE", "BETH", "JEANNE",
-	"VICKI", "CARLA", "TARA", "ROSEMARY", "EILEEN", "TERRI", "GERTRUDE", "LUCY", "TONYA", "ELLA",
-	"STACEY", "WILMA", "GINA", "KRISTIN", "JESSIE", "NATALIE", "AGNES", "VERA", "WILLIE", "CHARLENE",
-	"BESSIE", "DELORES", "MELINDA", "PEARL", "ARLENE", "MAUREEN", "COLLEEN", "ALLISON", "TAMARA", "JOY",
-	"GEORGIA", "CONSTANCE", "LILLIE", "CLAUDIA", "JACKIE", "MARCIA", "TANYA", "NELLIE", "MINNIE", "MARLENE",
-	"HEIDI", "GLENDA", "LYDIA", "VIOLA", "COURTNEY", "MARIAN", "STELLA", "CAROLINE", "DORA", "JO",
-	"VICKIE", "MATTIE", "TERRY", "MAXINE", "IRMA", "MABEL", "MARSHA", "MYRTLE", "LENA", "CHRISTY",
-	"DEANNA", "PATSY", "HILDA", "GWENDOLYN", "JENNIE", "NORA", "MARGIE", "NINA", "CASSANDRA", "LEAH",
-	"PENNY", "KAY", "PRISCILLA", "NAOMI", "CAROLE", "BRANDY", "OLGA", "BILLIE", "DIANNE", "TRACEY",
-	"LEONA", "JENNY", "FELICIA", "SONIA", "MIRIAM", "VELMA", "BECKY", "BOBBIE", "VIOLET", "KRISTINA",
-	"TONI", "MISTY", "MAE", "SHELLY", "DAISY", "RAMONA", "SHERRI", "ERIKA", "KATRINA", "CLAIRE",
-	"LINDSEY", "LINDSAY", "GENEVA", "GUADALUPE", "BELINDA", "MARGARITA", "SHERYL", "CORA", "FAYE", "ADA",
-	"NATASHA", "SABRINA", "ISABEL", "MARGUERITE", "HATTIE", "HARRIET", "MOLLY", "CECILIA", "KRISTI", "BRANDI",
-	"BLANCHE", "SANDY", "ROSIE", "JOANNA", "IRIS", "EUNICE", "ANGIE", "INEZ", "LYNDA", "MADELINE",
-	"AMELIA", "ALBERTA", "GENEVIEVE", "MONIQUE", "JODI", "JANIE", "MAGGIE", "KAYLA", "SONYA", "JAN",
-	"LEE", "KRISTINE", "CANDACE", "FANNIE", "MARYANN", "OPAL", "ALISON", "YVETTE", "MELODY", "LUZ",
-	"SUSIE", "OLIVIA", "FLORA", "SHELLEY", "KRISTY", "MAMIE", "LULA", "LOLA", "VERNA", "BEULAH",
-	"ANTOINETTE", "CANDICE", "JUANA", "JEANNETTE", "PAM", "KELLI", "HANNAH", "WHITNEY", "BRIDGET", "KARLA",
-	"CELIA", "LATOYA", "PATTY", "SHELIA", "GAYLE", "DELLA", "VICKY", "LYNNE", "SHERI", "MARIANNE",
-	"KARA", "JACQUELYN", "ERMA", "BLANCA", "MYRA", "LETICIA", "PAT", "KRISTA", "ROXANNE", "ANGELICA",
-	"JOHNNIE", "ROBYN", "FRANCIS", "ADRIENNE", "ROSALIE", "ALEXANDRA", "BROOKE", "BETHANY", "SADIE", "BERNADETTE",
-	"TRACI", "JODY", "KENDRA", "JASMINE", "NICHOLE", "RACHAEL", "CHELSEA", "MABLE", "ERNESTINE", "MURIEL",
-	"MARCELLA", "ELENA", "KRYSTAL", "ANGELINA", "NADINE", "KARI", "ESTELLE", "DIANNA", "PAULETTE", "LORA",
-	"MONA", "DOREEN", "ROSEMARIE", "ANGEL", "DESIREE", "ANTONIA", "HOPE", "GINGER", "JANIS", "BETSY",
-	"CHRISTIE", "FREDA", "MERCEDES", "MEREDITH", "LYNETTE", "TERI", "CRISTINA", "EULA", "LEIGH", "MEGHAN",
-	"SOPHIA", "ELOISE", "ROCHELLE", "GRETCHEN", "CECELIA", "RAQUEL", "HENRIETTA", "ALYSSA", "JANA", "KELLEY",
-	"GWEN", "KERRY", "JENNA", "TRICIA", "LAVERNE", "OLIVE", "ALEXIS", "TASHA", "SILVIA", "ELVIRA",
-	"CASEY", "DELIA", "SOPHIE", "KATE", "PATTI", "LORENA", "KELLIE", "SONJA", "LILA", "LANA",
-	"DARLA", "MAY", "MINDY", "ESSIE", "MANDY", "LORENE", "ELSA", "JOSEFINA", "JEANNIE", "MIRANDA",
-	"DIXIE", "LUCIA", "MARTA", "FAITH", "LELA", "JOHANNA", "SHARI", "CAMILLE", "TAMI", "SHAWNA",
-	"ELISA", "EBONY", "MELBA", "ORA", "NETTIE", "TABITHA", "OLLIE", "JAIME", "WINIFRED", "KRISTIE",
-	"MARINA", "ALISHA", "AIMEE", "RENA", "MYRNA", "MARLA", "TAMMIE", "LATASHA", "BONITA", "PATRICE",
-	"RONDA", "SHERRIE", "ADDIE", "FRANCINE", "DELORIS", "STACIE", "ADRIANA", "CHERI", "SHELBY", "ABIGAIL",
-	"CELESTE", "JEWEL", "CARA", "ADELE", "REBEKAH", "LUCINDA", "DORTHY", "CHRIS", "EFFIE", "TRINA",
-	"REBA", "SHAWN", "SALLIE", "AURORA", "LENORA", "ETTA", "LOTTIE", "KERRI", "TRISHA", "NIKKI",
-	"ESTELLA", "FRANCISCA", "JOSIE", "TRACIE", "MARISSA", "KARIN", "BRITTNEY", "JANELLE", "LOURDES", "LAUREL",
-	"HELENE", "FERN", "ELVA", "CORINNE", "KELSEY", "INA", "BETTIE", "ELISABETH", "AIDA", "CAITLIN",
-	"INGRID", "IVA", "EUGENIA", "CHRISTA", "GOLDIE", "CASSIE", "MAUDE", "JENIFER", "THERESE", "FRANKIE",
-	"DENA", "LORNA", "JANETTE", "LATONYA", "CANDY", "MORGAN", "CONSUELO", "TAMIKA", "ROSETTA", "DEBORA",
-	"CHERIE", "POLLY", "DINA", "JEWELL", "FAY", "JILLIAN", "DOROTHEA", "NELL", "TRUDY", "ESPERANZA",
-	"PATRICA", "KIMBERLEY", "SHANNA", "HELENA", "CAROLINA", "CLEO", "STEFANIE", "ROSARIO", "OLA", "JANINE",
-	"MOLLIE", "LUPE", "ALISA", "LOU", "MARIBEL", "SUSANNE", "BETTE", "SUSANA", "ELISE", "CECILE",
-	"ISABELLE", "LESLEY", "JOCELYN", "PAIGE", "JONI", "RACHELLE", "LEOLA", "DAPHNE", "ALTA", "ESTER",
-	"PETRA", "GRACIELA", "IMOGENE", "JOLENE", "KEISHA", "LACEY", "GLENNA", "GABRIELA", "KERI", "URSULA",
-	"LIZZIE", "KIRSTEN", "SHANA", "ADELINE", "MAYRA", "JAYNE", "JACLYN", "GRACIE", "SONDRA", "CARMELA",
-	"MARISA", "ROSALIND", "CHARITY", "TONIA", "BEATRIZ", "MARISOL", "CLARICE", "JEANINE", "SHEENA", "ANGELINE",
-	"FRIEDA", "LILY", "ROBBIE", "SHAUNA", "MILLIE", "CLAUDETTE", "CATHLEEN", "ANGELIA", "GABRIELLE", "AUTUMN",
-	"KATHARINE", "SUMMER", "JODIE", "STACI", "LEA", "CHRISTI", "JIMMIE", "JUSTINE", "ELMA", "LUELLA",
-	"MARGRET", "DOMINIQUE", "SOCORRO", "RENE", "MARTINA", "MARGO", "MAVIS", "CALLIE", "BOBBI", "MARITZA",
-	"LUCILE", "LEANNE", "JEANNINE", "DEANA", "AILEEN", "LORIE", "LADONNA", "WILLA", "MANUELA", "GALE",
-	"SELMA", "DOLLY", "SYBIL", "ABBY", "LARA", "DALE", "IVY", "DEE", "WINNIE", "MARCY",
-	"LUISA", "JERI", "MAGDALENA", "OFELIA", "MEAGAN", "AUDRA", "MATILDA", "LEILA", "CORNELIA", "BIANCA",
-	"SIMONE", "BETTYE", "RANDI", "VIRGIE", "LATISHA", "BARBRA", "GEORGINA", "ELIZA", "LEANN", "BRIDGETTE",
-	"RHODA", "HALEY", "ADELA", "NOLA", "BERNADINE", "FLOSSIE", "ILA", "GRETA", "RUTHIE", "NELDA",
-	"MINERVA", "LILLY", "TERRIE", "LETHA", "HILARY", "ESTELA", "VALARIE", "BRIANNA", "ROSALYN", "EARLINE",
-	"CATALINA", "AVA", "MIA", "CLARISSA", "LIDIA", "CORRINE", "ALEXANDRIA", "CONCEPCION", "TIA", "SHARRON",
-	"RAE", "DONA", "ERICKA", "JAMI", "ELNORA", "CHANDRA", "LENORE", "NEVA", "MARYLOU", "MELISA",
-	"TABATHA", "SERENA", "AVIS", "ALLIE", "SOFIA", "JEANIE", "ODESSA", "NANNIE", "HARRIETT", "LORAINE",
-	"PENELOPE", "MILAGROS", "EMILIA", "BENITA", "ALLYSON", "ASHLEE", "TANIA", "TOMMIE", "ESMERALDA", "KARINA",
-	"EVE", "PEARLIE", "ZELMA", "MALINDA", "NOREEN", "TAMEKA", "SAUNDRA", "HILLARY", "AMIE", "ALTHEA",
-	"ROSALINDA", "JORDAN", "LILIA", "ALANA", "GAY", "CLARE", "ALEJANDRA", "ELINOR", "MICHAEL", "LORRIE",
-	"JERRI", "DARCY", "EARNESTINE", "CARMELLA", "TAYLOR", "NOEMI", "MARCIE", "LIZA", "ANNABELLE", "LOUISA",
-	"EARLENE", "MALLORY", "CARLENE", "NITA", "SELENA", "TANISHA", "KATY", "JULIANNE", "JOHN", "LAKISHA",
-	"EDWINA", "MARICELA", "MARGERY", "KENYA", "DOLLIE", "ROXIE", "ROSLYN", "KATHRINE", "NANETTE", "CHARMAINE",
-	"LAVONNE", "ILENE", "KRIS", "TAMMI", "SUZETTE", "CORINE", "KAYE", "JERRY", "MERLE", "CHRYSTAL",
-	"LINA", "DEANNE", "LILIAN", "JULIANA", "ALINE", "LUANN", "KASEY", "MARYANNE", "EVANGELINE", "COLETTE",
-	"MELVA", "LAWANDA", "YESENIA", "NADIA", "MADGE", "KATHIE", "EDDIE", "OPHELIA", "VALERIA", "NONA",
-	"MITZI", "MARI", "GEORGETTE", "CLAUDINE", "FRAN", "ALISSA", "ROSEANN", "LAKEISHA", "SUSANNA", "REVA",
-	"DEIDRE", "CHASITY", "SHEREE", "CARLY", "JAMES", "ELVIA", "ALYCE", "DEIRDRE", "GENA", "BRIANA",
-	"ARACELI", "KATELYN", "ROSANNE", "WENDI", "TESSA", "BERTA", "MARVA", "IMELDA", "MARIETTA", "MARCI",
-	"LEONOR", "ARLINE", "SASHA", "MADELYN", "JANNA", "JULIETTE", "DEENA", "AURELIA", "JOSEFA", "AUGUSTA",
-	"LILIANA", "YOUNG", "CHRISTIAN", "LESSIE", "AMALIA", "SAVANNAH", "ANASTASIA", "VILMA", "NATALIA", "ROSELLA",
-	"LYNNETTE", "CORINA", "ALFREDA", "LEANNA", "CAREY", "AMPARO", "COLEEN", "TAMRA", "AISHA", "WILDA",
-	"KARYN", "CHERRY", "QUEEN", "MAURA", "MAI", "EVANGELINA", "ROSANNA", "HALLIE", "ERNA", "ENID",
-	"MARIANA", "LACY", "JULIET", "JACKLYN", "FREIDA", "MADELEINE", "MARA", "HESTER", "CATHRYN", "LELIA",
-	"CASANDRA", "BRIDGETT", "ANGELITA", "JANNIE", "DIONNE", "ANNMARIE", "KATINA", "BERYL", "PHOEBE", "MILLICENT",
-	"KATHERYN", "DIANN", "CARISSA", "MARYELLEN", "LIZ", "LAURI", "HELGA", "GILDA", "ADRIAN", "RHEA",
-	"MARQUITA", "HOLLIE", "TISHA", "TAMERA", "ANGELIQUE", "FRANCESCA", "BRITNEY", "KAITLIN", "LOLITA", "FLORINE",
-	"ROWENA", "REYNA", "TWILA", "FANNY", "JANELL", "INES", "CONCETTA", "BERTIE", "ALBA", "BRIGITTE",
-	"ALYSON", "VONDA", "PANSY", "ELBA", "NOELLE", "LETITIA", "KITTY", "DEANN", "BRANDIE", "LOUELLA",
-	"LETA", "FELECIA", "SHARLENE", "LESA", "BEVERLEY", "ROBERT", "ISABELLA", "HERMINIA", "TERRA", "CELINA",
-	"TORI", "OCTAVIA", "JADE", "DENICE", "GERMAINE", "SIERRA", "MICHELL", "CORTNEY", "NELLY", "DORETHA",
-	"SYDNEY", "DEIDRA", "MONIKA", "LASHONDA", "JUDI", "CHELSEY", "ANTIONETTE", "MARGOT", "BOBBY", "ADELAIDE",
-	"NAN", "LEEANN", "ELISHA", "DESSIE", "LIBBY", "KATHI", "GAYLA", "LATANYA", "MINA", "MELLISA",
-	"KIMBERLEE", "JASMIN", "RENAE", "ZELDA", "ELDA", "MA", "JUSTINA", "GUSSIE", "EMILIE", "CAMILLA",
-	"ABBIE", "ROCIO", "KAITLYN", "JESSE", "EDYTHE", "ASHLEIGH", "SELINA", "LAKESHA", "GERI", "ALLENE",
-	"PAMALA", "MICHAELA", "DAYNA", "CARYN", "ROSALIA", "SUN", "JACQULINE", "REBECA", "MARYBETH", "KRYSTLE",
-	"IOLA", "DOTTIE", "BENNIE", "BELLE", "AUBREY", "GRISELDA", "ERNESTINA", "ELIDA", "ADRIANNE", "DEMETRIA",
-	"DELMA", "CHONG", "JAQUELINE", "DESTINY", "ARLEEN", "VIRGINA", "RETHA", "FATIMA", "TILLIE", "ELEANORE",
-	"CARI", "TREVA", "BIRDIE", "WILHELMINA", "ROSALEE", "MAURINE", "LATRICE", "YONG", "JENA", "TARYN",
-	"ELIA", "DEBBY", "MAUDIE", "JEANNA", "DELILAH", "CATRINA", "SHONDA", "HORTENCIA", "THEODORA", "TERESITA",
-	"ROBBIN", "DANETTE", "MARYJANE", "FREDDIE", "DELPHINE", "BRIANNE", "NILDA", "DANNA", "CINDI", "BESS",
-	"IONA", "HANNA", "ARIEL", "WINONA", "VIDA", "ROSITA", "MARIANNA", "WILLIAM", "RACHEAL", "GUILLERMINA",
-	"ELOISA", "CELESTINE", "CAREN", "MALISSA", "LONA", "CHANTEL", "SHELLIE", "MARISELA", "LEORA", "AGATHA",
-	"SOLEDAD", "MIGDALIA", "IVETTE", "CHRISTEN", "ATHENA", "JANEL", "CHLOE", "VEDA", "PATTIE", "TESSIE",
-	"TERA", "MARILYNN", "LUCRETIA", "KARRIE", "DINAH", "DANIELA", "ALECIA", "ADELINA", "VERNICE", "SHIELA",
-	"PORTIA", "MERRY", "LASHAWN", "DEVON", "DARA", "TAWANA", "OMA", "VERDA", "CHRISTIN", "ALENE",
-	"ZELLA", "SANDI", "RAFAELA", "MAYA", "KIRA", "CANDIDA", "ALVINA", "SUZAN", "SHAYLA", "LYN",
-	"LETTIE", "ALVA", "SAMATHA", "ORALIA", "MATILDE", "MADONNA", "LARISSA", "VESTA", "RENITA", "INDIA",
-	"DELOIS", "SHANDA", "PHILLIS", "LORRI", "ERLINDA", "CRUZ", "CATHRINE", "BARB", "ZOE", "ISABELL",
-	"IONE", "GISELA", "CHARLIE", "VALENCIA", "ROXANNA", "MAYME", "KISHA", "ELLIE", "MELLISSA", "DORRIS",
-	"DALIA", "BELLA", "ANNETTA", "ZOILA", "RETA", "REINA", "LAURETTA", "KYLIE", "CHRISTAL", "PILAR",
-	"CHARLA", "ELISSA", "TIFFANI", "TANA", "PAULINA", "LEOTA", "BREANNA", "JAYME", "CARMEL", "VERNELL",
-	"TOMASA", "MANDI", "DOMINGA", "SANTA", "MELODIE", "LURA", "ALEXA", "TAMELA", "RYAN", "MIRNA",
-	"KERRIE", "VENUS", "NOEL", "FELICITA", "CRISTY", "CARMELITA", "BERNIECE", "ANNEMARIE", "TIARA", "ROSEANNE",
-	"MISSY", "CORI", "ROXANA", "PRICILLA", "KRISTAL", "JUNG", "ELYSE", "HAYDEE", "ALETHA", "BETTINA",
-	"MARGE", "GILLIAN", "FILOMENA", "CHARLES", "ZENAIDA", "HARRIETTE", "CARIDAD", "VADA", "UNA", "ARETHA",
-	"PEARLINE", "MARJORY", "MARCELA", "FLOR", "EVETTE", "ELOUISE", "ALINA", "TRINIDAD", "DAVID", "DAMARIS",
-	"CATHARINE", "CARROLL", "BELVA", "NAKIA", "MARLENA", "LUANNE", "LORINE", "KARON", "DORENE", "DANITA",
-	"BRENNA", "TATIANA", "SAMMIE", "LOUANN", "LOREN", "JULIANNA", "ANDRIA", "PHILOMENA", "LUCILA", "LEONORA",
-	"DOVIE", "ROMONA", "MIMI", "JACQUELIN", "GAYE", "TONJA", "MISTI", "JOE", "GENE", "CHASTITY",
-	"STACIA", "ROXANN", "MICAELA", "NIKITA", "MEI", "VELDA", "MARLYS", "JOHNNA", "AURA", "LAVERN",
-	"IVONNE", "HAYLEY", "NICKI", "MAJORIE", "HERLINDA", "GEORGE", "ALPHA", "YADIRA", "PERLA", "GREGORIA",
-	"DANIEL", "ANTONETTE", "SHELLI", "MOZELLE", "MARIAH", "JOELLE", "CORDELIA", "JOSETTE", "CHIQUITA", "TRISTA",
-	"LOUIS", "LAQUITA", "GEORGIANA", "CANDI", "SHANON", "LONNIE", "HILDEGARD", "CECIL", "VALENTINA", "STEPHANY",
-	"MAGDA", "KAROL", "GERRY", "GABRIELLA", "TIANA", "ROMA", "RICHELLE", "RAY", "PRINCESS", "OLETA",
-	"JACQUE", "IDELLA", "ALAINA", "SUZANNA", "JOVITA", "BLAIR", "TOSHA", "RAVEN", "NEREIDA", "MARLYN",
-	"KYLA", "JOSEPH", "DELFINA", "TENA", "STEPHENIE", "SABINA", "NATHALIE", "MARCELLE", "GERTIE", "DARLEEN",
-	"THEA", "SHARONDA", "SHANTEL", "BELEN", "VENESSA", "ROSALINA", "ONA", "GENOVEVA", "COREY", "CLEMENTINE",
-	"ROSALBA", "RENATE", "RENATA", "MI", "IVORY", "GEORGIANNA", "FLOY", "DORCAS", "ARIANA", "TYRA",
-	"THEDA", "MARIAM", "JULI", "JESICA", "DONNIE", "VIKKI", "VERLA", "ROSELYN", "MELVINA", "JANNETTE",
-	"GINNY", "DEBRAH", "CORRIE", "ASIA", "VIOLETA", "MYRTIS", "LATRICIA", "COLLETTE", "CHARLEEN", "ANISSA",
-	"VIVIANA", "TWYLA", "PRECIOUS", "NEDRA", "LATONIA", "LAN", "HELLEN", "FABIOLA", "ANNAMARIE", "ADELL",
-	"SHARYN", "CHANTAL", "NIKI", "MAUD", "LIZETTE", "LINDY", "KIA", "KESHA", "JEANA", "DANELLE",
-	"CHARLINE", "CHANEL", "CARROL", "VALORIE", "LIA", "DORTHA", "CRISTAL", "SUNNY", "LEONE", "LEILANI",
-	"GERRI", "DEBI", "ANDRA", "KESHIA", "IMA", "EULALIA", "EASTER", "DULCE", "NATIVIDAD", "LINNIE",
-	"KAMI", "GEORGIE", "CATINA", "BROOK", "ALDA", "WINNIFRED", "SHARLA", "RUTHANN", "MEAGHAN", "MAGDALENE",
-	"LISSETTE", "ADELAIDA", "VENITA", "TRENA", "SHIRLENE", "SHAMEKA", "ELIZEBETH", "DIAN", "SHANTA", "MICKEY",
-	"LATOSHA", "CARLOTTA", "WINDY", "SOON", "ROSINA", "MARIANN", "LEISA", "JONNIE", "DAWNA", "CATHIE",
-	"BILLY", "ASTRID", "SIDNEY", "LAUREEN", "JANEEN", "HOLLI", "FAWN", "VICKEY", "TERESSA", "SHANTE",
-	"RUBYE", "MARCELINA", "CHANDA", "CARY", "TERESE", "SCARLETT", "MARTY", "MARNIE", "LULU", "LISETTE",
-	"JENIFFER", "ELENOR", "DORINDA", "DONITA", "CARMAN", "BERNITA", "ALTAGRACIA", "ALETA", "ADRIANNA", "ZORAIDA",
-	"RONNIE", "NICOLA", "LYNDSEY", "KENDALL", "JANINA", "CHRISSY", "AMI", "STARLA", "PHYLIS", "PHUONG",
-	"KYRA", "CHARISSE", "BLANCH", "SANJUANITA", "RONA", "NANCI", "MARILEE", "MARANDA", "CORY", "BRIGETTE",
-	"SANJUANA", "MARITA", "KASSANDRA", "JOYCELYN", "IRA", "FELIPA", "CHELSIE", "BONNY", "MIREYA", "LORENZA",
-	"KYONG", "ILEANA", "CANDELARIA", "TONY", "TOBY", "SHERIE", "OK", "MARK", "LUCIE", "LEATRICE",
-	"LAKESHIA", "GERDA", "EDIE", "BAMBI", "MARYLIN", "LAVON", "HORTENSE", "GARNET", "EVIE", "TRESSA",
-	"SHAYNA", "LAVINA", "KYUNG", "JEANETTA", "SHERRILL", "SHARA", "PHYLISS", "MITTIE", "ANABEL", "ALESIA",
-	"THUY", "TAWANDA", "RICHARD", "JOANIE", "TIFFANIE", "LASHANDA", "KARISSA", "ENRIQUETA", "DARIA", "DANIELLA",
-	"CORINNA", "ALANNA", "ABBEY", "ROXANE", "ROSEANNA", "MAGNOLIA", "LIDA", "KYLE", "JOELLEN", "ERA",
-	"CORAL", "CARLEEN", "TRESA", "PEGGIE", "NOVELLA", "NILA", "MAYBELLE", "JENELLE", "CARINA", "NOVA",
-	"MELINA", "MARQUERITE", "MARGARETTE", "JOSEPHINA", "EVONNE", "DEVIN", "CINTHIA", "ALBINA", "TOYA", "TAWNYA",
-	"SHERITA", "SANTOS", "MYRIAM", "LIZABETH", "LISE", "KEELY", "JENNI", "GISELLE", "CHERYLE", "ARDITH",
-	"ARDIS", "ALESHA", "ADRIANE", "SHAINA", "LINNEA", "KAROLYN", "HONG", "FLORIDA", "FELISHA", "DORI",
-	"DARCI", "ARTIE", "ARMIDA", "ZOLA", "XIOMARA", "VERGIE", "SHAMIKA", "NENA", "NANNETTE", "MAXIE",
-	"LOVIE", "JEANE", "JAIMIE", "INGE", "FARRAH", "ELAINA", "CAITLYN", "STARR", "FELICITAS", "CHERLY",
-	"CARYL", "YOLONDA", "YASMIN", "TEENA", "PRUDENCE", "PENNIE", "NYDIA", "MACKENZIE", "ORPHA", "MARVEL",
-	"LIZBETH", "LAURETTE", "JERRIE", "HERMELINDA", "CAROLEE", "TIERRA", "MIRIAN", "META", "MELONY", "KORI",
-	"JENNETTE", "JAMILA", "ENA", "ANH", "YOSHIKO", "SUSANNAH", "SALINA", "RHIANNON", "JOLEEN", "CRISTINE",
-	"ASHTON", "ARACELY", "TOMEKA", "SHALONDA", "MARTI", "LACIE", "KALA", "JADA", "ILSE", "HAILEY",
-	"BRITTANI", "ZONA", "SYBLE", "SHERRYL", "RANDY", "NIDIA", "MARLO", "KANDICE", "KANDI", "DEB",
-	"DEAN", "AMERICA", "ALYCIA", "TOMMY", "RONNA", "NORENE", "MERCY", "JOSE", "INGEBORG", "GIOVANNA",
-	"GEMMA", "CHRISTEL", "AUDRY", "ZORA", "VITA", "VAN", "TRISH", "STEPHAINE", "SHIRLEE", "SHANIKA",
-	"MELONIE", "MAZIE", "JAZMIN", "INGA", "HOA", "HETTIE", "GERALYN", "FONDA", "ESTRELLA", "ADELLA",
-	"SU", "SARITA", "RINA", "MILISSA", "MARIBETH", "GOLDA", "EVON", "ETHELYN", "ENEDINA", "CHERISE",
-	"CHANA", "VELVA", "TAWANNA", "SADE", "MIRTA", "LI", "KARIE", "JACINTA", "ELNA", "DAVINA",
-	"CIERRA", "ASHLIE", "ALBERTHA", "TANESHA", "STEPHANI", "NELLE", "MINDI", "LU", "LORINDA", "LARUE",
-	"FLORENE", "DEMETRA", "DEDRA", "CIARA", "CHANTELLE", "ASHLY", "SUZY", "ROSALVA", "NOELIA", "LYDA",
-	"LEATHA", "KRYSTYNA", "KRISTAN", "KARRI", "DARLINE", "DARCIE", "CINDA", "CHEYENNE", "CHERRIE", "AWILDA",
-	"ALMEDA", "ROLANDA", "LANETTE", "JERILYN", "GISELE", "EVALYN", "CYNDI", "CLETA", "CARIN", "ZINA",
-	"ZENA", "VELIA", "TANIKA", "PAUL", "CHARISSA", "THOMAS", "TALIA", "MARGARETE", "LAVONDA", "KAYLEE",
-	"KATHLENE", "JONNA", "IRENA", "ILONA", "IDALIA", "CANDIS", "CANDANCE", "BRANDEE", "ANITRA", "ALIDA",
-	"SIGRID", "NICOLETTE", "MARYJO", "LINETTE", "HEDWIG", "CHRISTIANA", "CASSIDY", "ALEXIA", "TRESSIE", "MODESTA",
-	"LUPITA", "LITA", "GLADIS", "EVELIA", "DAVIDA", "CHERRI", "CECILY", "ASHELY", "ANNABEL", "AGUSTINA",
-	"WANITA", "SHIRLY", "ROSAURA", "HULDA", "EUN", "BAILEY", "YETTA", "VERONA", "THOMASINA", "SIBYL",
-	"SHANNAN", "MECHELLE", "LUE", "LEANDRA", "LANI", "KYLEE", "KANDY", "JOLYNN", "FERNE", "EBONI",
-	"CORENE", "ALYSIA", "ZULA", "NADA", "MOIRA", "LYNDSAY", "LORRETTA", "JUAN", "JAMMIE", "HORTENSIA",
-	"GAYNELL", "CAMERON", "ADRIA", "VINA", "VICENTA", "TANGELA", "STEPHINE", "NORINE", "NELLA", "LIANA",
-	"LESLEE", "KIMBERELY", "ILIANA", "GLORY", "FELICA", "EMOGENE", "ELFRIEDE", "EDEN", "EARTHA", "CARMA",
-	"BEA", "OCIE", "MARRY", "LENNIE", "KIARA", "JACALYN", "CARLOTA", "ARIELLE", "YU", "STAR",
-	"OTILIA", "KIRSTIN", "KACEY", "JOHNETTA", "JOEY", "JOETTA", "JERALDINE", "JAUNITA", "ELANA", "DORTHEA",
-	"CAMI", "AMADA", "ADELIA", "VERNITA", "TAMAR", "SIOBHAN", "RENEA", "RASHIDA", "OUIDA", "ODELL",
-	"NILSA", "MERYL", "KRISTYN", "JULIETA", "DANICA", "BREANNE", "AUREA", "ANGLEA", "SHERRON", "ODETTE",
-	"MALIA", "LORELEI", "LIN", "LEESA", "KENNA", "KATHLYN", "FIONA", "CHARLETTE", "SUZIE", "SHANTELL",
-	"SABRA", "RACQUEL", "MYONG", "MIRA", "MARTINE", "LUCIENNE", "LAVADA", "JULIANN", "JOHNIE", "ELVERA",
-	"DELPHIA", "CLAIR", "CHRISTIANE", "CHAROLETTE", "CARRI", "AUGUSTINE", "ASHA", "ANGELLA", "PAOLA", "NINFA",
-	"LEDA", "LAI", "EDA", "SUNSHINE", "STEFANI", "SHANELL", "PALMA", "MACHELLE", "LISSA", "KECIA",
-	"KATHRYNE", "KARLENE", "JULISSA", "JETTIE", "JENNIFFER", "HUI", "CORRINA", "CHRISTOPHER", "CAROLANN", "ALENA",
-	"TESS", "ROSARIA", "MYRTICE", "MARYLEE", "LIANE", "KENYATTA", "JUDIE", "JANEY", "IN", "ELMIRA",
-	"ELDORA", "DENNA", "CRISTI", "CATHI", "ZAIDA", "VONNIE", "VIVA", "VERNIE", "ROSALINE", "MARIELA",
-	"LUCIANA", "LESLI", "KARAN", "FELICE", "DENEEN", "ADINA", "WYNONA", "TARSHA", "SHERON", "SHASTA",
-	"SHANITA", "SHANI", "SHANDRA", "RANDA", "PINKIE", "PARIS", "NELIDA", "MARILOU", "LYLA", "LAURENE",
-	"LACI", "JOI", "JANENE", "DOROTHA", "DANIELE", "DANI", "CAROLYNN", "CARLYN", "BERENICE", "AYESHA",
-	"ANNELIESE", "ALETHEA", "THERSA", "TAMIKO", "RUFINA", "OLIVA", "MOZELL", "MARYLYN", "MADISON", "KRISTIAN",
-	"KATHYRN", "KASANDRA", "KANDACE", "JANAE", "GABRIEL", "DOMENICA", "DEBBRA", "DANNIELLE", "CHUN", "BUFFY",
-	"BARBIE", "ARCELIA", "AJA", "ZENOBIA", "SHAREN", "SHAREE", "PATRICK", "PAGE", "MY", "LAVINIA",
-	"KUM", "KACIE", "JACKELINE", "HUONG", "FELISA", "EMELIA", "ELEANORA", "CYTHIA", "CRISTIN", "CLYDE",
-	"CLARIBEL", "CARON", "ANASTACIA", "ZULMA", "ZANDRA", "YOKO", "TENISHA", "SUSANN", "SHERILYN", "SHAY",
-	"SHAWANDA", "SABINE", "ROMANA", "MATHILDA", "LINSEY", "KEIKO", "JOANA", "ISELA", "GRETTA", "GEORGETTA",
-	"EUGENIE", "DUSTY", "DESIRAE", "DELORA", "CORAZON", "ANTONINA", "ANIKA", "WILLENE", "TRACEE", "TAMATHA",
-	"REGAN", "NICHELLE", "MICKIE", "MAEGAN", "LUANA", "LANITA", "KELSIE", "EDELMIRA", "BREE", "AFTON",
-	"TEODORA", "TAMIE", "SHENA", "MEG", "LINH", "KELI", "KACI", "DANYELLE", "BRITT", "ARLETTE",
-	"ALBERTINE", "ADELLE", "TIFFINY", "STORMY", "SIMONA", "NUMBERS", "NICOLASA", "NICHOL", "NIA", "NAKISHA",
-	"MEE", "MAIRA", "LOREEN", "KIZZY", "JOHNNY", "JAY", "FALLON", "CHRISTENE", "BOBBYE", "ANTHONY",
-	"YING", "VINCENZA", "TANJA", "RUBIE", "RONI", "QUEENIE", "MARGARETT", "KIMBERLI", "IRMGARD", "IDELL",
-	"HILMA", "EVELINA", "ESTA", "EMILEE", "DENNISE", "DANIA", "CARL", "CARIE", "ANTONIO", "WAI",
-	"SANG", "RISA", "RIKKI", "PARTICIA", "MUI", "MASAKO", "MARIO", "LUVENIA", "LOREE", "LONI",
-	"LIEN", "KEVIN", "GIGI", "FLORENCIA", "DORIAN", "DENITA", "DALLAS", "CHI", "BILLYE", "ALEXANDER",
-	"TOMIKA", "SHARITA", "RANA", "NIKOLE", "NEOMA", "MARGARITE", "MADALYN", "LUCINA", "LAILA", "KALI",
-	"JENETTE", "GABRIELE", "EVELYNE", "ELENORA", "CLEMENTINA", "ALEJANDRINA", "ZULEMA", "VIOLETTE", "VANNESSA", "THRESA",
-	"RETTA", "PIA", "PATIENCE", "NOELLA", "NICKIE", "JONELL", "DELTA", "CHUNG", "CHAYA", "CAMELIA",
-	"BETHEL", "ANYA", "ANDREW", "THANH", "SUZANN", "SPRING", "SHU", "MILA", "LILLA", "LAVERNA",
-	"KEESHA", "KATTIE", "GIA", "GEORGENE", "EVELINE", "ESTELL", "ELIZBETH", "VIVIENNE", "VALLIE", "TRUDIE",
-	"STEPHANE", "MICHEL", "MAGALY", "MADIE", "KENYETTA", "KARREN", "JANETTA", "HERMINE", "HARMONY", "DRUCILLA",
-	"DEBBI", "CELESTINA", "CANDIE", "BRITNI", "BECKIE", "AMINA", "ZITA", "YUN", "YOLANDE", "VIVIEN",
-	"VERNETTA", "TRUDI", "SOMMER", "PEARLE", "PATRINA", "OSSIE", "NICOLLE", "LOYCE", "LETTY", "LARISA",
-	"KATHARINA", "JOSELYN", "JONELLE", "JENELL", "IESHA", "HEIDE", "FLORINDA", "FLORENTINA", "FLO", "ELODIA",
-	"DORINE", "BRUNILDA", "BRIGID", "ASHLI", "ARDELLA", "TWANA", "THU", "TARAH", "SUNG", "SHEA",
-	"SHAVON", "SHANE", "SERINA", "RAYNA", "RAMONITA", "NGA", "MARGURITE", "LUCRECIA", "KOURTNEY", "KATI",
-	"JESUS", "JESENIA", "DIAMOND", "CRISTA", "AYANA", "ALICA", "ALIA", "VINNIE", "SUELLEN", "ROMELIA",
-	"RACHELL", "PIPER", "OLYMPIA", "MICHIKO", "KATHALEEN", "JOLIE", "JESSI", "JANESSA", "HANA", "HA",
-	"ELEASE", "CARLETTA", "BRITANY", "SHONA", "SALOME", "ROSAMOND", "REGENA", "RAINA", "NGOC", "NELIA",
-	"LOUVENIA", "LESIA", "LATRINA", "LATICIA", "LARHONDA", "JINA", "JACKI", "HOLLIS", "HOLLEY", "EMMY",
-	"DEEANN", "CORETTA", "ARNETTA", "VELVET", "THALIA", "SHANICE", "NETA", "MIKKI", "MICKI", "LONNA",
-	"LEANA", "LASHUNDA", "KILEY", "JOYE", "JACQULYN", "IGNACIA", "HYUN", "HIROKO", "HENRY", "HENRIETTE",
-	"ELAYNE", "DELINDA", "DARNELL", "DAHLIA", "COREEN", "CONSUELA", "CONCHITA", "CELINE", "BABETTE", "AYANNA",
-	"ANETTE", "ALBERTINA", "SKYE", "SHAWNEE", "SHANEKA", "QUIANA", "PAMELIA", "MIN", "MERRI", "MERLENE",
-	"MARGIT", "KIESHA", "KIERA", "KAYLENE", "JODEE", "JENISE", "ERLENE", "EMMIE", "ELSE", "DARYL",
-	"DALILA", "DAISEY", "CODY", "CASIE", "BELIA", "BABARA", "VERSIE", "VANESA", "SHELBA", "SHAWNDA",
-	"SAM", "NORMAN", "NIKIA", "NAOMA", "MARNA", "MARGERET", "MADALINE", "LAWANA", "KINDRA", "JUTTA",
-	"JAZMINE", "JANETT", "HANNELORE", "GLENDORA", "GERTRUD", "GARNETT", "FREEDA", "FREDERICA", "FLORANCE", "FLAVIA",
-	"DENNIS", "CARLINE", "BEVERLEE", "ANJANETTE", "VALDA", "TRINITY", "TAMALA", "STEVIE", "SHONNA", "SHA",
-	"SARINA", "ONEIDA", "MICAH", "MERILYN", "MARLEEN", "LURLINE", "LENNA", "KATHERIN", "JIN", "JENI",
-	"HAE", "GRACIA", "GLADY", "FARAH", "ERIC", "ENOLA", "EMA", "DOMINQUE", "DEVONA", "DELANA",
-	"CECILA", "CAPRICE", "ALYSHA", "ALI", "ALETHIA", "VENA", "THERESIA", "TAWNY", "SONG", "SHAKIRA",
-	"SAMARA", "SACHIKO", "RACHELE", "PAMELLA", "NICKY", "MARNI", "MARIEL", "MAREN", "MALISA", "LIGIA",
-	"LERA", "LATORIA", "LARAE", "KIMBER", "KATHERN", "KAREY", "JENNEFER", "JANETH", "HALINA", "FREDIA",
-	"DELISA", "DEBROAH", "CIERA", "CHIN", "ANGELIKA", "ANDREE", "ALTHA", "YEN", "VIVAN", "TERRESA",
-	"TANNA", "SUK", "SUDIE", "SOO", "SIGNE", "SALENA", "RONNI", "REBBECCA", "MYRTIE", "MCKENZIE",
-	"MALIKA", "MAIDA", "LOAN", "LEONARDA", "KAYLEIGH", "FRANCE", "ETHYL", "ELLYN", "DAYLE", "CAMMIE",
-	"BRITTNI", "BIRGIT", "AVELINA", "ASUNCION", "ARIANNA", "AKIKO", "VENICE", "TYESHA", "TONIE", "TIESHA",
-	"TAKISHA", "STEFFANIE", "SINDY", "SANTANA", "MEGHANN", "MANDA", "MACIE", "LADY", "KELLYE", "KELLEE",
-	"JOSLYN", "JASON", "INGER", "INDIRA", "GLINDA", "GLENNIS", "FERNANDA", "FAUSTINA", "ENEIDA", "ELICIA",
-	"DOT", "DIGNA", "DELL", "ARLETTA", "ANDRE", "WILLIA", "TAMMARA", "TABETHA", "SHERRELL", "SARI",
-	"REFUGIO", "REBBECA", "PAULETTA", "NIEVES", "NATOSHA", "NAKITA", "MAMMIE", "KENISHA", "KAZUKO", "KASSIE",
-	"GARY", "EARLEAN", "DAPHINE", "CORLISS", "CLOTILDE", "CAROLYNE", "BERNETTA", "AUGUSTINA", "AUDREA", "ANNIS",
-	"ANNABELL", "YAN", "TENNILLE", "TAMICA", "SELENE", "SEAN", "ROSANA", "REGENIA", "QIANA", "MARKITA",
-	"MACY", "LEEANNE", "LAURINE", "KYM", "JESSENIA", "JANITA", "GEORGINE", "GENIE", "EMIKO", "ELVIE",
-	"DEANDRA", "DAGMAR", "CORIE", "COLLEN", "CHERISH", "ROMAINE", "PORSHA", "PEARLENE", "MICHELINE", "MERNA",
-	"MARGORIE", "MARGARETTA", "LORE", "KENNETH", "JENINE", "HERMINA", "FREDERICKA", "ELKE", "DRUSILLA", "DORATHY",
-	"DIONE", "DESIRE", "CELENA", "BRIGIDA", "ANGELES", "ALLEGRA", "THEO", "TAMEKIA", "SYNTHIA", "STEPHEN",
-	"SOOK", "SLYVIA", "ROSANN", "REATHA", "RAYE", "MARQUETTA", "MARGART", "LING", "LAYLA", "KYMBERLY",
-	"KIANA", "KAYLEEN", "KATLYN", "KARMEN", "JOELLA", "IRINA", "EMELDA", "ELENI", "DETRA", "CLEMMIE",
-	"CHERYLL", "CHANTELL", "CATHEY", "ARNITA", "ARLA", "ANGLE", "ANGELIC", "ALYSE", "ZOFIA", "THOMASINE",
-	"TENNIE", "SON", "SHERLY", "SHERLEY", "SHARYL", "REMEDIOS", "PETRINA", "NICKOLE", "MYUNG", "MYRLE",
-	"MOZELLA", "LOUANNE", "LISHA", "LATIA", "LANE", "KRYSTA", "JULIENNE", "JOEL", "JEANENE", "JACQUALINE",
-	"ISAURA", "GWENDA", "EARLEEN", "DONALD", "CLEOPATRA", "CARLIE", "AUDIE", "ANTONIETTA", "ALISE", "ALEX",
-	"VERDELL", "VAL", "TYLER", "TOMOKO", "THAO", "TALISHA", "STEVEN", "SO", "SHEMIKA", "SHAUN",
-	"SCARLET", "SAVANNA", "SANTINA", "ROSIA", "RAEANN", "ODILIA", "NANA", "MINNA", "MAGAN", "LYNELLE",
-	"LE", "KARMA", "JOEANN", "IVANA", "INELL", "ILANA", "HYE", "HONEY", "HEE", "GUDRUN",
-	"FRANK", "DREAMA", "CRISSY", "CHANTE", "CARMELINA", "ARVILLA", "ARTHUR", "ANNAMAE", "ALVERA", "ALEIDA",
-	"AARON", "YEE", "YANIRA", "VANDA", "TIANNA", "TAM", "STEFANIA", "SHIRA", "PERRY", "NICOL",
-	"NANCIE", "MONSERRATE", "MINH", "MELYNDA", "MELANY", "MATTHEW", "LOVELLA", "LAURE", "KIRBY", "KACY",
-	"JACQUELYNN", "HYON", "GERTHA", "FRANCISCO", "ELIANA", "CHRISTENA", "CHRISTEEN", "CHARISE", "CATERINA", "CARLEY",
-	"CANDYCE", "ARLENA", "AMMIE", "YANG", "WILLETTE", "VANITA", "TUYET", "TINY", "SYREETA", "SILVA",
-	"SCOTT", "RONALD", "PENNEY", "NYLA", "MICHAL", "MAURICE", "MARYAM", "MARYA", "MAGEN", "LUDIE",
-	"LOMA", "LIVIA", "LANELL", "KIMBERLIE", "JULEE", "DONETTA", "DIEDRA", "DENISHA", "DEANE", "DAWNE",
-	"CLARINE", "CHERRYL", "BRONWYN", "BRANDON", "ALLA", "VALERY", "TONDA", "SUEANN", "SORAYA", "SHOSHANA",
-	"SHELA", "SHARLEEN", "SHANELLE", "NERISSA", "MICHEAL", "MERIDITH", "MELLIE", "MAYE", "MAPLE", "MAGARET",
-	"LUIS", "LILI", "LEONILA", "LEONIE", "LEEANNA", "LAVONIA", "LAVERA", "KRISTEL", "KATHEY", "KATHE",
-	"JUSTIN", "JULIAN", "JIMMY", "JANN", "ILDA", "HILDRED", "HILDEGARDE", "GENIA", "FUMIKO", "EVELIN",
-	"ERMELINDA", "ELLY", "DUNG", "DOLORIS", "DIONNA", "DANAE", "BERNEICE", "ANNICE", "ALIX", "VERENA",
-	"VERDIE", "TRISTAN", "SHAWNNA", "SHAWANA", "SHAUNNA", "ROZELLA", "RANDEE", "RANAE", "MILAGRO", "LYNELL",
-	"LUISE", "LOUIE", "LOIDA", "LISBETH", "KARLEEN", "JUNITA", "JONA", "ISIS", "HYACINTH", "HEDY",
-	"GWENN", "ETHELENE", "ERLINE", "EDWARD", "DONYA", "DOMONIQUE", "DELICIA", "DANNETTE", "CICELY", "BRANDA",
-	"BLYTHE", "BETHANN", "ASHLYN", "ANNALEE", "ALLINE", "YUKO", "VELLA", "TRANG", "TOWANDA", "TESHA",
-	"SHERLYN", "NARCISA", "MIGUELINA", "MERI", "MAYBELL", "MARLANA", "MARGUERITA", "MADLYN", "LUNA", "LORY",
-	"LORIANN", "LIBERTY", "LEONORE", "LEIGHANN", "LAURICE", "LATESHA", "LARONDA", "KATRICE", "KASIE", "KARL",
-	"KALEY", "JADWIGA", "GLENNIE", "GEARLDINE", "FRANCINA", "EPIFANIA", "DYAN", "DORIE", "DIEDRE", "DENESE",
-	"DEMETRICE", "DELENA", "DARBY", "CRISTIE", "CLEORA", "CATARINA", "CARISA", "BERNIE", "BARBERA", "ALMETA",
-	"TRULA", "TEREASA", "SOLANGE", "SHEILAH", "SHAVONNE", "SANORA", "ROCHELL", "MATHILDE", "MARGARETA", "MAIA",
-	"LYNSEY", "LAWANNA", "LAUNA", "KENA", "KEENA", "KATIA", "JAMEY", "GLYNDA", "GAYLENE", "ELVINA",
-	"ELANOR", "DANUTA", "DANIKA", "CRISTEN", "CORDIE", "COLETTA", "CLARITA", "CARMON", "BRYNN", "AZUCENA",
-	"AUNDREA", "ANGELE", "YI", "WALTER", "VERLIE", "VERLENE", "TAMESHA", "SILVANA", "SEBRINA", "SAMIRA",
-	"REDA", "RAYLENE", "PENNI", "PANDORA", "NORAH", "NOMA", "MIREILLE", "MELISSIA", "MARYALICE", "LARAINE",
-	"KIMBERY", "KARYL", "KARINE", "KAM", "JOLANDA", "JOHANA", "JESUSA", "JALEESA", "JAE", "JACQUELYNE",
-	"IRISH", "ILUMINADA", "HILARIA", "HANH", "GENNIE", "FRANCIE", "FLORETTA", "EXIE", "EDDA", "DREMA",
-	"DELPHA", "BEV", "BARBAR", "ASSUNTA", "ARDELL", "ANNALISA", "ALISIA", "YUKIKO", "YOLANDO", "WONDA",
-	"WEI", "WALTRAUD", "VETA", "TEQUILA", "TEMEKA", "TAMEIKA", "SHIRLEEN", "SHENITA", "PIEDAD", "OZELLA",
-	"MIRTHA", "MARILU", "KIMIKO", "JULIANE", "JENICE", "JEN", "JANAY", "JACQUILINE", "HILDE", "FE",
-	"FAE", "EVAN", "EUGENE", "ELOIS", "ECHO", "DEVORAH", "CHAU", "BRINDA", "BETSEY", "ARMINDA",
-	"ARACELIS", "APRYL", "ANNETT", "ALISHIA", "VEOLA", "USHA", "TOSHIKO", "THEOLA", "TASHIA", "TALITHA",
-	"SHERY", "RUDY", "RENETTA", "REIKO", "RASHEEDA", "OMEGA", "OBDULIA", "MIKA", "MELAINE", "MEGGAN",
-	"MARTIN", "MARLEN", "MARGET", "MARCELINE", "MANA", "MAGDALEN", "LIBRADA", "LEZLIE", "LEXIE", "LATASHIA",
-	"LASANDRA", "KELLE", "ISIDRA", "ISA", "INOCENCIA", "GWYN", "FRANCOISE", "ERMINIA", "ERINN", "DIMPLE",
-	"DEVORA", "CRISELDA", "ARMANDA", "ARIE", "ARIANE", "ANGELO", "ANGELENA", "ALLEN", "ALIZA", "ADRIENE",
-	"ADALINE", "XOCHITL", "TWANNA", "TRAN", "TOMIKO", "TAMISHA", "TAISHA", "SUSY", "SIU", "RUTHA",
-	"ROXY", "RHONA", "RAYMOND", "OTHA", "NORIKO", "NATASHIA", "MERRIE", "MELVIN", "MARINDA", "MARIKO",
-	"MARGERT", "LORIS", "LIZZETTE", "LEISHA", "KAILA", "KA", "JOANNIE", "JERRICA", "JENE", "JANNET",
-	"JANEE", "JACINDA", "HERTA", "ELENORE", "DORETTA", "DELAINE", "DANIELL", "CLAUDIE", "CHINA", "BRITTA",
-	"APOLONIA", "AMBERLY", "ALEASE", "YURI", "YUK", "WEN", "WANETA", "UTE", "TOMI", "SHARRI",
-	"SANDIE", "ROSELLE", "REYNALDA", "RAGUEL", "PHYLICIA", "PATRIA", "OLIMPIA", "ODELIA", "MITZIE", "MITCHELL",
-	"MISS", "MINDA", "MIGNON", "MICA", "MENDY", "MARIVEL", "MAILE", "LYNETTA", "LAVETTE", "LAURYN",
-	"LATRISHA", "LAKIESHA", "KIERSTEN", "KARY", "JOSPHINE", "JOLYN", "JETTA", "JANISE", "JACQUIE", "IVELISSE",
-	"GLYNIS", "GIANNA", "GAYNELLE", "EMERALD", "DEMETRIUS", "DANYELL", "DANILLE", "DACIA", "CORALEE", "CHER",
-	"CEOLA", "BRETT", "BELL", "ARIANNE", "ALESHIA", "YUNG", "WILLIEMAE", "TROY", "TRINH", "THORA",
-	"TAI", "SVETLANA", "SHERIKA", "SHEMEKA", "SHAUNDA", "ROSELINE", "RICKI", "MELDA", "MALLIE", "LAVONNA",
-	"LATINA", "LARRY", "LAQUANDA", "LALA", "LACHELLE", "KLARA", "KANDIS", "JOHNA", "JEANMARIE", "JAYE",
-	"HANG", "GRAYCE", "GERTUDE", "EMERITA", "EBONIE", "CLORINDA", "CHING", "CHERY", "CAROLA", "BREANN",
-	"BLOSSOM", "BERNARDINE", "BECKI", "ARLETHA", "ARGELIA", "ARA", "ALITA", "YULANDA", "YON", "YESSENIA",
-	"TOBI", "TASIA", "SYLVIE", "SHIRL", "SHIRELY", "SHERIDAN", "SHELLA", "SHANTELLE", "SACHA", "ROYCE",
-	"REBECKA", "REAGAN", "PROVIDENCIA", "PAULENE", "MISHA", "MIKI", "MARLINE", "MARICA", "LORITA", "LATOYIA",
-	"LASONYA", "KERSTIN", "KENDA", "KEITHA", "KATHRIN", "JAYMIE", "JACK", "GRICELDA", "GINETTE", "ERYN",
-	"ELINA", "ELFRIEDA", "DANYEL", "CHEREE", "CHANELLE", "BARRIE", "AVERY", "AURORE", "ANNAMARIA", "ALLEEN",
-	"AILENE", "AIDE", "YASMINE", "VASHTI", "VALENTINE", "TREASA", "TORY", "TIFFANEY", "SHERYLL", "SHARIE",
-	"SHANAE", "SAU", "RAISA", "PA", "NEDA", "MITSUKO", "MIRELLA", "MILDA", "MARYANNA", "MARAGRET",
-	"MABELLE", "LUETTA", "LORINA", "LETISHA", "LATARSHA", "LANELLE", "LAJUANA", "KRISSY", "KARLY", "KARENA",
-	"JON", "JESSIKA", "JERICA", "JEANELLE", "JANUARY", "JALISA", "JACELYN", "IZOLA", "IVEY", "GREGORY",
-	"EUNA", "ETHA", "DREW", "DOMITILA", "DOMINICA", "DAINA", "CREOLA", "CARLI", "CAMIE", "BUNNY",
-	"BRITTNY", "ASHANTI", "ANISHA", "ALEEN", "ADAH", "YASUKO", "WINTER", "VIKI", "VALRIE", "TONA",
-	"TINISHA", "THI", "TERISA", "TATUM", "TANEKA", "SIMONNE", "SHALANDA", "SERITA", "RESSIE", "REFUGIA",
-	"PAZ", "OLENE", "NA", "MERRILL", "MARGHERITA", "MANDIE", "MAN", "MAIRE", "LYNDIA", "LUCI",
-	"LORRIANE", "LORETA", "LEONIA", "LAVONA", "LASHAWNDA", "LAKIA", "KYOKO", "KRYSTINA", "KRYSTEN", "KENIA",
-	"KELSI", "JUDE", "JEANICE", "ISOBEL", "GEORGIANN", "GENNY", "FELICIDAD", "EILENE", "DEON", "DELOISE",
-	"DEEDEE", "DANNIE", "CONCEPTION", "CLORA", "CHERILYN", "CHANG", "CALANDRA", "BERRY", "ARMANDINA", "ANISA",
-	"ULA", "TIMOTHY", "TIERA", "THERESSA", "STEPHANIA", "SIMA", "SHYLA", "SHONTA", "SHERA", "SHAQUITA",
-	"SHALA", "SAMMY", "ROSSANA", "NOHEMI", "NERY", "MORIAH", "MELITA", "MELIDA", "MELANI", "MARYLYNN",
-	"MARISHA", "MARIETTE", "MALORIE", "MADELENE", "LUDIVINA", "LORIA", "LORETTE", "LORALEE", "LIANNE", "LEON",
-	"LAVENIA", "LAURINDA", "LASHON", "KIT", "KIMI", "KEILA", "KATELYNN", "KAI", "JONE", "JOANE",
-	"JI", "JAYNA", "JANELLA", "JA", "HUE", "HERTHA", "FRANCENE", "ELINORE", "DESPINA", "DELSIE",
-	"DEEDRA", "CLEMENCIA", "CARRY", "CAROLIN", "CARLOS", "BULAH", "BRITTANIE", "BOK", "BLONDELL", "BIBI",
-	"BEAULAH", "BEATA", "ANNITA", "AGRIPINA", "VIRGEN", "VALENE", "UN", "TWANDA", "TOMMYE", "TOI",
-	"TARRA", "TARI", "TAMMERA", "SHAKIA", "SADYE", "RUTHANNE", "ROCHEL", "RIVKA", "PURA", "NENITA",
-	"NATISHA", "MING", "MERRILEE", "MELODEE", "MARVIS", "LUCILLA", "LEENA", "LAVETA", "LARITA", "LANIE",
-	"KEREN", "ILEEN", "GEORGEANN", "GENNA", "GENESIS", "FRIDA", "EWA", "EUFEMIA", "EMELY", "ELA",
-	"EDYTH", "DEONNA", "DEADRA", "DARLENA", "CHANELL", "CHAN", "CATHERN", "CASSONDRA", "CASSAUNDRA", "BERNARDA",
-	"BERNA", "ARLINDA", "ANAMARIA", "ALBERT", "WESLEY", "VERTIE", "VALERI", "TORRI", "TATYANA", "STASIA",
-	"SHERISE", "SHERILL", "SEASON", "SCOTTIE", "SANDA", "RUTHE", "ROSY", "ROBERTO", "ROBBI", "RANEE",
-	"QUYEN", "PEARLY", "PALMIRA", "ONITA", "NISHA", "NIESHA", "NIDA", "NEVADA", "NAM", "MERLYN",
-	"MAYOLA", "MARYLOUISE", "MARYLAND", "MARX", "MARTH", "MARGENE", "MADELAINE", "LONDA", "LEONTINE", "LEOMA",
-	"LEIA", "LAWRENCE", "LAURALEE", "LANORA", "LAKITA", "KIYOKO", "KETURAH", "KATELIN", "KAREEN", "JONIE",
-	"JOHNETTE", "JENEE", "JEANETT", "IZETTA", "HIEDI", "HEIKE", "HASSIE", "HAROLD", "GIUSEPPINA", "GEORGANN",
-	"FIDELA", "FERNANDE", "ELWANDA", "ELLAMAE", "ELIZ", "DUSTI", "DOTTY", "CYNDY", "CORALIE", "CELESTA",
-	"ARGENTINA", "ALVERTA", "XENIA", "WAVA", "VANETTA", "TORRIE", "TASHINA", "TANDY", "TAMBRA", "TAMA",
-	"STEPANIE", "SHILA", "SHAUNTA", "SHARAN", "SHANIQUA", "SHAE", "SETSUKO", "SERAFINA", "SANDEE", "ROSAMARIA",
-	"PRISCILA", "OLINDA", "NADENE", "MUOI", "MICHELINA", "MERCEDEZ", "MARYROSE", "MARIN", "MARCENE", "MAO",
-	"MAGALI", "MAFALDA", "LOGAN", "LINN", "LANNIE", "KAYCE", "KAROLINE", "KAMILAH", "KAMALA", "JUSTA",
-	"JOLINE", "JENNINE", "JACQUETTA", "IRAIDA", "GERALD", "GEORGEANNA", "FRANCHESCA", "FAIRY", "EMELINE", "ELANE",
-	"EHTEL", "EARLIE", "DULCIE", "DALENE", "CRIS", "CLASSIE", "CHERE", "CHARIS", "CAROYLN", "CARMINA",
-	"CARITA", "BRIAN", "BETHANIE", "AYAKO", "ARICA", "AN", "ALYSA", "ALESSANDRA", "AKILAH", "ADRIEN",
-	"ZETTA", "YOULANDA", "YELENA", "YAHAIRA", "XUAN", "WENDOLYN", "VICTOR", "TIJUANA", "TERRELL", "TERINA",
-	"TERESIA", "SUZI", "SUNDAY", "SHERELL", "SHAVONDA", "SHAUNTE", "SHARDA", "SHAKITA", "SENA", "RYANN",
-	"RUBI", "RIVA", "REGINIA", "REA", "RACHAL", "PARTHENIA", "PAMULA", "MONNIE", "MONET", "MICHAELE",
-	"MELIA", "MARINE", "MALKA", "MAISHA", "LISANDRA", "LEO", "LEKISHA", "LEAN", "LAURENCE", "LAKENDRA",
-	"KRYSTIN", "KORTNEY", "KIZZIE", "KITTIE", "KERA", "KENDAL", "KEMBERLY", "KANISHA", "JULENE", "JULE",
-	"JOSHUA", "JOHANNE", "JEFFREY", "JAMEE", "HAN", "HALLEY", "GIDGET", "GALINA", "FREDRICKA", "FLETA",
-	"FATIMAH", "EUSEBIA", "ELZA", "ELEONORE", "DORTHEY", "DORIA", "DONELLA", "DINORAH", "DELORSE", "CLARETHA",
-	"CHRISTINIA", "CHARLYN", "BONG", "BELKIS", "AZZIE", "ANDERA", "AIKO", "ADENA", "YER", "YAJAIRA",
-	"WAN", "VANIA", "ULRIKE", "TOSHIA", "TIFANY", "STEFANY", "SHIZUE", "SHENIKA", "SHAWANNA", "SHAROLYN",
-	"SHARILYN", "SHAQUANA", "SHANTAY", "SEE", "ROZANNE", "ROSELEE", "RICKIE", "REMONA", "REANNA", "RAELENE",
-	"QUINN", "PHUNG", "PETRONILA", "NATACHA", "NANCEY", "MYRL", "MIYOKO", "MIESHA", "MERIDETH", "MARVELLA",
-	"MARQUITTA", "MARHTA", "MARCHELLE", "LIZETH", "LIBBIE", "LAHOMA", "LADAWN", "KINA", "KATHELEEN", "KATHARYN",
-	"KARISA", "KALEIGH", "JUNIE", "JULIEANN", "JOHNSIE", "JANEAN", "JAIMEE", "JACKQUELINE", "HISAKO", "HERMA",
-	"HELAINE", "GWYNETH", "GLENN", "GITA", "EUSTOLIA", "EMELINA", "ELIN", "EDRIS", "DONNETTE", "DONNETTA",
-	"DIERDRE", "DENAE", "DARCEL", "CLAUDE", "CLARISA", "CINDERELLA", "CHIA", "CHARLESETTA", "CHARITA", "CELSA",
-	"CASSY", "CASSI", "CARLEE", "BRUNA", "BRITTANEY", "BRANDE", "BILLI", "BAO", "ANTONETTA", "ANGLA",
-	"ANGELYN", "ANALISA", "ALANE", "WENONA", "WENDIE", "VERONIQUE", "VANNESA", "TOBIE", "TEMPIE", "SUMIKO",
-	"SULEMA", "SPARKLE", "SOMER", "SHEBA", "SHAYNE", "SHARICE", "SHANEL", "SHALON", "SAGE", "ROY",
-	"ROSIO", "ROSELIA", "RENAY", "REMA", "REENA", "PORSCHE", "PING", "PEG", "OZIE", "ORETHA",
-	"ORALEE", "ODA", "NU", "NGAN", "NAKESHA", "MILLY", "MARYBELLE", "MARLIN", "MARIS", "MARGRETT",
-	"MARAGARET", "MANIE", "LURLENE", "LILLIA", "LIESELOTTE", "LAVELLE", "LASHAUNDA", "LAKEESHA", "KEITH", "KAYCEE",
-	"KALYN", "JOYA", "JOETTE", "JENAE", "JANIECE", "ILLA", "GRISEL", "GLAYDS", "GENEVIE", "GALA",
-	"FREDDA", "FRED", "ELMER", "ELEONOR", "DEBERA", "DEANDREA", "DAN", "CORRINNE", "CORDIA", "CONTESSA",
-	"COLENE", "CLEOTILDE", "CHARLOTT", "CHANTAY", "CECILLE", "BEATRIS", "AZALEE", "ARLEAN", "ARDATH", "ANJELICA",
-	"ANJA", "ALFREDIA", "ALEISHA", "ADAM", "ZADA", "YUONNE", "XIAO", "WILLODEAN", "WHITLEY", "VENNIE",
-	"VANNA", "TYISHA", "TOVA", "TORIE", "TONISHA", "TILDA", "TIEN", "TEMPLE", "SIRENA", "SHERRIL",
-	"SHANTI", "SHAN", "SENAIDA", "SAMELLA", "ROBBYN", "RENDA", "REITA", "PHEBE", "PAULITA", "NOBUKO",
-	"NGUYET", "NEOMI", "MOON", "MIKAELA", "MELANIA", "MAXIMINA", "MARG", "MAISIE", "LYNNA", "LILLI",
-	"LAYNE", "LASHAUN", "LAKENYA", "LAEL", "KIRSTIE", "KATHLINE", "KASHA", "KARLYN", "KARIMA", "JOVAN",
-	"JOSEFINE", "JENNELL", "JACQUI", "JACKELYN", "HYO", "HIEN", "GRAZYNA", "FLORRIE", "FLORIA", "ELEONORA",
-	"DWANA", "DORLA", "DONG", "DELMY", "DEJA", "DEDE", "DANN", "CRYSTA", "CLELIA", "CLARIS",
-	"CLARENCE", "CHIEKO", "CHERLYN", "CHERELLE", "CHARMAIN", "CHARA", "CAMMY", "BEE", "ARNETTE", "ARDELLE",
-	"ANNIKA", "AMIEE", "AMEE", "ALLENA", "YVONE", "YUKI", "YOSHIE", "YEVETTE", "YAEL", "WILLETTA",
-	"VONCILE", "VENETTA", "TULA", "TONETTE", "TIMIKA", "TEMIKA", "TELMA", "TEISHA", "TAREN", "TA",
-	"STACEE", "SHIN", "SHAWNTA", "SATURNINA", "RICARDA", "POK", "PASTY", "ONIE", "NUBIA", "MORA",
-	"MIKE", "MARIELLE", "MARIELLA", "MARIANELA", "MARDELL", "MANY", "LUANNA", "LOISE", "LISABETH", "LINDSY",
-	"LILLIANA", "LILLIAM", "LELAH", "LEIGHA", "LEANORA", "LANG", "KRISTEEN", "KHALILAH", "KEELEY", "KANDRA",
-	"JUNKO", "JOAQUINA", "JERLENE", "JANI", "JAMIKA", "JAME", "HSIU", "HERMILA", "GOLDEN", "GENEVIVE",
-	"EVIA", "EUGENA", "EMMALINE", "ELFREDA", "ELENE", "DONETTE", "DELCIE", "DEEANNA", "DARCEY", "CUC",
-	"CLARINDA", "CIRA", "CHAE", "CELINDA", "CATHERYN", "CATHERIN", "CASIMIRA", "CARMELIA", "CAMELLIA", "BREANA",
-	"BOBETTE", "BERNARDINA", "BEBE", "BASILIA", "ARLYNE", "AMAL", "ALAYNA", "ZONIA", "ZENIA", "YURIKO",
-	"YAEKO", "WYNELL", "WILLOW", "WILLENA", "VERNIA", "TU", "TRAVIS", "TORA", "TERRILYN", "TERICA",
-	"TENESHA", "TAWNA", "TAJUANA", "TAINA", "STEPHNIE", "SONA", "SOL", "SINA", "SHONDRA", "SHIZUKO",
-	"SHERLENE", "SHERICE", "SHARIKA", "ROSSIE", "ROSENA", "RORY", "RIMA", "RIA", "RHEBA", "RENNA",
-	"PETER", "NATALYA", "NANCEE", "MELODI", "MEDA", "MAXIMA", "MATHA", "MARKETTA", "MARICRUZ", "MARCELENE",
-	"MALVINA", "LUBA", "LOUETTA", "LEIDA", "LECIA", "LAURAN", "LASHAWNA", "LAINE", "KHADIJAH", "KATERINE",
-	"KASI", "KALLIE", "JULIETTA", "JESUSITA", "JESTINE", "JESSIA", "JEREMY", "JEFFIE", "JANYCE", "ISADORA",
-	"GEORGIANNE", "FIDELIA", "EVITA", "EURA", "EULAH", "ESTEFANA", "ELSY", "ELIZABET", "ELADIA", "DODIE",
-	"DION", "DIA", "DENISSE", "DELORAS", "DELILA", "DAYSI", "DAKOTA", "CURTIS", "CRYSTLE", "CONCHA",
-	"COLBY", "CLARETTA", "CHU", "CHRISTIA", "CHARLSIE", "CHARLENA", "CARYLON", "BETTYANN", "ASLEY", "ASHLEA",
-	"AMIRA", "AI", "AGUEDA", "AGNUS", "YUETTE", "VINITA", "VICTORINA", "TYNISHA", "TREENA", "TOCCARA",
-	"TISH", "THOMASENA", "TEGAN", "SOILA", "SHILOH", "SHENNA", "SHARMAINE", "SHANTAE", "SHANDI", "SEPTEMBER",
-	"SARAN", "SARAI", "SANA", "SAMUEL", "SALLEY", "ROSETTE", "ROLANDE", "REGINE", "OTELIA", "OSCAR",
-	"OLEVIA", "NICHOLLE", "NECOLE", "NAIDA", "MYRTA", "MYESHA", "MITSUE", "MINTA", "MERTIE", "MARGY",
-	"MAHALIA", "MADALENE", "LOVE", "LOURA", "LOREAN", "LEWIS", "LESHA", "LEONIDA", "LENITA", "LAVONE",
-	"LASHELL", "LASHANDRA", "LAMONICA", "KIMBRA", "KATHERINA", "KARRY", "KANESHA", "JULIO", "JONG", "JENEVA",
-	"JAQUELYN", "HWA", "GILMA", "GHISLAINE", "GERTRUDIS", "FRANSISCA", "FERMINA", "ETTIE", "ETSUKO", "ELLIS",
-	"ELLAN", "ELIDIA", "EDRA", "DORETHEA", "DOREATHA", "DENYSE", "DENNY", "DEETTA", "DAINE", "CYRSTAL",
-	"CORRIN", "CAYLA", "CARLITA", "CAMILA", "BURMA", "BULA", "BUENA", "BLAKE", "BARABARA", "AVRIL",
-	"AUSTIN", "ALAINE", "ZANA", "WILHEMINA", "WANETTA", "VIRGIL", "VI", "VERONIKA", "VERNON", "VERLINE",
-	"VASILIKI", "TONITA", "TISA", "TEOFILA", "TAYNA", "TAUNYA", "TANDRA", "TAKAKO", "SUNNI", "SUANNE",
-	"SIXTA", "SHARELL", "SEEMA", "RUSSELL", "ROSENDA", "ROBENA", "RAYMONDE", "PEI", "PAMILA", "OZELL",
-	"NEIDA", "NEELY", "MISTIE", "MICHA", "MERISSA", "MAURITA", "MARYLN", "MARYETTA", "MARSHALL", "MARCELL",
-	"MALENA", "MAKEDA", "MADDIE", "LOVETTA", "LOURIE", "LORRINE", "LORILEE", "LESTER", "LAURENA", "LASHAY",
-	"LARRAINE", "LAREE", "LACRESHA", "KRISTLE", "KRISHNA", "KEVA", "KEIRA", "KAROLE", "JOIE", "JINNY",
-	"JEANNETTA", "JAMA", "HEIDY", "GILBERTE", "GEMA", "FAVIOLA", "EVELYNN", "ENDA", "ELLI", "ELLENA",
-	"DIVINA", "DAGNY", "COLLENE", "CODI", "CINDIE", "CHASSIDY", "CHASIDY", "CATRICE", "CATHERINA", "CASSEY",
-	"CAROLL", "CARLENA", "CANDRA", "CALISTA", "BRYANNA", "BRITTENY", "BEULA", "BARI", "AUDRIE", "AUDRIA",
-	"ARDELIA", "ANNELLE", "ANGILA", "ALONA", "ALLYN", "DOUGLAS", "ROGER", "JONATHAN", "RALPH", "NICHOLAS",
-	"BENJAMIN", "BRUCE", "HARRY", "WAYNE", "STEVE", "HOWARD", "ERNEST", "PHILLIP", "TODD", "CRAIG",
-	"ALAN", "PHILIP", "EARL", "DANNY", "BRYAN", "STANLEY", "LEONARD", "NATHAN", "MANUEL", "RODNEY",
-	"MARVIN", "VINCENT", "JEFFERY", "JEFF", "CHAD", "JACOB", "ALFRED", "BRADLEY", "HERBERT", "FREDERICK",
-	"EDWIN", "DON", "RICKY", "RANDALL", "BARRY", "BERNARD", "LEROY", "MARCUS", "THEODORE", "CLIFFORD",
-	"MIGUEL", "JIM", "TOM", "CALVIN", "BILL", "LLOYD", "DEREK", "WARREN", "DARRELL", "JEROME",
-	"FLOYD", "ALVIN", "TIM", "GORDON", "GREG", "JORGE", "DUSTIN", "PEDRO", "DERRICK", "ZACHARY",
-	"HERMAN", "GLEN", "HECTOR", "RICARDO", "RICK", "BRENT", "RAMON", "GILBERT", "MARC", "REGINALD",
-	"RUBEN", "NATHANIEL", "RAFAEL", "EDGAR", "MILTON", "RAUL", "BEN", "CHESTER", "DUANE", "FRANKLIN",
-	"BRAD", "RON", "ROLAND", "ARNOLD", "HARVEY", "JARED", "ERIK", "DARRYL", "NEIL", "JAVIER",
-	"FERNANDO", "CLINTON", "TED", "MATHEW", "TYRONE", "DARREN", "LANCE", "KURT", "ALLAN", "NELSON",
-	"GUY", "CLAYTON", "HUGH", "MAX", "DWAYNE", "DWIGHT", "ARMANDO", "FELIX", "EVERETT", "IAN",
-	"WALLACE", "KEN", "BOB", "ALFREDO", "ALBERTO", "DAVE", "IVAN", "BYRON", "ISAAC", "MORRIS",
-	"CLIFTON", "WILLARD", "ROSS", "ANDY", "SALVADOR", "KIRK", "SERGIO", "SETH", "KENT", "TERRANCE",
-	"EDUARDO", "TERRENCE", "ENRIQUE", "WADE", "STUART", "FREDRICK", "ARTURO", "ALEJANDRO", "NICK", "LUTHER",
-	"WENDELL", "JEREMIAH", "JULIUS", "OTIS", "TREVOR", "OLIVER", "LUKE", "HOMER", "GERARD", "DOUG",
-	"KENNY", "HUBERT", "LYLE", "MATT", "ALFONSO", "ORLANDO", "REX", "CARLTON", "ERNESTO", "NEAL",
-	"PABLO", "LORENZO", "OMAR", "WILBUR", "GRANT", "HORACE", "RODERICK", "ABRAHAM", "WILLIS", "RICKEY",
-	"ANDRES", "CESAR", "JOHNATHAN", "MALCOLM", "RUDOLPH", "DAMON", "KELVIN", "PRESTON", "ALTON", "ARCHIE",
-	"MARCO", "WM", "PETE", "RANDOLPH", "GARRY", "GEOFFREY", "JONATHON", "FELIPE", "GERARDO", "ED",
-	"DOMINIC", "DELBERT", "COLIN", "GUILLERMO", "EARNEST", "LUCAS", "BENNY", "SPENCER", "RODOLFO", "MYRON",
-	"EDMUND", "GARRETT", "SALVATORE", "CEDRIC", "LOWELL", "GREGG", "SHERMAN", "WILSON", "SYLVESTER", "ROOSEVELT",
-	"ISRAEL", "JERMAINE", "FORREST", "WILBERT", "LELAND", "SIMON", "CLARK", "IRVING", "BRYANT", "OWEN",
-	"RUFUS", "WOODROW", "KRISTOPHER", "MACK", "LEVI", "MARCOS", "GUSTAVO", "JAKE", "LIONEL", "GILBERTO",
-	"CLINT", "NICOLAS", "ISMAEL", "ORVILLE", "ERVIN", "DEWEY", "AL", "WILFRED", "JOSH", "HUGO",
-	"IGNACIO", "CALEB", "TOMAS", "SHELDON", "ERICK", "STEWART", "DOYLE", "DARREL", "ROGELIO", "TERENCE",
-	"SANTIAGO", "ALONZO", "ELIAS", "BERT", "ELBERT", "RAMIRO", "CONRAD", "NOAH", "GRADY", "PHIL",
-	"CORNELIUS", "LAMAR", "ROLANDO", "CLAY", "PERCY", "DEXTER", "BRADFORD", "DARIN", "AMOS", "MOSES",
-	"IRVIN", "SAUL", "ROMAN", "RANDAL", "TIMMY", "DARRIN", "WINSTON", "BRENDAN", "ABEL", "DOMINICK",
-	"BOYD", "EMILIO", "ELIJAH", "DOMINGO", "EMMETT", "MARLON", "EMANUEL", "JERALD", "EDMOND", "EMIL",
-	"DEWAYNE", "WILL", "OTTO", "TEDDY", "REYNALDO", "BRET", "JESS", "TRENT", "HUMBERTO", "EMMANUEL",
-	"STEPHAN", "VICENTE", "LAMONT", "GARLAND", "MILES", "EFRAIN", "HEATH", "RODGER", "HARLEY", "ETHAN",
-	"ELDON", "ROCKY", "PIERRE", "JUNIOR", "FREDDY", "ELI", "BRYCE", "ANTOINE", "STERLING", "CHASE",
-	"GROVER", "ELTON", "CLEVELAND", "DYLAN", "CHUCK", "DAMIAN", "REUBEN", "STAN", "AUGUST", "LEONARDO",
-	"JASPER", "RUSSEL", "ERWIN", "BENITO", "HANS", "MONTE", "BLAINE", "ERNIE", "CURT", "QUENTIN",
-	"AGUSTIN", "MURRAY", "JAMAL", "ADOLFO", "HARRISON", "TYSON", "BURTON", "BRADY", "ELLIOTT", "WILFREDO",
-	"BART", "JARROD", "VANCE", "DENIS", "DAMIEN", "JOAQUIN", "HARLAN", "DESMOND", "ELLIOT", "DARWIN",
-	"GREGORIO", "BUDDY", "XAVIER", "KERMIT", "ROSCOE", "ESTEBAN", "ANTON", "SOLOMON", "SCOTTY", "NORBERT",
-	"ELVIN", "WILLIAMS", "NOLAN", "ROD", "QUINTON", "HAL", "BRAIN", "ROB", "ELWOOD", "KENDRICK",
-	"DARIUS", "MOISES", "FIDEL", "THADDEUS", "CLIFF", "MARCEL", "JACKSON", "RAPHAEL", "BRYON", "ARMAND",
-	"ALVARO", "JEFFRY", "DANE", "JOESPH", "THURMAN", "NED", "RUSTY", "MONTY", "FABIAN", "REGGIE",
-	"MASON", "GRAHAM", "ISAIAH", "VAUGHN", "GUS", "LOYD", "DIEGO", "ADOLPH", "NORRIS", "MILLARD",
-	"ROCCO", "GONZALO", "DERICK", "RODRIGO", "WILEY", "RIGOBERTO", "ALPHONSO", "TY", "NOE", "VERN",
-	"REED", "JEFFERSON", "ELVIS", "BERNARDO", "MAURICIO", "HIRAM", "DONOVAN", "BASIL", "RILEY", "NICKOLAS",
-	"MAYNARD", "SCOT", "VINCE", "QUINCY", "EDDY", "SEBASTIAN", "FEDERICO", "ULYSSES", "HERIBERTO", "DONNELL",
-	"COLE", "DAVIS", "GAVIN", "EMERY", "WARD", "ROMEO", "JAYSON", "DANTE", "CLEMENT", "COY",
-	"MAXWELL", "JARVIS", "BRUNO", "ISSAC", "DUDLEY", "BROCK", "SANFORD", "CARMELO", "BARNEY", "NESTOR",
-	"STEFAN", "DONNY", "ART", "LINWOOD", "BEAU", "WELDON", "GALEN", "ISIDRO", "TRUMAN", "DELMAR",
-	"JOHNATHON", "SILAS", "FREDERIC", "DICK", "IRWIN", "MERLIN", "CHARLEY", "MARCELINO", "HARRIS", "CARLO",
-	"TRENTON", "KURTIS", "HUNTER", "AURELIO", "WINFRED", "VITO", "COLLIN", "DENVER", "CARTER", "LEONEL",
-	"EMORY", "PASQUALE", "MOHAMMAD", "MARIANO", "DANIAL", "LANDON", "DIRK", "BRANDEN", "ADAN", "BUFORD",
-	"GERMAN", "WILMER", "EMERSON", "ZACHERY", "FLETCHER", "JACQUES", "ERROL", "DALTON", "MONROE", "JOSUE",
-	"EDWARDO", "BOOKER", "WILFORD", "SONNY", "SHELTON", "CARSON", "THERON", "RAYMUNDO", "DAREN", "HOUSTON",
-	"ROBBY", "LINCOLN", "GENARO", "BENNETT", "OCTAVIO", "CORNELL", "HUNG", "ARRON", "ANTONY", "HERSCHEL",
-	"GIOVANNI", "GARTH", "CYRUS", "CYRIL", "RONNY", "LON", "FREEMAN", "DUNCAN", "KENNITH", "CARMINE",
-	"ERICH", "CHADWICK", "WILBURN", "RUSS", "REID", "MYLES", "ANDERSON", "MORTON", "JONAS", "FOREST",
-	"MITCHEL", "MERVIN", "ZANE", "RICH", "JAMEL", "LAZARO", "ALPHONSE", "RANDELL", "MAJOR", "JARRETT",
-	"BROOKS", "ABDUL", "LUCIANO", "SEYMOUR", "EUGENIO", "MOHAMMED", "VALENTIN", "CHANCE", "ARNULFO", "LUCIEN",
-	"FERDINAND", "THAD", "EZRA", "ALDO", "RUBIN", "ROYAL", "MITCH", "EARLE", "ABE", "WYATT",
-	"MARQUIS", "LANNY", "KAREEM", "JAMAR", "BORIS", "ISIAH", "EMILE", "ELMO", "ARON", "LEOPOLDO",
-	"EVERETTE", "JOSEF", "ELOY", "RODRICK", "REINALDO", "LUCIO", "JERROD", "WESTON", "HERSHEL", "BARTON",
-	"PARKER", "LEMUEL", "BURT", "JULES", "GIL", "ELISEO", "AHMAD", "NIGEL", "EFREN", "ANTWAN",
-	"ALDEN", "MARGARITO", "COLEMAN", "DINO", "OSVALDO", "LES", "DEANDRE", "NORMAND", "KIETH", "TREY",
-	"NORBERTO", "NAPOLEON", "JEROLD", "FRITZ", "ROSENDO", "MILFORD", "CHRISTOPER", "ALFONZO", "LYMAN", "JOSIAH",
-	"BRANT", "WILTON", "RICO", "JAMAAL", "DEWITT", "BRENTON", "OLIN", "FOSTER", "FAUSTINO", "CLAUDIO",
-	"JUDSON", "GINO", "EDGARDO", "ALEC", "TANNER", "JARRED", "DONN", "TAD", "PRINCE", "PORFIRIO",
-	"ODIS", "LENARD", "CHAUNCEY", "TOD", "MEL", "MARCELO", "KORY", "AUGUSTUS", "KEVEN", "HILARIO",
-	"BUD", "SAL", "ORVAL", "MAURO", "ZACHARIAH", "OLEN", "ANIBAL", "MILO", "JED", "DILLON",
-	"AMADO", "NEWTON", "LENNY", "RICHIE", "HORACIO", "BRICE", "MOHAMED", "DELMER", "DARIO", "REYES",
-	"MAC", "JONAH", "JERROLD", "ROBT", "HANK", "RUPERT", "ROLLAND", "KENTON", "DAMION", "ANTONE",
-	"WALDO", "FREDRIC", "BRADLY", "KIP", "BURL", "WALKER", "TYREE", "JEFFEREY", "AHMED", "WILLY",
-	"STANFORD", "OREN", "NOBLE", "MOSHE", "MIKEL", "ENOCH", "BRENDON", "QUINTIN", "JAMISON", "FLORENCIO",
-	"DARRICK", "TOBIAS", "HASSAN", "GIUSEPPE", "DEMARCUS", "CLETUS", "TYRELL", "LYNDON", "KEENAN", "WERNER",
-	"GERALDO", "COLUMBUS", "CHET", "BERTRAM", "MARKUS", "HUEY", "HILTON", "DWAIN", "DONTE", "TYRON",
-	"OMER", "ISAIAS", "HIPOLITO", "FERMIN", "ADALBERTO", "BO", "BARRETT", "TEODORO", "MCKINLEY", "MAXIMO",
-	"GARFIELD", "RALEIGH", "LAWERENCE", "ABRAM", "RASHAD", "KING", "EMMITT", "DARON", "SAMUAL", "MIQUEL",
-	"EUSEBIO", "DOMENIC", "DARRON", "BUSTER", "WILBER", "RENATO", "JC", "HOYT", "HAYWOOD", "EZEKIEL",
-	"CHAS", "FLORENTINO", "ELROY", "CLEMENTE", "ARDEN", "NEVILLE", "EDISON", "DESHAWN", "NATHANIAL", "JORDON",
-	"DANILO", "CLAUD", "SHERWOOD", "RAYMON", "RAYFORD", "CRISTOBAL", "AMBROSE", "TITUS", "HYMAN", "FELTON",
-	"EZEQUIEL", "ERASMO", "STANTON", "LONNY", "LEN", "IKE", "MILAN", "LINO", "JAROD", "HERB",
-	"ANDREAS", "WALTON", "RHETT", "PALMER", "DOUGLASS", "CORDELL", "OSWALDO", "ELLSWORTH", "VIRGILIO", "TONEY",
-	"NATHANAEL", "DEL", "BENEDICT", "MOSE", "JOHNSON", "ISREAL", "GARRET", "FAUSTO", "ASA", "ARLEN",
-	"ZACK", "WARNER", "MODESTO", "FRANCESCO", "MANUAL", "GAYLORD", "GASTON", "FILIBERTO", "DEANGELO", "MICHALE",
-	"GRANVILLE", "WES", "MALIK", "ZACKARY", "TUAN", "ELDRIDGE", "CRISTOPHER", "CORTEZ", "ANTIONE", "MALCOM",
-	"LONG", "KOREY", "JOSPEH", "COLTON", "WAYLON", "VON", "HOSEA", "SHAD", "SANTO", "RUDOLF",
-	"ROLF", "REY", "RENALDO", "MARCELLUS", "LUCIUS", "KRISTOFER", "BOYCE", "BENTON", "HAYDEN", "HARLAND",
-	"ARNOLDO", "RUEBEN", "LEANDRO", "KRAIG", "JERRELL", "JEROMY", "HOBERT", "CEDRICK", "ARLIE", "WINFORD",
-	"WALLY", "LUIGI", "KENETH", "JACINTO", "GRAIG", "FRANKLYN", "EDMUNDO", "SID", "PORTER", "LEIF",
-	"JERAMY", "BUCK", "WILLIAN", "VINCENZO", "SHON", "LYNWOOD", "JERE", "HAI", "ELDEN", "DORSEY",
-	"DARELL", "BRODERICK", "ALONSO"
-	]
-	total_sum = 0
-	temp_sum = 0
-	name.sort()
-	for i in range(len(name)):
-		for j in name[i]:
-			temp_sum += ord(j) - ord('A') + 1
-		total_sum += (i + 1) * temp_sum
-		temp_sum = 0
-	print(total_sum)
+# -*- coding: latin-1 -*-
+"""
+Name scores
+Problem 22
 
+Using names.txt (right click and 'Save Link/Target As...'), a 46K text file
+containing over five-thousand first names, begin by sorting it into
+alphabetical order. Then working out the alphabetical value for each name,
+multiply this value by its alphabetical position in the list to obtain a name
+score.
 
-if __name__ == '__main__':
-	main()
+For example, when the list is sorted into alphabetical order, COLIN, which is
+worth 3 + 15 + 12 + 9 + 14 = 53, is the 938th name in the list. So, COLIN would
+obtain a score of 938 × 53 = 49714.
+
+What is the total of all the name scores in the file?
+"""
+import os
+
+
+def solution():
+    """Returns the total of all the name scores in the file.
+
+    >>> solution()
+    871198282
+    """
+    total_sum = 0
+    temp_sum = 0
+    with open(os.path.dirname(__file__) + "/p022_names.txt") as file:
+        name = str(file.readlines()[0])
+        name = name.replace('"', "").split(",")
+
+    name.sort()
+    for i in range(len(name)):
+        for j in name[i]:
+            temp_sum += ord(j) - ord("A") + 1
+        total_sum += (i + 1) * temp_sum
+        temp_sum = 0
+    return total_sum
+
+
+if __name__ == "__main__":
+    print(solution())
diff --git a/project_euler/problem_234/__init__.py b/project_euler/problem_234/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/project_euler/problem_234/sol1.py b/project_euler/problem_234/sol1.py
index c7a6bd97d66b..8298a7f8cce3 100644
--- a/project_euler/problem_234/sol1.py
+++ b/project_euler/problem_234/sol1.py
@@ -1,4 +1,22 @@
-# https://projecteuler.net/problem=234
+"""
+https://projecteuler.net/problem=234
+
+For an integer n ≥ 4, we define the lower prime square root of n, denoted by
+lps(n), as the largest prime ≤ √n and the upper prime square root of n, ups(n),
+as the smallest prime ≥ √n.
+
+So, for example, lps(4) = 2 = ups(4), lps(1000) = 31, ups(1000) = 37. Let us
+call an integer n ≥ 4 semidivisible, if one of lps(n) and ups(n) divides n,
+but not both.
+
+The sum of the semidivisible numbers not exceeding 15 is 30, the numbers are 8,
+10 and 12. 15 is not semidivisible because it is a multiple of both lps(15) = 3
+and ups(15) = 5. As a further example, the sum of the 92 semidivisible numbers
+up to 1000 is 34825.
+
+What is the sum of all semidivisible numbers not exceeding 999966663333 ?
+"""
+
 def fib(a, b, n):
     
     if n==1:
@@ -17,16 +35,22 @@ def fib(a, b, n):
     return c
 
 
-q=int(input())
-for x in range(q):
-    l=[i for i in input().split()]
-    c1=0
-    c2=1
-    while(1):
-        
-        if len(fib(l[0],l[1],c2))<int(l[2]):
-            c2+=1
-        else:
-            break
-    print(fib(l[0],l[1],c2+1)[int(l[2])-1])
- 
+def solution(n):
+    """Returns the sum of all semidivisible numbers not exceeding n."""
+    semidivisible = []
+    for x in range(n):
+        l=[i for i in input().split()]
+        c1=0
+        c2=1
+        while(1):
+            if len(fib(l[0],l[1],c2))<int(l[2]):
+                c2+=1
+            else:
+                break
+        semidivisible.append(fib(l[0],l[1],c2+1)[int(l[2])-1])
+    return semidivisible
+
+
+if __name__ == "__main__":
+    for i in solution(int(str(input()).strip())):
+        print(i)
diff --git a/project_euler/problem_24/__init__.py b/project_euler/problem_24/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/project_euler/problem_24/sol1.py b/project_euler/problem_24/sol1.py
index b20493cb03af..1c6378b38260 100644
--- a/project_euler/problem_24/sol1.py
+++ b/project_euler/problem_24/sol1.py
@@ -1,7 +1,27 @@
+"""
+A permutation is an ordered arrangement of objects. For example, 3124 is one
+possible permutation of the digits 1, 2, 3 and 4. If all of the permutations
+are listed numerically or alphabetically, we call it lexicographic order. The
+lexicographic permutations of 0, 1 and 2 are:
+
+    012   021   102   120   201   210
+
+What is the millionth lexicographic permutation of the digits 0, 1, 2, 3, 4, 5,
+6, 7, 8 and 9?
+"""
 from itertools import permutations
-def main():
-	result=list(map("".join, permutations('0123456789')))
-	print(result[999999])
 
-if __name__ == '__main__':
-	main()
\ No newline at end of file
+
+def solution():
+    """Returns the millionth lexicographic permutation of the digits 0, 1, 2,
+    3, 4, 5, 6, 7, 8 and 9.
+
+    >>> solution()
+    '2783915460'
+    """
+    result = list(map("".join, permutations("0123456789")))
+    return result[999999]
+
+
+if __name__ == "__main__":
+    print(solution())
diff --git a/project_euler/problem_25/__init__.py b/project_euler/problem_25/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/project_euler/problem_25/sol1.py b/project_euler/problem_25/sol1.py
index f8cea3093dcf..be3b4d9b2d7d 100644
--- a/project_euler/problem_25/sol1.py
+++ b/project_euler/problem_25/sol1.py
@@ -1,31 +1,75 @@
-from __future__ import print_function
+# -*- coding: utf-8 -*-
+"""
+The Fibonacci sequence is defined by the recurrence relation:
+
+    Fn = Fn−1 + Fn−2, where F1 = 1 and F2 = 1.
+
+Hence the first 12 terms will be:
+
+    F1 = 1
+    F2 = 1
+    F3 = 2
+    F4 = 3
+    F5 = 5
+    F6 = 8
+    F7 = 13
+    F8 = 21
+    F9 = 34
+    F10 = 55
+    F11 = 89
+    F12 = 144
+
+The 12th term, F12, is the first term to contain three digits.
+
+What is the index of the first term in the Fibonacci sequence to contain 1000
+digits?
+"""
 
 try:
-	xrange			#Python 2
+    xrange  # Python 2
 except NameError:
-	xrange = range	#Python 3
+    xrange = range  # Python 3
+
 
 def fibonacci(n):
-	if n == 1 or type(n) is not int:
-		return 0
-	elif n == 2:
-		return 1
-	else:
-		sequence = [0, 1]
-		for i in xrange(2, n+1):
-			sequence.append(sequence[i-1] + sequence[i-2])
+    if n == 1 or type(n) is not int:
+        return 0
+    elif n == 2:
+        return 1
+    else:
+        sequence = [0, 1]
+        for i in xrange(2, n + 1):
+            sequence.append(sequence[i - 1] + sequence[i - 2])
+
+        return sequence[n]
 
-		return sequence[n]
 
 def fibonacci_digits_index(n):
-	digits = 0
-	index = 2
+    digits = 0
+    index = 2
+
+    while digits < n:
+        index += 1
+        digits = len(str(fibonacci(index)))
+
+    return index
+
+
+def solution(n):
+    """Returns the index of the first term in the Fibonacci sequence to contain
+    n digits.
 
-	while digits < n:
-		index += 1
-		digits = len(str(fibonacci(index)))
+    >>> solution(1000)
+    4782
+    >>> solution(100)
+    476
+    >>> solution(50)
+    237
+    >>> solution(3)
+    12
+    """
+    return fibonacci_digits_index(n)
 
-	return index
 
-if __name__ == '__main__':
-	print(fibonacci_digits_index(1000))
\ No newline at end of file
+if __name__ == "__main__":
+    print(solution(int(str(input()).strip())))
diff --git a/project_euler/problem_25/sol2.py b/project_euler/problem_25/sol2.py
index 35147a9bfb14..d754e2ddd722 100644
--- a/project_euler/problem_25/sol2.py
+++ b/project_euler/problem_25/sol2.py
@@ -1,10 +1,57 @@
-def fibonacci_genrator():
-	a, b = 0,1
-	while True:
-		a,b = b,a+b
-		yield b
-answer = 1
-gen = fibonacci_genrator()
-while len(str(next(gen))) < 1000:
-	answer += 1
-assert answer+1 == 4782
+# -*- coding: utf-8 -*-
+"""
+The Fibonacci sequence is defined by the recurrence relation:
+
+    Fn = Fn−1 + Fn−2, where F1 = 1 and F2 = 1.
+
+Hence the first 12 terms will be:
+
+    F1 = 1
+    F2 = 1
+    F3 = 2
+    F4 = 3
+    F5 = 5
+    F6 = 8
+    F7 = 13
+    F8 = 21
+    F9 = 34
+    F10 = 55
+    F11 = 89
+    F12 = 144
+
+The 12th term, F12, is the first term to contain three digits.
+
+What is the index of the first term in the Fibonacci sequence to contain 1000
+digits?
+"""
+
+
+def fibonacci_generator():
+    a, b = 0, 1
+    while True:
+        a, b = b, a + b
+        yield b
+
+
+def solution(n):
+    """Returns the index of the first term in the Fibonacci sequence to contain
+    n digits.
+
+    >>> solution(1000)
+    4782
+    >>> solution(100)
+    476
+    >>> solution(50)
+    237
+    >>> solution(3)
+    12
+    """
+    answer = 1
+    gen = fibonacci_generator()
+    while len(str(next(gen))) < n:
+        answer += 1
+    return answer + 1
+
+
+if __name__ == "__main__":
+    print(solution(int(str(input()).strip())))
diff --git a/project_euler/problem_28/__init__.py b/project_euler/problem_28/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/project_euler/problem_28/sol1.py b/project_euler/problem_28/sol1.py
index 4942115ce537..63386ce3058c 100644
--- a/project_euler/problem_28/sol1.py
+++ b/project_euler/problem_28/sol1.py
@@ -1,29 +1,60 @@
-from __future__ import print_function
+"""
+Starting with the number 1 and moving to the right in a clockwise direction a 5
+by 5 spiral is formed as follows:
+
+    21 22 23 24 25
+    20  7  8  9 10
+    19  6  1  2 11
+    18  5  4  3 12
+    17 16 15 14 13
+
+It can be verified that the sum of the numbers on the diagonals is 101.
+
+What is the sum of the numbers on the diagonals in a 1001 by 1001 spiral formed
+in the same way?
+"""
+
 from math import ceil
 
 try:
-	xrange			#Python 2
+    xrange  # Python 2
 except NameError:
-	xrange = range	#Python 3
+    xrange = range  # Python 3
+
 
 def diagonal_sum(n):
-	total = 1
-
-	for i in xrange(1, int(ceil(n/2.0))):
-		odd = 2*i+1
-		even = 2*i
-		total = total + 4*odd**2 - 6*even
-
-	return total
-
-if __name__ == '__main__':
-	import sys
-
-	if len(sys.argv) == 1:
-		print(diagonal_sum(1001))
-	else:
-		try:
-			n = int(sys.argv[1])
-			diagonal_sum(n)
-		except ValueError:
-			print('Invalid entry - please enter a number')
\ No newline at end of file
+    """Returns the sum of the numbers on the diagonals in a n by n spiral
+    formed in the same way.
+
+    >>> diagonal_sum(1001)
+    669171001
+    >>> diagonal_sum(500)
+    82959497
+    >>> diagonal_sum(100)
+    651897
+    >>> diagonal_sum(50)
+    79697
+    >>> diagonal_sum(10)
+    537
+    """
+    total = 1
+
+    for i in xrange(1, int(ceil(n / 2.0))):
+        odd = 2 * i + 1
+        even = 2 * i
+        total = total + 4 * odd ** 2 - 6 * even
+
+    return total
+
+
+if __name__ == "__main__":
+    import sys
+
+    if len(sys.argv) == 1:
+        print(diagonal_sum(1001))
+    else:
+        try:
+            n = int(sys.argv[1])
+            print(diagonal_sum(n))
+        except ValueError:
+            print("Invalid entry - please enter a number")
diff --git a/project_euler/problem_29/__init__.py b/project_euler/problem_29/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/project_euler/problem_29/solution.py b/project_euler/problem_29/solution.py
index 64d35c84d9ca..e67dafe4639d 100644
--- a/project_euler/problem_29/solution.py
+++ b/project_euler/problem_29/solution.py
@@ -1,33 +1,51 @@
-def main():
+"""
+Consider all integer combinations of ab for 2 <= a <= 5 and 2 <= b <= 5:
+
+2^2=4,  2^3=8,   2^4=16,  2^5=32
+3^2=9,  3^3=27,  3^4=81,  3^5=243
+4^2=16, 4^3=64,  4^4=256, 4^5=1024
+5^2=25, 5^3=125, 5^4=625, 5^5=3125
+
+If they are then placed in numerical order, with any repeats removed, we get
+the following sequence of 15 distinct terms:
+
+4, 8, 9, 16, 25, 27, 32, 64, 81, 125, 243, 256, 625, 1024, 3125
+
+How many distinct terms are in the sequence generated by ab
+for 2 <= a <= 100 and 2 <= b <= 100?
+"""
+from __future__ import print_function
+
+
+def solution(n):
+    """Returns the number of distinct terms in the sequence generated by a^b
+    for 2 <= a <= 100 and 2 <= b <= 100.
+ 
+    >>> solution(100)
+    9183
+    >>> solution(50)
+    2184
+    >>> solution(20)
+    324
+    >>> solution(5)
+    15
+    >>> solution(2)
+    1
+    >>> solution(1)
+    0
     """
-    Consider all integer combinations of ab for 2 <= a <= 5 and 2 <= b <= 5:
-
-    22=4, 23=8, 24=16, 25=32
-    32=9, 33=27, 34=81, 35=243
-    42=16, 43=64, 44=256, 45=1024
-    52=25, 53=125, 54=625, 55=3125
-    If they are then placed in numerical order, with any repeats removed,
-    we get the following sequence of 15 distinct terms:
-
-    4, 8, 9, 16, 25, 27, 32, 64, 81, 125, 243, 256, 625, 1024, 3125
-
-    How many distinct terms are in the sequence generated by ab
-    for 2 <= a <= 100 and 2 <= b <= 100?
-    """
-
     collectPowers = set()
 
     currentPow = 0
 
-    N = 101     # maximum limit
+    N = n + 1  # maximum limit
 
     for a in range(2, N):
         for b in range(2, N):
-            currentPow = a**b   # calculates the current power
-            collectPowers.add(currentPow)   # adds the result to the set
-
-    print("Number of terms ", len(collectPowers))
+            currentPow = a ** b  # calculates the current power
+            collectPowers.add(currentPow)  # adds the result to the set
+    return len(collectPowers)
 
 
-if __name__ == '__main__':
-    main()
+if __name__ == "__main__":
+    print("Number of terms ", solution(int(str(input()).strip())))
diff --git a/project_euler/problem_31/__init__.py b/project_euler/problem_31/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/project_euler/problem_31/sol1.py b/project_euler/problem_31/sol1.py
index 33653722f890..e2a209e5df5a 100644
--- a/project_euler/problem_31/sol1.py
+++ b/project_euler/problem_31/sol1.py
@@ -1,10 +1,5 @@
 # -*- coding: utf-8 -*-
-from __future__ import print_function
-try:
-    raw_input          # Python 2
-except NameError:
-    raw_input = input  # Python 3
-'''
+"""
 Coin sums
 Problem 31
 In England the currency is made up of pound, £, and pence, p, and there are
@@ -15,7 +10,13 @@
 
 1×£1 + 1×50p + 2×20p + 1×5p + 1×2p + 3×1p
 How many different ways can £2 be made using any number of coins?
-'''
+"""
+from __future__ import print_function
+
+try:
+    raw_input  # Python 2
+except NameError:
+    raw_input = input  # Python 3
 
 
 def one_pence():
@@ -50,4 +51,21 @@ def two_pound(x):
     return 0 if x < 0 else two_pound(x - 200) + one_pound(x)
 
 
-print(two_pound(200))
+def solution(n):
+    """Returns the number of different ways can £n be made using any number of
+    coins?
+
+    >>> solution(500)
+    6295434
+    >>> solution(200)
+    73682
+    >>> solution(50)
+    451
+    >>> solution(10)
+    11
+    """
+    return two_pound(n)
+
+
+if __name__ == "__main__":
+    print(solution(int(str(input()).strip())))
diff --git a/project_euler/problem_36/__init__.py b/project_euler/problem_36/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/project_euler/problem_36/sol1.py b/project_euler/problem_36/sol1.py
index d78e7e59f210..38b60420992b 100644
--- a/project_euler/problem_36/sol1.py
+++ b/project_euler/problem_36/sol1.py
@@ -1,30 +1,57 @@
-from __future__ import print_function
-'''
+"""
 Double-base palindromes
 Problem 36
 The decimal number, 585 = 10010010012 (binary), is palindromic in both bases.
 
-Find the sum of all numbers, less than one million, which are palindromic in base 10 and base 2.
+Find the sum of all numbers, less than one million, which are palindromic in
+base 10 and base 2.
 
-(Please note that the palindromic number, in either base, may not include leading zeros.)
-'''
+(Please note that the palindromic number, in either base, may not include
+leading zeros.)
+"""
 try:
-	xrange		#Python 2
+    xrange  # Python 2
 except NameError:
-	xrange = range	#Python 3
+    xrange = range  # Python 3
+
 
 def is_palindrome(n):
-	n = str(n)
+    n = str(n)
+
+    if n == n[::-1]:
+        return True
+    else:
+        return False
+
+
+def solution(n):
+    """Return the sum of all numbers, less than n , which are palindromic in
+    base 10 and base 2.
 
-	if n == n[::-1]:
-		return True
-	else:
-		return False
+    >>> solution(1000000)
+    872187
+    >>> solution(500000)
+    286602
+    >>> solution(100000)
+    286602
+    >>> solution(1000)
+    1772
+    >>> solution(100)
+    157
+    >>> solution(10)
+    25
+    >>> solution(2)
+    1
+    >>> solution(1)
+    0
+    """
+    total = 0
 
-total = 0
+    for i in xrange(1, n):
+        if is_palindrome(i) and is_palindrome(bin(i).split("b")[1]):
+            total += i
+    return total
 
-for i in xrange(1, 1000000):
-	if is_palindrome(i) and is_palindrome(bin(i).split('b')[1]):
-		total += i
 
-print(total)
\ No newline at end of file
+if __name__ == "__main__":
+    print(solution(int(str(input().strip()))))
diff --git a/project_euler/problem_40/__init__.py b/project_euler/problem_40/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/project_euler/problem_40/sol1.py b/project_euler/problem_40/sol1.py
index ab4017512a1a..accd7125354c 100644
--- a/project_euler/problem_40/sol1.py
+++ b/project_euler/problem_40/sol1.py
@@ -1,26 +1,47 @@
-#-.- coding: latin-1 -.-
-from __future__ import print_function
-'''
+# -.- coding: latin-1 -.-
+"""
 Champernowne's constant
 Problem 40
-An irrational decimal fraction is created by concatenating the positive integers:
+An irrational decimal fraction is created by concatenating the positive
+integers:
 
 0.123456789101112131415161718192021...
 
 It can be seen that the 12th digit of the fractional part is 1.
 
-If dn represents the nth digit of the fractional part, find the value of the following expression.
+If dn represents the nth digit of the fractional part, find the value of the
+following expression.
 
 d1 × d10 × d100 × d1000 × d10000 × d100000 × d1000000
-'''
+"""
+from __future__ import print_function
+
+
+def solution():
+    """Returns 
+
+    >>> solution()
+    210
+    """
+    constant = []
+    i = 1
+
+    while len(constant) < 1e6:
+        constant.append(str(i))
+        i += 1
 
-constant = []
-i = 1
+    constant = "".join(constant)
 
-while len(constant) < 1e6:
-	constant.append(str(i))
-	i += 1
+    return (
+        int(constant[0])
+        * int(constant[9])
+        * int(constant[99])
+        * int(constant[999])
+        * int(constant[9999])
+        * int(constant[99999])
+        * int(constant[999999])
+    )
 
-constant = ''.join(constant)
 
-print(int(constant[0])*int(constant[9])*int(constant[99])*int(constant[999])*int(constant[9999])*int(constant[99999])*int(constant[999999]))
\ No newline at end of file
+if __name__ == "__main__":
+    print(solution())
diff --git a/project_euler/problem_48/__init__.py b/project_euler/problem_48/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/project_euler/problem_48/sol1.py b/project_euler/problem_48/sol1.py
index 5c4bdb0f6384..95af951c0e8a 100644
--- a/project_euler/problem_48/sol1.py
+++ b/project_euler/problem_48/sol1.py
@@ -1,21 +1,29 @@
-from __future__ import print_function
-'''
+"""
 Self Powers
 Problem 48
 
 The series, 11 + 22 + 33 + ... + 1010 = 10405071317.
 
 Find the last ten digits of the series, 11 + 22 + 33 + ... + 10001000.
-'''
+"""
 
 try:
-	xrange
+    xrange
 except NameError:
-	xrange = range
+    xrange = range
 
-total = 0
-for i in xrange(1, 1001):
-	total += i**i
 
+def solution():
+    """Returns the last 10 digits of the series, 11 + 22 + 33 + ... + 10001000.
 
-print(str(total)[-10:])
\ No newline at end of file
+    >>> solution()
+    '9110846700'
+    """
+    total = 0
+    for i in xrange(1, 1001):
+        total += i ** i
+    return str(total)[-10:]
+
+
+if __name__ == "__main__":
+    print(solution())
diff --git a/project_euler/problem_52/__init__.py b/project_euler/problem_52/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/project_euler/problem_52/sol1.py b/project_euler/problem_52/sol1.py
index 376b4cfa1d63..df5c46ae05d1 100644
--- a/project_euler/problem_52/sol1.py
+++ b/project_euler/problem_52/sol1.py
@@ -1,23 +1,37 @@
-from __future__ import print_function
-'''
+"""
 Permuted multiples
 Problem 52
 
-It can be seen that the number, 125874, and its double, 251748, contain exactly the same digits, but in a different order.
+It can be seen that the number, 125874, and its double, 251748, contain exactly
+the same digits, but in a different order.
 
-Find the smallest positive integer, x, such that 2x, 3x, 4x, 5x, and 6x, contain the same digits.
-'''
-i = 1
+Find the smallest positive integer, x, such that 2x, 3x, 4x, 5x, and 6x,
+contain the same digits.
+"""
 
-while True:
-	if sorted(list(str(i))) == \
-       sorted(list(str(2*i))) == \
-       sorted(list(str(3*i))) == \
-       sorted(list(str(4*i))) == \
-       sorted(list(str(5*i))) == \
-       sorted(list(str(6*i))):
-		break
 
-	i += 1
+def solution():
+    """Returns the smallest positive integer, x, such that 2x, 3x, 4x, 5x, and
+    6x, contain the same digits.
 
-print(i) 
\ No newline at end of file
+    >>> solution()
+    142857
+    """
+    i = 1
+
+    while True:
+        if (
+            sorted(list(str(i)))
+            == sorted(list(str(2 * i)))
+            == sorted(list(str(3 * i)))
+            == sorted(list(str(4 * i)))
+            == sorted(list(str(5 * i)))
+            == sorted(list(str(6 * i)))
+        ):
+            return i
+
+        i += 1
+
+
+if __name__ == "__main__":
+    print(solution())
diff --git a/project_euler/problem_53/__init__.py b/project_euler/problem_53/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/project_euler/problem_53/sol1.py b/project_euler/problem_53/sol1.py
index ed6d5329eb4e..c72e0b993a34 100644
--- a/project_euler/problem_53/sol1.py
+++ b/project_euler/problem_53/sol1.py
@@ -1,13 +1,11 @@
-#-.- coding: latin-1 -.-
-from __future__ import print_function
-from math import factorial
-'''
+# -.- coding: latin-1 -.-
+"""
 Combinatoric selections
 Problem 53
 
 There are exactly ten ways of selecting three from five, 12345:
 
-123, 124, 125, 134, 135, 145, 234, 235, 245, and 345
+    123, 124, 125, 134, 135, 145, 234, 235, 245, and 345
 
 In combinatorics, we use the notation, 5C3 = 10.
 
@@ -16,21 +14,37 @@
 nCr = n!/(r!(n−r)!),where r ≤ n, n! = n×(n−1)×...×3×2×1, and 0! = 1.
 It is not until n = 23, that a value exceeds one-million: 23C10 = 1144066.
 
-How many, not necessarily distinct, values of nCr, for 1 ≤ n ≤ 100, are greater than one-million?
-'''
+How many, not necessarily distinct, values of nCr, for 1 ≤ n ≤ 100, are greater
+than one-million?
+"""
+from __future__ import print_function
+from math import factorial
+
 try:
-	xrange		#Python 2
+    xrange  # Python 2
 except NameError:
-	xrange = range	#Python 3
+    xrange = range  # Python 3
+
 
 def combinations(n, r):
-	return factorial(n)/(factorial(r)*factorial(n-r))
+    return factorial(n) / (factorial(r) * factorial(n - r))
+
+
+def solution():
+    """Returns the number of values of nCr, for 1 ≤ n ≤ 100, are greater than
+    one-million
+
+    >>> solution()
+    4075
+    """
+    total = 0
 
-total = 0
+    for i in xrange(1, 101):
+        for j in xrange(1, i + 1):
+            if combinations(i, j) > 1e6:
+                total += 1
+    return total
 
-for i in xrange(1, 101):
-	for j in xrange(1, i+1):
-		if combinations(i, j) > 1e6:
-			total += 1
 
-print(total)
\ No newline at end of file
+if __name__ == "__main__":
+    print(solution())
diff --git a/project_euler/problem_76/__init__.py b/project_euler/problem_76/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/project_euler/problem_76/sol1.py b/project_euler/problem_76/sol1.py
index 2832f6d7afb6..c9e3c452fbc4 100644
--- a/project_euler/problem_76/sol1.py
+++ b/project_euler/problem_76/sol1.py
@@ -1,5 +1,4 @@
-from __future__ import print_function
-'''
+"""
 Counting Summations
 Problem 76
 
@@ -12,24 +11,50 @@
 2 + 1 + 1 + 1
 1 + 1 + 1 + 1 + 1
 
-How many different ways can one hundred be written as a sum of at least two positive integers?
-'''
+How many different ways can one hundred be written as a sum of at least two
+positive integers?
+"""
+from __future__ import print_function
+
 try:
-	xrange		#Python 2
+    xrange  # Python 2
 except NameError:
-	xrange = range	#Python 3
+    xrange = range  # Python 3
+
 
 def partition(m):
-	memo = [[0 for _ in xrange(m)] for _ in xrange(m+1)]
-	for i in xrange(m+1):
-		memo[i][0] = 1
+    """Returns the number of different ways one hundred can be written as a sum
+    of at least two positive integers.
+
+    >>> partition(100)
+    190569291
+    >>> partition(50)
+    204225
+    >>> partition(30)
+    5603
+    >>> partition(10)
+    41
+    >>> partition(5)
+    6
+    >>> partition(3)
+    2
+    >>> partition(2)
+    1
+    >>> partition(1)
+    0
+    """
+    memo = [[0 for _ in xrange(m)] for _ in xrange(m + 1)]
+    for i in xrange(m + 1):
+        memo[i][0] = 1
+
+    for n in xrange(m + 1):
+        for k in xrange(1, m):
+            memo[n][k] += memo[n][k - 1]
+            if n > k:
+                memo[n][k] += memo[n - k - 1][k]
 
-	for n in xrange(m+1):
-		for k in xrange(1, m):
-			memo[n][k] += memo[n][k-1]
-			if n > k:
-				memo[n][k] += memo[n-k-1][k]
+    return memo[m][m - 1] - 1
 
-	return (memo[m][m-1] - 1)
 
-print(partition(100))
\ No newline at end of file
+if __name__ == "__main__":
+    print(partition(int(str(input()).strip())))

From 7cdda931fd6e272529f25a4cd2dbd7c6785d467c Mon Sep 17 00:00:00 2001
From: cclauss <cclauss@me.com>
Date: Wed, 17 Jul 2019 06:07:25 +0200
Subject: [PATCH 120/348] Travis CI: Add pytest --doctest-modules graphs
 (#1018)

---
 .travis.yml                                   |  1 +
 graphs/basic_graphs.py                        | 75 ++++++++++---------
 graphs/bellman_ford.py                        | 40 +++++-----
 graphs/dijkstra_2.py                          | 40 +++++-----
 ...d_warshall.py => graphs_floyd_warshall.py} |  0
 graphs/minimum_spanning_tree_kruskal.py       | 48 ++++++------
 graphs/minimum_spanning_tree_prims.py         | 19 ++---
 graphs/multi_hueristic_astar.py               | 25 ++++---
 graphs/scc_kosaraju.py                        | 35 +++++----
 9 files changed, 148 insertions(+), 135 deletions(-)
 rename graphs/{floyd_warshall.py => graphs_floyd_warshall.py} (100%)

diff --git a/.travis.yml b/.travis.yml
index 3b55045ac33f..55ea2c7ddc24 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -21,6 +21,7 @@ script:
       digital_image_processing
       divide_and_conquer
       dynamic_programming
+      graphs
       hashes
       linear_algebra_python
       matrix
diff --git a/graphs/basic_graphs.py b/graphs/basic_graphs.py
index 3b3abeb1720d..ee63ca995de6 100644
--- a/graphs/basic_graphs.py
+++ b/graphs/basic_graphs.py
@@ -10,42 +10,44 @@
 except NameError:
     xrange = range  # Python 3
 
-# Accept No. of Nodes and edges
-n, m = map(int, raw_input().split(" "))
 
-# Initialising Dictionary of edges
-g = {}
-for i in xrange(n):
-    g[i + 1] = []
-
-"""
---------------------------------------------------------------------------------
-    Accepting edges of Unweighted Directed Graphs
---------------------------------------------------------------------------------
-"""
-for _ in xrange(m):
-    x, y = map(int, raw_input().split(" "))
-    g[x].append(y)
-
-"""
---------------------------------------------------------------------------------
-    Accepting edges of Unweighted Undirected Graphs
---------------------------------------------------------------------------------
-"""
-for _ in xrange(m):
-    x, y = map(int, raw_input().split(" "))
-    g[x].append(y)
-    g[y].append(x)
+if __name__ == "__main__":
+    # Accept No. of Nodes and edges
+    n, m = map(int, raw_input().split(" "))
 
-"""
---------------------------------------------------------------------------------
-    Accepting edges of Weighted Undirected Graphs
---------------------------------------------------------------------------------
-"""
-for _ in xrange(m):
-    x, y, r = map(int, raw_input().split(" "))
-    g[x].append([y, r])
-    g[y].append([x, r])
+    # Initialising Dictionary of edges
+    g = {}
+    for i in xrange(n):
+        g[i + 1] = []
+
+    """
+    ----------------------------------------------------------------------------
+        Accepting edges of Unweighted Directed Graphs
+    ----------------------------------------------------------------------------
+    """
+    for _ in xrange(m):
+        x, y = map(int, raw_input().strip().split(" "))
+        g[x].append(y)
+
+    """
+    ----------------------------------------------------------------------------
+        Accepting edges of Unweighted Undirected Graphs
+    ----------------------------------------------------------------------------
+    """
+    for _ in xrange(m):
+        x, y = map(int, raw_input().strip().split(" "))
+        g[x].append(y)
+        g[y].append(x)
+
+    """
+    ----------------------------------------------------------------------------
+        Accepting edges of Weighted Undirected Graphs
+    ----------------------------------------------------------------------------
+    """
+    for _ in xrange(m):
+        x, y, r = map(int, raw_input().strip().split(" "))
+        g[x].append([y, r])
+        g[y].append([x, r])
 
 """
 --------------------------------------------------------------------------------
@@ -168,9 +170,10 @@ def topo(G, ind=None, Q=[1]):
 
 
 def adjm():
-    n, a = raw_input(), []
+    n = raw_input().strip()
+    a = []
     for i in xrange(n):
-        a.append(map(int, raw_input().split()))
+        a.append(map(int, raw_input().strip().split()))
     return a, n
 
 
diff --git a/graphs/bellman_ford.py b/graphs/bellman_ford.py
index 82db80546b94..f49157230054 100644
--- a/graphs/bellman_ford.py
+++ b/graphs/bellman_ford.py
@@ -12,7 +12,7 @@ def printDist(dist, V):
 def BellmanFord(graph, V, E, src):
 	mdist=[float('inf') for i in range(V)]
 	mdist[src] = 0.0
-	
+
 	for i in range(V-1):
 		for j in range(V):
 			u = graph[j]["src"]
@@ -20,7 +20,7 @@ def BellmanFord(graph, V, E, src):
 			w = graph[j]["weight"]
 
 			if mdist[u] != float('inf') and mdist[u] + w < mdist[v]:
-				mdist[v] = mdist[u] + w 
+				mdist[v] = mdist[u] + w
 	for j in range(V):
 			u = graph[j]["src"]
 			v = graph[j]["dst"]
@@ -29,26 +29,26 @@ def BellmanFord(graph, V, E, src):
 			if mdist[u] != float('inf') and mdist[u] + w < mdist[v]:
 				print("Negative cycle found. Solution not possible.")
 				return
-	
-	printDist(mdist, V)	
 
-			
+	printDist(mdist, V)
+
+
+
+if __name__ == "__main__":
+    V = int(input("Enter number of vertices: ").strip())
+    E = int(input("Enter number of edges: ").strip())
 
-#MAIN
-V = int(input("Enter number of vertices: "))
-E = int(input("Enter number of edges: "))
+    graph = [dict() for j in range(E)]
 
-graph = [dict() for j in range(E)]
+    for i in range(V):
+	    graph[i][i] = 0.0
 
-for i in range(V):
-	graph[i][i] = 0.0
+    for i in range(E):
+	    print("\nEdge ",i+1)
+	    src = int(input("Enter source:").strip())
+	    dst = int(input("Enter destination:").strip())
+	    weight = float(input("Enter weight:").strip())
+	    graph[i] = {"src": src,"dst": dst, "weight": weight}
 
-for i in range(E):
-	print("\nEdge ",i+1)
-	src = int(input("Enter source:"))
-	dst = int(input("Enter destination:"))
-	weight = float(input("Enter weight:"))
-	graph[i] = {"src": src,"dst": dst, "weight": weight}
-	
-gsrc = int(input("\nEnter shortest path source:"))
-BellmanFord(graph, V, E, gsrc)
+    gsrc = int(input("\nEnter shortest path source:").strip())
+    BellmanFord(graph, V, E, gsrc)
diff --git a/graphs/dijkstra_2.py b/graphs/dijkstra_2.py
index a6c340e8a68d..8f39aec41906 100644
--- a/graphs/dijkstra_2.py
+++ b/graphs/dijkstra_2.py
@@ -22,36 +22,36 @@ def Dijkstra(graph, V, src):
 	mdist=[float('inf') for i in range(V)]
 	vset = [False for i in range(V)]
 	mdist[src] = 0.0
-	
+
 	for i in range(V-1):
 		u = minDist(mdist, vset, V)
 		vset[u] = True
-		
+
 		for v in range(V):
 			if (not vset[v]) and graph[u][v]!=float('inf') and mdist[u] + graph[u][v] < mdist[v]:
-				mdist[v] = mdist[u] + graph[u][v] 
+				mdist[v] = mdist[u] + graph[u][v]
+
+
 
-	
+	printDist(mdist, V)
 
-	printDist(mdist, V)	
 
-			
 
-#MAIN
-V = int(input("Enter number of vertices: "))
-E = int(input("Enter number of edges: "))
+if __name__ == "__main__":
+    V = int(input("Enter number of vertices: ").strip())
+    E = int(input("Enter number of edges: ").strip())
 
-graph = [[float('inf') for i in range(V)] for j in range(V)]
+    graph = [[float('inf') for i in range(V)] for j in range(V)]
 
-for i in range(V):
-	graph[i][i] = 0.0
+    for i in range(V):
+	    graph[i][i] = 0.0
 
-for i in range(E):
-	print("\nEdge ",i+1)
-	src = int(input("Enter source:"))
-	dst = int(input("Enter destination:"))
-	weight = float(input("Enter weight:"))
-	graph[src][dst] = weight
+    for i in range(E):
+	    print("\nEdge ",i+1)
+	    src = int(input("Enter source:").strip())
+	    dst = int(input("Enter destination:").strip())
+	    weight = float(input("Enter weight:").strip())
+	    graph[src][dst] = weight
 
-gsrc = int(input("\nEnter shortest path source:"))
-Dijkstra(graph, V, gsrc)
+    gsrc = int(input("\nEnter shortest path source:").strip())
+    Dijkstra(graph, V, gsrc)
diff --git a/graphs/floyd_warshall.py b/graphs/graphs_floyd_warshall.py
similarity index 100%
rename from graphs/floyd_warshall.py
rename to graphs/graphs_floyd_warshall.py
diff --git a/graphs/minimum_spanning_tree_kruskal.py b/graphs/minimum_spanning_tree_kruskal.py
index 81d64f421a31..975151c90ede 100644
--- a/graphs/minimum_spanning_tree_kruskal.py
+++ b/graphs/minimum_spanning_tree_kruskal.py
@@ -1,32 +1,34 @@
 from __future__ import print_function
-num_nodes, num_edges = list(map(int,input().split()))
 
-edges = []
+if __name__ == "__main__":
+    num_nodes, num_edges = list(map(int, input().strip().split()))
 
-for i in range(num_edges):
-	node1, node2, cost = list(map(int,input().split()))
-	edges.append((i,node1,node2,cost))
+    edges = []
 
-edges = sorted(edges, key=lambda edge: edge[3])
+    for i in range(num_edges):
+	    node1, node2, cost = list(map(int, input().strip().split()))
+	    edges.append((i,node1,node2,cost))
 
-parent = [i for i in range(num_nodes)]
+    edges = sorted(edges, key=lambda edge: edge[3])
 
-def find_parent(i):
-	if(i != parent[i]):
-		parent[i] = find_parent(parent[i])
-	return parent[i]
+    parent = list(range(num_nodes))
 
-minimum_spanning_tree_cost = 0
-minimum_spanning_tree = []
+    def find_parent(i):
+	    if i != parent[i]:
+		    parent[i] = find_parent(parent[i])
+	    return parent[i]
 
-for edge in edges:
-	parent_a = find_parent(edge[1])
-	parent_b = find_parent(edge[2])
-	if(parent_a != parent_b):
-		minimum_spanning_tree_cost += edge[3]
-		minimum_spanning_tree.append(edge)
-		parent[parent_a] = parent_b
+    minimum_spanning_tree_cost = 0
+    minimum_spanning_tree = []
 
-print(minimum_spanning_tree_cost)
-for edge in minimum_spanning_tree:
-	print(edge)
+    for edge in edges:
+	    parent_a = find_parent(edge[1])
+	    parent_b = find_parent(edge[2])
+	    if parent_a != parent_b:
+		    minimum_spanning_tree_cost += edge[3]
+		    minimum_spanning_tree.append(edge)
+		    parent[parent_a] = parent_b
+
+    print(minimum_spanning_tree_cost)
+    for edge in minimum_spanning_tree:
+	    print(edge)
diff --git a/graphs/minimum_spanning_tree_prims.py b/graphs/minimum_spanning_tree_prims.py
index 7b1ad0e743f7..0f21b8f494e4 100644
--- a/graphs/minimum_spanning_tree_prims.py
+++ b/graphs/minimum_spanning_tree_prims.py
@@ -100,12 +100,13 @@ def deleteMinimum(heap, positions):
                     Nbr_TV[ v[0] ] = vertex
     return TreeEdges
 
-# < --------- Prims Algorithm --------- >
-n = int(input("Enter number of vertices: "))
-e = int(input("Enter number of edges: "))
-adjlist = defaultdict(list)
-for x in range(e):
-    l = [int(x) for x in input().split()]
-    adjlist[l[0]].append([ l[1], l[2] ])
-    adjlist[l[1]].append([ l[0], l[2] ])
-print(PrimsAlgorithm(adjlist))
+if __name__ == "__main__":
+    # < --------- Prims Algorithm --------- >
+    n = int(input("Enter number of vertices: ").strip())
+    e = int(input("Enter number of edges: ").strip())
+    adjlist = defaultdict(list)
+    for x in range(e):
+        l = [int(x) for x in input().strip().split()]
+        adjlist[l[0]].append([ l[1], l[2] ])
+        adjlist[l[1]].append([ l[0], l[2] ])
+    print(PrimsAlgorithm(adjlist))
diff --git a/graphs/multi_hueristic_astar.py b/graphs/multi_hueristic_astar.py
index 1acd098f327d..1c01fe9aa6d3 100644
--- a/graphs/multi_hueristic_astar.py
+++ b/graphs/multi_hueristic_astar.py
@@ -18,7 +18,7 @@ def minkey(self):
 			return self.elements[0][0]
 		else:
 			return float('inf')
-	
+
 	def empty(self):
 		return len(self.elements) == 0
 
@@ -48,10 +48,10 @@ def remove_element(self, item):
 				(pro, x) = heapq.heappop(self.elements)
 			for (prito, yyy) in temp:
 				heapq.heappush(self.elements, (prito, yyy))
-	
+
 	def top_show(self):
 		return self.elements[0][1]
-	
+
 	def get(self):
 		(priority, item) = heapq.heappop(self.elements)
 		self.set.remove(item)
@@ -65,7 +65,7 @@ def consistent_hueristic(P, goal):
 
 def hueristic_2(P, goal):
 	# integer division by time variable
-	return consistent_hueristic(P, goal) // t 
+	return consistent_hueristic(P, goal) // t
 
 def hueristic_1(P, goal):
 	# manhattan distance
@@ -74,13 +74,13 @@ def hueristic_1(P, goal):
 def key(start, i, goal, g_function):
 	ans = g_function[start] + W1 * hueristics[i](start, goal)
 	return ans
-	
+
 def do_something(back_pointer, goal, start):
 	grid = np.chararray((n, n))
 	for i in range(n):
 		for j in range(n):
 			grid[i][j] = '*'
-	
+
 	for i in range(n):
 		for j in range(n):
 			if (j, (n-1)-i) in blocks:
@@ -94,7 +94,7 @@ def do_something(back_pointer, goal, start):
 		grid[(n-1)-y_c][x_c] = "-"
 		x = back_pointer[x]
 	grid[(n-1)][0] = "-"
-	
+
 
 	for i in xrange(n):
 		for j in range(n):
@@ -112,7 +112,7 @@ def do_something(back_pointer, goal, start):
 	print("PATH TAKEN BY THE ALGORITHM IS:-")
 	x = back_pointer[goal]
 	while x != start:
-		print(x, end=' ') 
+		print(x, end=' ')
 		x = back_pointer[x]
 	print(x)
 	quit()
@@ -153,7 +153,7 @@ def expand_state(s, j, visited, g_function, close_list_anchor, close_list_inad,
 							if key(neighbours, var, goal, g_function) <= W2 * key(neighbours, 0, goal, g_function):
 								# print("why not plssssssssss")
 								open_list[j].put(neighbours, key(neighbours, var, goal, g_function))
-			
+
 
 	# print
 
@@ -212,7 +212,7 @@ def multi_a_star(start, goal, n_hueristic):
 	for i in range(n_hueristic):
 		open_list.append(PriorityQueue())
 		open_list[i].put(start, key(start, i, goal, g_function))
-	
+
 	close_list_anchor = []
 	close_list_inad = []
 	while open_list[0].minkey() < float('inf'):
@@ -263,4 +263,7 @@ def multi_a_star(start, goal, n_hueristic):
 	print()
 	print("# is an obstacle")
 	print("- is the path taken by algorithm")
-multi_a_star(start, goal, n_hueristic)
+
+
+if __name__ == "__main__":
+    multi_a_star(start, goal, n_hueristic)
diff --git a/graphs/scc_kosaraju.py b/graphs/scc_kosaraju.py
index 1f13ebaba36b..0d0375203b6d 100644
--- a/graphs/scc_kosaraju.py
+++ b/graphs/scc_kosaraju.py
@@ -1,19 +1,5 @@
 from __future__ import print_function
-# n - no of nodes, m - no of edges
-n, m = list(map(int,input().split()))
-
-g = [[] for i in range(n)] #graph
-r = [[] for i in range(n)] #reversed graph
-# input graph data (edges)
-for i in range(m):
-    u, v = list(map(int,input().split()))
-    g[u].append(v)
-    r[v].append(u)
-
-stack = []
-visit = [False]*n
-scc = []
-component = []
+
 
 def dfs(u):
     global g, r, scc, component, visit, stack
@@ -43,4 +29,21 @@ def kosaraju():
         scc.append(component)
     return scc
 
-print(kosaraju())
+
+if __name__ == "__main__":
+    # n - no of nodes, m - no of edges
+    n, m = list(map(int,input().strip().split()))
+
+    g = [[] for i in range(n)] #graph
+    r = [[] for i in range(n)] #reversed graph
+    # input graph data (edges)
+    for i in range(m):
+        u, v = list(map(int,input().strip().split()))
+        g[u].append(v)
+        r[v].append(u)
+
+    stack = []
+    visit = [False]*n
+    scc = []
+    component = []
+    print(kosaraju())

From f195d9251cc64adb64549f79f4e774e220a668ab Mon Sep 17 00:00:00 2001
From: Jigyasa G <33327397+jpg-130@users.noreply.github.com>
Date: Wed, 17 Jul 2019 11:52:09 +0530
Subject: [PATCH 121/348] adding factorial (#930)

* adding factorial

* adding doctest

* Update factorial.py
---
 dynamic_programming/factorial.py | 34 ++++++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 dynamic_programming/factorial.py

diff --git a/dynamic_programming/factorial.py b/dynamic_programming/factorial.py
new file mode 100644
index 000000000000..7c6541ee2a74
--- /dev/null
+++ b/dynamic_programming/factorial.py
@@ -0,0 +1,34 @@
+#Factorial of a number using memoization
+result=[-1]*10
+result[0]=result[1]=1
+def factorial(num):
+    """
+    >>> factorial(7)
+    5040
+    >>> factorial(-1)
+    'Number should not be negative.'
+    >>> [factorial(i) for i in range(5)]
+    [1, 1, 2, 6, 24]
+    """
+    
+    if num<0:
+        return "Number should not be negative."
+    if result[num]!=-1:
+        return result[num]
+    else:
+        result[num]=num*factorial(num-1)
+        #uncomment the following to see how recalculations are avoided
+        #print(result)
+        return result[num]
+
+#factorial of num
+#uncomment the following to see how recalculations are avoided
+##result=[-1]*10
+##result[0]=result[1]=1
+##print(factorial(5))
+# print(factorial(3))
+# print(factorial(7))
+
+if __name__ == "__main__":
+    import doctest
+    doctest.testmod()

From f64b6029389019a2f2599b88078b940054e8be6c Mon Sep 17 00:00:00 2001
From: Sanders Lin <45224617+SandersLin@users.noreply.github.com>
Date: Thu, 18 Jul 2019 00:12:24 +0800
Subject: [PATCH 122/348] Update max_sub_array.py (#1000)

* Update max_sub_array.py

added another method of computing maximum sum subarray

* Update max_sub_array.py

* Update max_sub_array.py
---
 dynamic_programming/max_sub_array.py | 24 ++++++++++++++++++++++--
 1 file changed, 22 insertions(+), 2 deletions(-)

diff --git a/dynamic_programming/max_sub_array.py b/dynamic_programming/max_sub_array.py
index 5d48882427c0..56983b7d22c2 100644
--- a/dynamic_programming/max_sub_array.py
+++ b/dynamic_programming/max_sub_array.py
@@ -2,7 +2,7 @@
 author : Mayank Kumar Jha (mk9440)
 """
 from __future__ import print_function
-
+from typing import List
 import time
 import matplotlib.pyplot as plt
 from random import randint
@@ -37,7 +37,27 @@ def find_max_cross_sum(A,low,mid,high):
             right_sum=summ
             max_right=i
     return max_left,max_right,(left_sum+right_sum)
-    
+
+def max_sub_array(nums: List[int]) -> int:
+    """
+     Finds the contiguous subarray (can be empty array) 
+     which has the largest sum and return its sum.
+
+    >>> max_sub_array([-2,1,-3,4,-1,2,1,-5,4])
+    6
+    >>> max_sub_array([])
+    0
+    >>> max_sub_array([-1,-2,-3])
+    0
+    """
+    best = 0 
+    current = 0 
+    for i in nums: 
+        current += i 
+        if current < 0:
+            current = 0
+        best = max(best, current)
+    return best 
 
 if __name__=='__main__':
     inputs=[10,100,1000,10000,50000,100000,200000,300000,400000,500000]

From e662a5aaefb6f236021c89e9d410519c2013efa0 Mon Sep 17 00:00:00 2001
From: Bruno Simas Hadlich <brunosimashadlich@gmail.com>
Date: Wed, 17 Jul 2019 15:32:04 -0300
Subject: [PATCH 123/348] Added Burrows-Wheeler transform algorithm. (#1029)

* Added doctest and more explanation about Dijkstra execution.

* tests were not passing with python2 due to missing __init__.py file at number_theory folder

* Removed the dot at the beginning of the imported modules names because 'python3 -m doctest -v data_structures/hashing/*.py' and 'python3 -m doctest -v data_structures/stacks/*.py' were failing not finding hash_table.py and stack.py modules.

* Moved global code to main scope and added doctest for project euler problems 1 to 14.

* Added test case for negative input.

* Changed N variable to do not use end of line scape because in case there is a space after it the script will break making it much more error prone.

* Added problems description and doctests to the ones that were missing. Limited line length to 79 and executed python black over all scripts.

* Changed the way files are loaded to support pytest call.

* Added __init__.py to problems to make them modules and allow pytest execution.

* Added project_euler folder to test units execution

* Changed 'os.path.split(os.path.realpath(__file__))' to 'os.path.dirname()'

* Added Burrows-Wheeler transform algorithm.

* Added changes suggested by cclauss
---
 compression/burrows_wheeler.py | 176 +++++++++++++++++++++++++++++++++
 1 file changed, 176 insertions(+)
 create mode 100644 compression/burrows_wheeler.py

diff --git a/compression/burrows_wheeler.py b/compression/burrows_wheeler.py
new file mode 100644
index 000000000000..fabeab39adf8
--- /dev/null
+++ b/compression/burrows_wheeler.py
@@ -0,0 +1,176 @@
+"""
+https://en.wikipedia.org/wiki/Burrows%E2%80%93Wheeler_transform
+
+The Burrows–Wheeler transform (BWT, also called block-sorting compression)
+rearranges a character string into runs of similar characters. This is useful
+for compression, since it tends to be easy to compress a string that has runs
+of repeated characters by techniques such as move-to-front transform and
+run-length encoding. More importantly, the transformation is reversible,
+without needing to store any additional data except the position of the first
+original character. The BWT is thus a "free" method of improving the efficiency
+of text compression algorithms, costing only some extra computation.
+"""
+from typing import List, Dict
+
+
+def all_rotations(s: str) -> List[str]:
+    """
+    :param s: The string that will be rotated len(s) times.
+    :return: A list with the rotations.
+    :raises TypeError: If s is not an instance of str.
+    Examples:
+
+    >>> all_rotations("^BANANA|") # doctest: +NORMALIZE_WHITESPACE
+    ['^BANANA|', 'BANANA|^', 'ANANA|^B', 'NANA|^BA', 'ANA|^BAN', 'NA|^BANA',
+    'A|^BANAN', '|^BANANA']
+    >>> all_rotations("a_asa_da_casa") # doctest: +NORMALIZE_WHITESPACE
+    ['a_asa_da_casa', '_asa_da_casaa', 'asa_da_casaa_', 'sa_da_casaa_a',
+    'a_da_casaa_as', '_da_casaa_asa', 'da_casaa_asa_', 'a_casaa_asa_d',
+    '_casaa_asa_da', 'casaa_asa_da_', 'asaa_asa_da_c', 'saa_asa_da_ca',
+    'aa_asa_da_cas']
+    >>> all_rotations("panamabanana") # doctest: +NORMALIZE_WHITESPACE
+    ['panamabanana', 'anamabananap', 'namabananapa', 'amabananapan',
+    'mabananapana', 'abananapanam', 'bananapanama', 'ananapanamab',
+    'nanapanamaba', 'anapanamaban', 'napanamabana', 'apanamabanan']
+    >>> all_rotations(5)
+    Traceback (most recent call last):
+        ...
+    TypeError: The parameter s type must be str.
+    """
+    if not isinstance(s, str):
+        raise TypeError("The parameter s type must be str.")
+
+    return [s[i:] + s[:i] for i in range(len(s))]
+
+
+def bwt_transform(s: str) -> Dict:
+    """
+    :param s: The string that will be used at bwt algorithm
+    :return: the string composed of the last char of each row of the ordered
+    rotations and the index of the original string at ordered rotations list
+    :raises TypeError: If the s parameter type is not str
+    :raises ValueError: If the s parameter is empty
+    Examples:
+
+    >>> bwt_transform("^BANANA")
+    {'bwt_string': 'BNN^AAA', 'idx_original_string': 6}
+    >>> bwt_transform("a_asa_da_casa")
+    {'bwt_string': 'aaaadss_c__aa', 'idx_original_string': 3}
+    >>> bwt_transform("panamabanana")
+    {'bwt_string': 'mnpbnnaaaaaa', 'idx_original_string': 11}
+    >>> bwt_transform(4)
+    Traceback (most recent call last):
+        ...
+    TypeError: The parameter s type must be str.
+    >>> bwt_transform('')
+    Traceback (most recent call last):
+        ...
+    ValueError: The parameter s must not be empty.
+    """
+    if not isinstance(s, str):
+        raise TypeError("The parameter s type must be str.")
+    if not s:
+        raise ValueError("The parameter s must not be empty.")
+
+    rotations = all_rotations(s)
+    rotations.sort()  # sort the list of rotations in alphabetically order
+    # make a string composed of the last char of each rotation
+    return {
+        "bwt_string": "".join([word[-1] for word in rotations]),
+        "idx_original_string": rotations.index(s),
+    }
+
+
+def reverse_bwt(bwt_string: str, idx_original_string: int) -> str:
+    """
+    :param bwt_string: The string returned from bwt algorithm execution
+    :param idx_original_string: A 0-based index of the string that was used to
+    generate bwt_string at ordered rotations list
+    :return: The string used to generate bwt_string when bwt was executed
+    :raises TypeError: If the bwt_string parameter type is not str
+    :raises ValueError: If the bwt_string parameter is empty
+    :raises TypeError: If the idx_original_string type is not int or if not
+    possible to cast it to int
+    :raises ValueError: If the idx_original_string value is lower than 0 or
+    greater than len(bwt_string) - 1
+
+    >>> reverse_bwt("BNN^AAA", 6)
+    '^BANANA'
+    >>> reverse_bwt("aaaadss_c__aa", 3)
+    'a_asa_da_casa'
+    >>> reverse_bwt("mnpbnnaaaaaa", 11)
+    'panamabanana'
+    >>> reverse_bwt(4, 11)
+    Traceback (most recent call last):
+        ...
+    TypeError: The parameter bwt_string type must be str.
+    >>> reverse_bwt("", 11)
+    Traceback (most recent call last):
+        ...
+    ValueError: The parameter bwt_string must not be empty.
+    >>> reverse_bwt("mnpbnnaaaaaa", "asd") # doctest: +NORMALIZE_WHITESPACE
+    Traceback (most recent call last):
+        ...
+    TypeError: The parameter idx_original_string type must be int or passive
+    of cast to int.
+    >>> reverse_bwt("mnpbnnaaaaaa", -1)
+    Traceback (most recent call last):
+        ...
+    ValueError: The parameter idx_original_string must not be lower than 0.
+    >>> reverse_bwt("mnpbnnaaaaaa", 12) # doctest: +NORMALIZE_WHITESPACE
+    Traceback (most recent call last):
+        ...
+    ValueError: The parameter idx_original_string must be lower than
+    len(bwt_string).
+    >>> reverse_bwt("mnpbnnaaaaaa", 11.0)
+    'panamabanana'
+    >>> reverse_bwt("mnpbnnaaaaaa", 11.4)
+    'panamabanana'
+    """
+    if not isinstance(bwt_string, str):
+        raise TypeError("The parameter bwt_string type must be str.")
+    if not bwt_string:
+        raise ValueError("The parameter bwt_string must not be empty.")
+    try:
+        idx_original_string = int(idx_original_string)
+    except ValueError:
+        raise TypeError(
+            (
+                "The parameter idx_original_string type must be int or passive"
+                " of cast to int."
+            )
+        )
+    if idx_original_string < 0:
+        raise ValueError(
+            "The parameter idx_original_string must not be lower than 0."
+        )
+    if idx_original_string >= len(bwt_string):
+        raise ValueError(
+            (
+                "The parameter idx_original_string must be lower than"
+                " len(bwt_string)."
+            )
+        )
+
+    ordered_rotations = [""] * len(bwt_string)
+    for x in range(len(bwt_string)):
+        for i in range(len(bwt_string)):
+            ordered_rotations[i] = bwt_string[i] + ordered_rotations[i]
+        ordered_rotations.sort()
+    return ordered_rotations[idx_original_string]
+
+
+if __name__ == "__main__":
+    entry_msg = "Provide a string that I will generate its BWT transform: "
+    s = input(entry_msg).strip()
+    result = bwt_transform(s)
+    bwt_output_msg = "Burrows Wheeler tranform for string '{}' results in '{}'"
+    print(bwt_output_msg.format(s, result["bwt_string"]))
+    original_string = reverse_bwt(
+        result["bwt_string"], result["idx_original_string"]
+    )
+    fmt = (
+        "Reversing Burrows Wheeler tranform for entry '{}' we get original"
+        " string '{}'"
+    )
+    print(fmt.format(result["bwt_string"], original_string))

From 4658f4a49e2bf9b13d806bd7dfc3df522056ad1c Mon Sep 17 00:00:00 2001
From: Jigyasa G <33327397+jpg-130@users.noreply.github.com>
Date: Thu, 18 Jul 2019 16:17:15 +0530
Subject: [PATCH 124/348] lgtm fixes (#1032)

* adding sum of subsets

* lgtm fixes
---
 project_euler/problem_07/sol2.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/project_euler/problem_07/sol2.py b/project_euler/problem_07/sol2.py
index 630e5196796d..3dc0b1343eb7 100644
--- a/project_euler/problem_07/sol2.py
+++ b/project_euler/problem_07/sol2.py
@@ -7,7 +7,6 @@
 We can see that the 6th prime is 13. What is the Nth prime number?
 """
 from __future__ import print_function
-from math import sqrt
 
 try:
     raw_input  # Python 2

From c2e8582abdf64c837c61c08cecdd5cbea222e290 Mon Sep 17 00:00:00 2001
From: cclauss <cclauss@me.com>
Date: Thu, 18 Jul 2019 13:10:52 +0200
Subject: [PATCH 125/348] Travis CI: Add pytest --doctest-modules
 neural_network (#1028)

* neural_network/perceptron.py: Add if __name__ == '__main__':

* Remove tab indentation

* Add neural_network to the pytests
---
 .travis.yml                  |  1 +
 neural_network/perceptron.py | 27 ++++++++++++++-------------
 2 files changed, 15 insertions(+), 13 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index 55ea2c7ddc24..6ac3010c5396 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -26,6 +26,7 @@ script:
       linear_algebra_python
       matrix
       networking_flow
+      neural_network
       other
       project_euler
       searches
diff --git a/neural_network/perceptron.py b/neural_network/perceptron.py
index eb8b04e855d3..787ea8f73bf1 100644
--- a/neural_network/perceptron.py
+++ b/neural_network/perceptron.py
@@ -1,12 +1,12 @@
 '''
 
-	Perceptron
-	w = w + N * (d(k) - y) * x(k)
+    Perceptron
+    w = w + N * (d(k) - y) * x(k)
 
-	Using perceptron network for oil analysis,
-	with Measuring of 3 parameters that represent chemical characteristics we can classify the oil, in p1 or p2
-	p1 = -1
-	p2 = 1
+    Using perceptron network for oil analysis,
+    with Measuring of 3 parameters that represent chemical characteristics we can classify the oil, in p1 or p2
+    p1 = -1
+    p2 = 1
 
 '''
 from __future__ import print_function
@@ -113,12 +113,13 @@ def sign(self, u):
 
 exit = [-1, -1, -1, 1, 1, -1, 1, -1, 1, 1, -1, 1, -1, -1, -1, -1, 1, 1, 1, 1, -1, 1, 1, 1, 1, -1, -1, 1, -1, 1]
 
-network = Perceptron(sample=samples, exit = exit, learn_rate=0.01, epoch_number=1000, bias=-1)
+if __name__ == '__main__':
+    network = Perceptron(sample=samples, exit = exit, learn_rate=0.01, epoch_number=1000, bias=-1)
 
-network.training()
+    network.training()
 
-while True:
-    sample = []
-    for i in range(3):
-        sample.insert(i, float(input('value: ')))
-    network.sort(sample)
+    while True:
+        sample = []
+        for i in range(3):
+            sample.insert(i, float(input('value: ').strip()))
+        network.sort(sample)

From 9a55f2b36a569f27a0893a79f0ba9cee23819557 Mon Sep 17 00:00:00 2001
From: cclauss <cclauss@me.com>
Date: Thu, 18 Jul 2019 18:15:54 +0200
Subject: [PATCH 126/348] Remove the space: lucas series.py --> lucas_series.py
 (#1036)

---
 maths/{lucas series.py => lucas_series.py} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename maths/{lucas series.py => lucas_series.py} (100%)

diff --git a/maths/lucas series.py b/maths/lucas_series.py
similarity index 100%
rename from maths/lucas series.py
rename to maths/lucas_series.py

From f438440ac54bbaad1557d5d8d2caa3331231f99b Mon Sep 17 00:00:00 2001
From: Bruno Simas Hadlich <brunosimashadlich@gmail.com>
Date: Thu, 18 Jul 2019 14:05:14 -0300
Subject: [PATCH 127/348] Fixes for issue "Fix the LGTM issues #1024" (#1034)

* Added doctest and more explanation about Dijkstra execution.

* tests were not passing with python2 due to missing __init__.py file at number_theory folder

* Removed the dot at the beginning of the imported modules names because 'python3 -m doctest -v data_structures/hashing/*.py' and 'python3 -m doctest -v data_structures/stacks/*.py' were failing not finding hash_table.py and stack.py modules.

* Moved global code to main scope and added doctest for project euler problems 1 to 14.

* Added test case for negative input.

* Changed N variable to do not use end of line scape because in case there is a space after it the script will break making it much more error prone.

* Added problems description and doctests to the ones that were missing. Limited line length to 79 and executed python black over all scripts.

* Changed the way files are loaded to support pytest call.

* Added __init__.py to problems to make them modules and allow pytest execution.

* Added project_euler folder to test units execution

* Changed 'os.path.split(os.path.realpath(__file__))' to 'os.path.dirname()'

* Added Burrows-Wheeler transform algorithm.

* Added changes suggested by cclauss

* Fixes for issue 'Fix the LGTM issues #1024'.

* Added doctest for different parameter types and negative values.

* Fixed doctest issue added at last commit.
---
 project_euler/problem_02/sol4.py  | 26 +++++++++++++++++++++++++-
 project_euler/problem_03/sol1.py  | 27 +++++++++++++++++++++++++--
 project_euler/problem_03/sol2.py  | 27 +++++++++++++++++++++++++--
 project_euler/problem_05/sol1.py  | 27 +++++++++++++++++++++++++--
 project_euler/problem_07/sol2.py  | 24 ++++++++++++++++++++++++
 project_euler/problem_09/sol1.py  |  1 -
 project_euler/problem_19/sol1.py  |  2 +-
 project_euler/problem_234/sol1.py |  1 -
 8 files changed, 125 insertions(+), 10 deletions(-)

diff --git a/project_euler/problem_02/sol4.py b/project_euler/problem_02/sol4.py
index ba13b12a15e9..5e8c04899f3d 100644
--- a/project_euler/problem_02/sol4.py
+++ b/project_euler/problem_02/sol4.py
@@ -11,7 +11,7 @@
 """
 from __future__ import print_function
 import math
-from decimal import *
+from decimal import Decimal, getcontext
 
 try:
     raw_input  # Python 2
@@ -33,7 +33,31 @@ def solution(n):
     0
     >>> solution(34)
     44
+    >>> solution(3.4)
+    2
+    >>> solution(0)
+    Traceback (most recent call last):
+        ...
+    ValueError: Parameter n must be greater or equal to one.
+    >>> solution(-17)
+    Traceback (most recent call last):
+        ...
+    ValueError: Parameter n must be greater or equal to one.
+    >>> solution([])
+    Traceback (most recent call last):
+        ...
+    TypeError: Parameter n must be int or passive of cast to int.
+    >>> solution("asd")
+    Traceback (most recent call last):
+        ...
+    TypeError: Parameter n must be int or passive of cast to int.
     """
+    try:
+        n = int(n)
+    except (TypeError, ValueError) as e:
+        raise TypeError("Parameter n must be int or passive of cast to int.")
+    if n <= 0:
+        raise ValueError("Parameter n must be greater or equal to one.")
     getcontext().prec = 100
     phi = (Decimal(5) ** Decimal(0.5) + 1) / Decimal(2)
 
diff --git a/project_euler/problem_03/sol1.py b/project_euler/problem_03/sol1.py
index c2e601bd0040..ab19d8b30457 100644
--- a/project_euler/problem_03/sol1.py
+++ b/project_euler/problem_03/sol1.py
@@ -28,14 +28,38 @@ def isprime(no):
 
 def solution(n):
     """Returns the largest prime factor of a given number n.
-    
+
     >>> solution(13195)
     29
     >>> solution(10)
     5
     >>> solution(17)
     17
+    >>> solution(3.4)
+    3
+    >>> solution(0)
+    Traceback (most recent call last):
+        ...
+    ValueError: Parameter n must be greater or equal to one.
+    >>> solution(-17)
+    Traceback (most recent call last):
+        ...
+    ValueError: Parameter n must be greater or equal to one.
+    >>> solution([])
+    Traceback (most recent call last):
+        ...
+    TypeError: Parameter n must be int or passive of cast to int.
+    >>> solution("asd")
+    Traceback (most recent call last):
+        ...
+    TypeError: Parameter n must be int or passive of cast to int.
     """
+    try:
+        n = int(n)
+    except (TypeError, ValueError) as e:
+        raise TypeError("Parameter n must be int or passive of cast to int.")
+    if n <= 0:
+        raise ValueError("Parameter n must be greater or equal to one.")
     maxNumber = 0
     if isprime(n):
         return n
@@ -54,7 +78,6 @@ def solution(n):
                     elif isprime(i):
                         maxNumber = i
             return maxNumber
-    return int(sum)
 
 
 if __name__ == "__main__":
diff --git a/project_euler/problem_03/sol2.py b/project_euler/problem_03/sol2.py
index 497db3965cc3..f93a0b75f4e0 100644
--- a/project_euler/problem_03/sol2.py
+++ b/project_euler/problem_03/sol2.py
@@ -6,7 +6,6 @@
 e.g. for 10, largest prime factor = 5. For 17, largest prime factor = 17.
 """
 from __future__ import print_function, division
-import math
 
 try:
     raw_input  # Python 2
@@ -16,14 +15,38 @@
 
 def solution(n):
     """Returns the largest prime factor of a given number n.
-    
+
     >>> solution(13195)
     29
     >>> solution(10)
     5
     >>> solution(17)
     17
+    >>> solution(3.4)
+    3
+    >>> solution(0)
+    Traceback (most recent call last):
+        ...
+    ValueError: Parameter n must be greater or equal to one.
+    >>> solution(-17)
+    Traceback (most recent call last):
+        ...
+    ValueError: Parameter n must be greater or equal to one.
+    >>> solution([])
+    Traceback (most recent call last):
+        ...
+    TypeError: Parameter n must be int or passive of cast to int.
+    >>> solution("asd")
+    Traceback (most recent call last):
+        ...
+    TypeError: Parameter n must be int or passive of cast to int.
     """
+    try:
+        n = int(n)
+    except (TypeError, ValueError) as e:
+        raise TypeError("Parameter n must be int or passive of cast to int.")
+    if n <= 0:
+        raise ValueError("Parameter n must be greater or equal to one.")
     prime = 1
     i = 2
     while i * i <= n:
diff --git a/project_euler/problem_05/sol1.py b/project_euler/problem_05/sol1.py
index 609f02102a08..e2deb91fb6aa 100644
--- a/project_euler/problem_05/sol1.py
+++ b/project_euler/problem_05/sol1.py
@@ -17,7 +17,7 @@
 def solution(n):
     """Returns the smallest positive number that is evenly divisible(divisible
     with no remainder) by all of the numbers from 1 to n.
-    
+
     >>> solution(10)
     2520
     >>> solution(15)
@@ -26,7 +26,31 @@ def solution(n):
     232792560
     >>> solution(22)
     232792560
+    >>> solution(3.4)
+    6
+    >>> solution(0)
+    Traceback (most recent call last):
+        ...
+    ValueError: Parameter n must be greater or equal to one.
+    >>> solution(-17)
+    Traceback (most recent call last):
+        ...
+    ValueError: Parameter n must be greater or equal to one.
+    >>> solution([])
+    Traceback (most recent call last):
+        ...
+    TypeError: Parameter n must be int or passive of cast to int.
+    >>> solution("asd")
+    Traceback (most recent call last):
+        ...
+    TypeError: Parameter n must be int or passive of cast to int.
     """
+    try:
+        n = int(n)
+    except (TypeError, ValueError) as e:
+        raise TypeError("Parameter n must be int or passive of cast to int.")
+    if n <= 0:
+        raise ValueError("Parameter n must be greater or equal to one.")
     i = 0
     while 1:
         i += n * (n - 1)
@@ -39,7 +63,6 @@ def solution(n):
             if i == 0:
                 i = 1
             return i
-            break
 
 
 if __name__ == "__main__":
diff --git a/project_euler/problem_07/sol2.py b/project_euler/problem_07/sol2.py
index 3dc0b1343eb7..67336f7c1c96 100644
--- a/project_euler/problem_07/sol2.py
+++ b/project_euler/problem_07/sol2.py
@@ -36,7 +36,31 @@ def solution(n):
     229
     >>> solution(100)
     541
+    >>> solution(3.4)
+    5
+    >>> solution(0)
+    Traceback (most recent call last):
+        ...
+    ValueError: Parameter n must be greater or equal to one.
+    >>> solution(-17)
+    Traceback (most recent call last):
+        ...
+    ValueError: Parameter n must be greater or equal to one.
+    >>> solution([])
+    Traceback (most recent call last):
+        ...
+    TypeError: Parameter n must be int or passive of cast to int.
+    >>> solution("asd")
+    Traceback (most recent call last):
+        ...
+    TypeError: Parameter n must be int or passive of cast to int.
     """
+    try:
+        n = int(n)
+    except (TypeError, ValueError) as e:
+        raise TypeError("Parameter n must be int or passive of cast to int.")
+    if n <= 0:
+        raise ValueError("Parameter n must be greater or equal to one.")
     primes = []
     num = 2
     while len(primes) < n:
diff --git a/project_euler/problem_09/sol1.py b/project_euler/problem_09/sol1.py
index 0f368e48d2e3..20dedb84bc0e 100644
--- a/project_euler/problem_09/sol1.py
+++ b/project_euler/problem_09/sol1.py
@@ -28,7 +28,6 @@ def solution():
                     if (a ** 2) + (b ** 2) == (c ** 2):
                         if (a + b + c) == 1000:
                             return a * b * c
-                            break
 
 
 if __name__ == "__main__":
diff --git a/project_euler/problem_19/sol1.py b/project_euler/problem_19/sol1.py
index 6e4e29ec19c6..ab59365843b2 100644
--- a/project_euler/problem_19/sol1.py
+++ b/project_euler/problem_19/sol1.py
@@ -61,4 +61,4 @@ def solution():
 
 
 if __name__ == "__main__":
-    print(solution(171))
+    print(solution())
diff --git a/project_euler/problem_234/sol1.py b/project_euler/problem_234/sol1.py
index 8298a7f8cce3..c0d2949285e9 100644
--- a/project_euler/problem_234/sol1.py
+++ b/project_euler/problem_234/sol1.py
@@ -40,7 +40,6 @@ def solution(n):
     semidivisible = []
     for x in range(n):
         l=[i for i in input().split()]
-        c1=0
         c2=1
         while(1):
             if len(fib(l[0],l[1],c2))<int(l[2]):

From 9f8953dc0c39452bf6dccb76644bcb054d023dfb Mon Sep 17 00:00:00 2001
From: thiru15 <33665749+thiru15@users.noreply.github.com>
Date: Fri, 19 Jul 2019 03:10:51 +0530
Subject: [PATCH 128/348] Update find_lcm.py (#1019)

* Update find_lcm.py

Improved code quality and added comments.

* Make the doctests work
---
 maths/find_lcm.py | 17 +++++++++++++----
 1 file changed, 13 insertions(+), 4 deletions(-)

diff --git a/maths/find_lcm.py b/maths/find_lcm.py
index 9062d462b8b3..f7ac958070b5 100644
--- a/maths/find_lcm.py
+++ b/maths/find_lcm.py
@@ -4,8 +4,17 @@
 
 
 def find_lcm(num_1, num_2):
-    """Find the LCM of two numbers."""
-    max_num = num_1 if num_1 > num_2 else num_2
+    """Find the least common multiple of two numbers.
+       >>> find_lcm(5,2)
+       10
+       >>> find_lcm(12,76)
+       228
+    """
+    if num_1>=num_2:
+        max_num=num_1
+    else:
+        max_num=num_2
+    
     lcm = max_num
     while True:
         if ((lcm % num_1 == 0) and (lcm % num_2 == 0)):
@@ -16,8 +25,8 @@ def find_lcm(num_1, num_2):
 
 def main():
     """Use test numbers to run the find_lcm algorithm."""
-    num_1 = 12
-    num_2 = 76
+    num_1 = int(input().strip()) 
+    num_2 = int(input().strip()) 
     print(find_lcm(num_1, num_2))
 
 

From f7ac8b5ed054198bdb254635e8f06c6f219c2f75 Mon Sep 17 00:00:00 2001
From: Bruno Simas Hadlich <brunosimashadlich@gmail.com>
Date: Thu, 18 Jul 2019 19:34:29 -0300
Subject: [PATCH 129/348] Commented doctests that were causing slowness at
 Travis. (#1039)

* Added doctest and more explanation about Dijkstra execution.

* tests were not passing with python2 due to missing __init__.py file at number_theory folder

* Removed the dot at the beginning of the imported modules names because 'python3 -m doctest -v data_structures/hashing/*.py' and 'python3 -m doctest -v data_structures/stacks/*.py' were failing not finding hash_table.py and stack.py modules.

* Moved global code to main scope and added doctest for project euler problems 1 to 14.

* Added test case for negative input.

* Changed N variable to do not use end of line scape because in case there is a space after it the script will break making it much more error prone.

* Added problems description and doctests to the ones that were missing. Limited line length to 79 and executed python black over all scripts.

* Changed the way files are loaded to support pytest call.

* Added __init__.py to problems to make them modules and allow pytest execution.

* Added project_euler folder to test units execution

* Changed 'os.path.split(os.path.realpath(__file__))' to 'os.path.dirname()'

* Added Burrows-Wheeler transform algorithm.

* Added changes suggested by cclauss

* Fixes for issue 'Fix the LGTM issues #1024'.

* Added doctest for different parameter types and negative values.

* Fixed doctest issue added at last commit.

* Commented doctest that were causing slowness at Travis.

* Added comment with the reason for some doctest commented.

* pytest --ignore
---
 .travis.yml                      | 38 +++++++++++---------------------
 project_euler/problem_09/sol1.py |  5 +++--
 project_euler/problem_09/sol3.py |  4 ++--
 project_euler/problem_10/sol1.py |  5 +++--
 project_euler/problem_10/sol2.py |  5 +++--
 project_euler/problem_12/sol1.py |  5 +++--
 project_euler/problem_12/sol2.py |  5 +++--
 project_euler/problem_14/sol1.py |  5 +++--
 project_euler/problem_14/sol2.py |  5 +++--
 9 files changed, 36 insertions(+), 41 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index 6ac3010c5396..a3ff22fb09b7 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -9,31 +9,19 @@ before_script:
   - flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
 script:
   - mypy --ignore-missing-imports .
-  #- IGNORE="data_structures,file_transfer_protocol,graphs,machine_learning,maths,neural_network,project_euler"
-  #- pytest . --doctest-modules --ignore=${IGNORE}
-  - pytest --doctest-modules
-      arithmetic_analysis
-      backtracking
-      boolean_algebra
-      ciphers
-      compression
-      conversions
-      digital_image_processing
-      divide_and_conquer
-      dynamic_programming
-      graphs
-      hashes
-      linear_algebra_python
-      matrix
-      networking_flow
-      neural_network
-      other
-      project_euler
-      searches
-      sorts
-      strings
-      traversals
-
+  - pytest . --doctest-modules
+      --ignore=data_structures/stacks/balanced_parentheses.py
+      --ignore=data_structures/stacks/infix_to_postfix_conversion.py
+      --ignore=file_transfer_protocol/ftp_send_receive.py
+      --ignore=file_transfer_protocol/ftp_client_server.py
+      --ignore=machine_learning/linear_regression.py
+      --ignore=machine_learning/perceptron.py
+      --ignore=machine_learning/random_forest_classification/random_forest_classification.py
+      --ignore=machine_learning/random_forest_regression/random_forest_regression.py
+      --ignore=maths/abs_min.py
+      --ignore=maths/binary_exponentiation.py
+      --ignore=maths/lucas_series.py
+      --ignore=maths/sieve_of_eratosthenes.py
 after_success:
   - python scripts/build_directory_md.py
   - cat DIRECTORY.md
diff --git a/project_euler/problem_09/sol1.py b/project_euler/problem_09/sol1.py
index 20dedb84bc0e..d9ebe8760861 100644
--- a/project_euler/problem_09/sol1.py
+++ b/project_euler/problem_09/sol1.py
@@ -18,8 +18,9 @@ def solution():
      2. a**2 + b**2 = c**2
      3. a + b + c = 1000
     
-    >>> solution()
-    31875000
+    # The code below has been commented due to slow execution affecting Travis.
+    # >>> solution()
+    # 31875000
     """
     for a in range(300):
         for b in range(400):
diff --git a/project_euler/problem_09/sol3.py b/project_euler/problem_09/sol3.py
index f749b8a61f11..829ba84c4a77 100644
--- a/project_euler/problem_09/sol3.py
+++ b/project_euler/problem_09/sol3.py
@@ -21,8 +21,8 @@ def solution():
      1. a**2 + b**2 = c**2
      2. a + b + c = 1000
 
-    >>> solution()
-    31875000
+    #>>> solution()
+    #31875000
     """
     return [
         a * b * c
diff --git a/project_euler/problem_10/sol1.py b/project_euler/problem_10/sol1.py
index 038da96e6352..49384d7c78f0 100644
--- a/project_euler/problem_10/sol1.py
+++ b/project_euler/problem_10/sol1.py
@@ -42,8 +42,9 @@ def sum_of_primes(n):
 def solution(n):
     """Returns the sum of all the primes below n.
     
-    >>> solution(2000000)
-    142913828922
+    # The code below has been commented due to slow execution affecting Travis.
+    # >>> solution(2000000)
+    # 142913828922
     >>> solution(1000)
     76127
     >>> solution(5000)
diff --git a/project_euler/problem_10/sol2.py b/project_euler/problem_10/sol2.py
index 9e51d61b8749..451a4ae5e8f3 100644
--- a/project_euler/problem_10/sol2.py
+++ b/project_euler/problem_10/sol2.py
@@ -31,8 +31,9 @@ def prime_generator():
 def solution(n):
     """Returns the sum of all the primes below n.
     
-    >>> solution(2000000)
-    142913828922
+    # The code below has been commented due to slow execution affecting Travis.
+    # >>> solution(2000000)
+    # 142913828922
     >>> solution(1000)
     76127
     >>> solution(5000)
diff --git a/project_euler/problem_12/sol1.py b/project_euler/problem_12/sol1.py
index baf9babab686..54476110b503 100644
--- a/project_euler/problem_12/sol1.py
+++ b/project_euler/problem_12/sol1.py
@@ -45,8 +45,9 @@ def solution():
     """Returns the value of the first triangle number to have over five hundred
     divisors.
     
-    >>> solution()
-    76576500
+    # The code below has been commented due to slow execution affecting Travis.
+    # >>> solution()
+    # 76576500
     """
     tNum = 1
     i = 1
diff --git a/project_euler/problem_12/sol2.py b/project_euler/problem_12/sol2.py
index 071d7516ac0f..0d1502830bee 100644
--- a/project_euler/problem_12/sol2.py
+++ b/project_euler/problem_12/sol2.py
@@ -39,8 +39,9 @@ def solution():
     """Returns the value of the first triangle number to have over five hundred
     divisors.
     
-    >>> solution()
-    76576500
+    # The code below has been commented due to slow execution affecting Travis.
+    # >>> solution()
+    # 76576500
     """
     return next(
         i for i in triangle_number_generator() if count_divisors(i) > 500
diff --git a/project_euler/problem_14/sol1.py b/project_euler/problem_14/sol1.py
index 6b80cd7cb24b..8d3efbc59eb5 100644
--- a/project_euler/problem_14/sol1.py
+++ b/project_euler/problem_14/sol1.py
@@ -30,8 +30,9 @@ def solution(n):
     n → n/2 (n is even)
     n → 3n + 1 (n is odd)
  
-    >>> solution(1000000)
-    {'counter': 525, 'largest_number': 837799}
+    # The code below has been commented due to slow execution affecting Travis.
+    # >>> solution(1000000)
+    # {'counter': 525, 'largest_number': 837799}
     >>> solution(200)
     {'counter': 125, 'largest_number': 171}
     >>> solution(5000)
diff --git a/project_euler/problem_14/sol2.py b/project_euler/problem_14/sol2.py
index 59fa79515148..0ec80e221f09 100644
--- a/project_euler/problem_14/sol2.py
+++ b/project_euler/problem_14/sol2.py
@@ -47,8 +47,9 @@ def collatz_sequence(n):
 def solution(n):
     """Returns the number under n that generates the longest Collatz sequence.
 
-    >>> solution(1000000)
-    {'counter': 525, 'largest_number': 837799}
+    # The code below has been commented due to slow execution affecting Travis.
+    # >>> solution(1000000)
+    # {'counter': 525, 'largest_number': 837799}
     >>> solution(200)
     {'counter': 125, 'largest_number': 171}
     >>> solution(5000)

From 9fcfe6a02bca94664189a656cf76bd425bbf3417 Mon Sep 17 00:00:00 2001
From: Bruno Simas Hadlich <brunosimashadlich@gmail.com>
Date: Fri, 19 Jul 2019 01:33:28 -0300
Subject: [PATCH 130/348] Commented doctests that were causing slowness at
 Travis. #2 (#1041)

* Added doctest and more explanation about Dijkstra execution.

* tests were not passing with python2 due to missing __init__.py file at number_theory folder

* Removed the dot at the beginning of the imported modules names because 'python3 -m doctest -v data_structures/hashing/*.py' and 'python3 -m doctest -v data_structures/stacks/*.py' were failing not finding hash_table.py and stack.py modules.

* Moved global code to main scope and added doctest for project euler problems 1 to 14.

* Added test case for negative input.

* Changed N variable to do not use end of line scape because in case there is a space after it the script will break making it much more error prone.

* Added problems description and doctests to the ones that were missing. Limited line length to 79 and executed python black over all scripts.

* Changed the way files are loaded to support pytest call.

* Added __init__.py to problems to make them modules and allow pytest execution.

* Added project_euler folder to test units execution

* Changed 'os.path.split(os.path.realpath(__file__))' to 'os.path.dirname()'

* Added Burrows-Wheeler transform algorithm.

* Added changes suggested by cclauss

* Fixes for issue 'Fix the LGTM issues #1024'.

* Added doctest for different parameter types and negative values.

* Fixed doctest issue added at last commit.

* Commented doctest that were causing slowness at Travis.

* Added comment with the reason for some doctest commented.

* pytest --ignore

* Added tests execution again.

* Had forgotten to add comment to file project_euler/problem_09/sol3.py
---
 project_euler/problem_09/sol3.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/project_euler/problem_09/sol3.py b/project_euler/problem_09/sol3.py
index 829ba84c4a77..006029c8a30d 100644
--- a/project_euler/problem_09/sol3.py
+++ b/project_euler/problem_09/sol3.py
@@ -21,8 +21,9 @@ def solution():
      1. a**2 + b**2 = c**2
      2. a + b + c = 1000
 
-    #>>> solution()
-    #31875000
+    # The code below has been commented due to slow execution affecting Travis.
+    # >>> solution()
+    # 31875000
     """
     return [
         a * b * c

From 60c608d85a41f85f795233b5ff913ca35f8a2f92 Mon Sep 17 00:00:00 2001
From: "Md. Mahbubur Rahman" <mahbuburrahman2111@gmail.com>
Date: Fri, 19 Jul 2019 16:41:37 +0900
Subject: [PATCH 131/348] Added matrix exponentiation approach for finding
 fibonacci number. (#1042)

* Added matrix exponentiation approach for finding fibonacci number.

* Implemented the way of finding nth fibonacci.
* Complexity is about O(log(n)*8)

* Updated the matrix exponentiation approach of finding nth fibonacci.

- Removed some extra spaces
- Added the complexity of bruteforce algorithm
- Removed unused function called zerro()
- Added some docktest based on request

* Updated the matrix exponentiation approach of finding nth fibonacci.

- Removed some extra spaces
- Added the complexity of bruteforce algorithm
- Removed unused function called zerro()
- Added some docktest based on request

* Tighten up main() and add comments on performance
---
 ...h_fibonacci_using_matrix_exponentiation.py | 88 +++++++++++++++++++
 1 file changed, 88 insertions(+)
 create mode 100644 matrix/nth_fibonacci_using_matrix_exponentiation.py

diff --git a/matrix/nth_fibonacci_using_matrix_exponentiation.py b/matrix/nth_fibonacci_using_matrix_exponentiation.py
new file mode 100644
index 000000000000..cee6b21c81eb
--- /dev/null
+++ b/matrix/nth_fibonacci_using_matrix_exponentiation.py
@@ -0,0 +1,88 @@
+"""
+Implementation of finding nth fibonacci number using matrix exponentiation.
+Time Complexity is about O(log(n)*8), where 8 is the complexity of matrix multiplication of size 2 by 2.
+And on the other hand complexity of bruteforce solution is O(n).
+As we know
+    f[n] = f[n-1] + f[n-1]
+Converting to matrix,
+    [f(n),f(n-1)] = [[1,1],[1,0]] * [f(n-1),f(n-2)]
+->  [f(n),f(n-1)] = [[1,1],[1,0]]^2 * [f(n-2),f(n-3)]
+    ...
+    ...
+->  [f(n),f(n-1)] = [[1,1],[1,0]]^(n-1) * [f(1),f(0)]
+So we just need the n times multiplication of the matrix [1,1],[1,0]].
+We can decrease the n times multiplication by following the divide and conquer approach.
+"""
+from __future__ import print_function
+
+
+def multiply(matrix_a, matrix_b):
+    matrix_c = []
+    n = len(matrix_a)
+    for i in range(n):
+        list_1 = []
+        for j in range(n):
+            val = 0
+            for k in range(n):
+                val = val + matrix_a[i][k] * matrix_b[k][j]
+            list_1.append(val)
+        matrix_c.append(list_1)
+    return matrix_c
+
+
+def identity(n):
+    return [[int(row == column) for column in range(n)] for row in range(n)]
+
+
+def nth_fibonacci_matrix(n):
+    """
+    >>> nth_fibonacci_matrix(100)
+    354224848179261915075
+    >>> nth_fibonacci_matrix(-100)
+    -100
+    """
+    if n <= 1:
+        return n
+    res_matrix = identity(2)
+    fibonacci_matrix = [[1, 1], [1, 0]]
+    n = n - 1
+    while n > 0:
+        if n % 2 == 1:
+            res_matrix = multiply(res_matrix, fibonacci_matrix)
+        fibonacci_matrix = multiply(fibonacci_matrix, fibonacci_matrix)
+        n = int(n / 2)
+    return res_matrix[0][0]
+
+
+def nth_fibonacci_bruteforce(n):
+    """
+    >>> nth_fibonacci_bruteforce(100)
+    354224848179261915075
+    >>> nth_fibonacci_bruteforce(-100)
+    -100
+    """
+    if n <= 1:
+        return n
+    fib0 = 0
+    fib1 = 1
+    for i in range(2, n + 1):
+        fib0, fib1 = fib1, fib0 + fib1
+    return fib1
+
+
+def main():
+    fmt = "{} fibonacci number using matrix exponentiation is {} and using bruteforce is {}\n"
+    for ordinal in "0th 1st 2nd 3rd 10th 100th 1000th".split():
+        n = int("".join(c for c in ordinal if c in "0123456789"))  # 1000th --> 1000
+        print(fmt.format(ordinal, nth_fibonacci(n), nth_fibonacci_test(n)))
+    # from timeit import timeit
+    # print(timeit("nth_fibonacci_matrix(1000000)",
+    #              "from main import nth_fibonacci_matrix", number=5))
+    # print(timeit("nth_fibonacci_bruteforce(1000000)",
+    #              "from main import nth_fibonacci_bruteforce", number=5))
+    # 2.3342058970001744
+    # 57.256506615000035
+
+
+if __name__ == "__main__":
+    main()

From dc1de946eabe20053b811b50e0e1d50697bd46fa Mon Sep 17 00:00:00 2001
From: cclauss <cclauss@me.com>
Date: Fri, 19 Jul 2019 10:55:45 +0200
Subject: [PATCH 132/348] Use correct function names in
 nth_fibonacci_using_matrix_exponentiation.py (#1045)

@AnupKumarPanwar @ParthS007 @poyea Could I please get a quick review on this one because I made a mistake here that breaks the build for new pull requests.
---
 matrix/nth_fibonacci_using_matrix_exponentiation.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/matrix/nth_fibonacci_using_matrix_exponentiation.py b/matrix/nth_fibonacci_using_matrix_exponentiation.py
index cee6b21c81eb..7491abcae031 100644
--- a/matrix/nth_fibonacci_using_matrix_exponentiation.py
+++ b/matrix/nth_fibonacci_using_matrix_exponentiation.py
@@ -74,7 +74,7 @@ def main():
     fmt = "{} fibonacci number using matrix exponentiation is {} and using bruteforce is {}\n"
     for ordinal in "0th 1st 2nd 3rd 10th 100th 1000th".split():
         n = int("".join(c for c in ordinal if c in "0123456789"))  # 1000th --> 1000
-        print(fmt.format(ordinal, nth_fibonacci(n), nth_fibonacci_test(n)))
+        print(fmt.format(ordinal, nth_fibonacci_matrix(n), nth_fibonacci_bruteforce(n)))
     # from timeit import timeit
     # print(timeit("nth_fibonacci_matrix(1000000)",
     #              "from main import nth_fibonacci_matrix", number=5))

From 4e0717c3cfb336aa86f6720f2f49adf58f0e95d7 Mon Sep 17 00:00:00 2001
From: Stephen Gemin <45926479+StephenGemin@users.noreply.github.com>
Date: Fri, 19 Jul 2019 23:06:29 -0400
Subject: [PATCH 133/348] Add error & test checks for matrix_operations.py
 (#925)

* Update matrix_operation.py

1. Adding error checks for integer inputs
2. Adding error checks for matrix operations where size requirements do not match up
3. Added matrix subtraction function
4. included error check so only integer is passed into identity function

* Create test_matrix_operation.py

* Update matrix_ops and Add Test Cases

1. Included error checks in matrix operation.  There were some cases where the functions would not work correctly.

2. PEP8 changes to matrix_operations.py

3. added test cases for matrix operations using pytest.

* Update pytest.ini

Add carriage return to end of file
---
 matrix/matrix_operation.py            | 136 +++++++++++++++++++-------
 matrix/tests/pytest.ini               |   3 +
 matrix/tests/test_matrix_operation.py | 112 +++++++++++++++++++++
 3 files changed, 217 insertions(+), 34 deletions(-)
 create mode 100644 matrix/tests/pytest.ini
 create mode 100644 matrix/tests/test_matrix_operation.py

diff --git a/matrix/matrix_operation.py b/matrix/matrix_operation.py
index dd7c01582681..b32a4dcf7af3 100644
--- a/matrix/matrix_operation.py
+++ b/matrix/matrix_operation.py
@@ -1,64 +1,131 @@
-from __future__ import print_function
+"""
+function based version of matrix operations, which are just 2D arrays
+"""
+
 
 def add(matrix_a, matrix_b):
-    rows = len(matrix_a)
-    columns = len(matrix_a[0])
-    matrix_c = []
-    for i in range(rows):
-        list_1 = []
-        for j in range(columns):
-            val = matrix_a[i][j] + matrix_b[i][j]
-            list_1.append(val)
-        matrix_c.append(list_1)
-    return matrix_c
-
-def scalarMultiply(matrix , n):
+    if _check_not_integer(matrix_a) and _check_not_integer(matrix_b):
+        rows, cols = _verify_matrix_sizes(matrix_a, matrix_b)
+        matrix_c = []
+        for i in range(rows[0]):
+            list_1 = []
+            for j in range(cols[0]):
+                val = matrix_a[i][j] + matrix_b[i][j]
+                list_1.append(val)
+            matrix_c.append(list_1)
+        return matrix_c
+
+
+def subtract(matrix_a, matrix_b):
+    if _check_not_integer(matrix_a) and _check_not_integer(matrix_b):
+        rows, cols = _verify_matrix_sizes(matrix_a, matrix_b)
+        matrix_c = []
+        for i in range(rows[0]):
+            list_1 = []
+            for j in range(cols[0]):
+                val = matrix_a[i][j] - matrix_b[i][j]
+                list_1.append(val)
+            matrix_c.append(list_1)
+        return matrix_c
+
+
+def scalar_multiply(matrix, n):
     return [[x * n for x in row] for row in matrix]
 
+
 def multiply(matrix_a, matrix_b):
-    matrix_c = []
-    n = len(matrix_a)
-    for i in range(n):
-        list_1 = []
-        for j in range(n):
-            val = 0
-            for k in range(n):
-                val = val + matrix_a[i][k] * matrix_b[k][j]
-            list_1.append(val)
-        matrix_c.append(list_1)
-    return matrix_c
+    if _check_not_integer(matrix_a) and _check_not_integer(matrix_b):
+        matrix_c = []
+        rows, cols = _verify_matrix_sizes(matrix_a, matrix_b)
+
+        if cols[0] != rows[1]:
+            raise ValueError(f'Cannot multiply matrix of dimensions ({rows[0]},{cols[0]}) '
+                             f'and ({rows[1]},{cols[1]})')
+        for i in range(rows[0]):
+            list_1 = []
+            for j in range(cols[1]):
+                val = 0
+                for k in range(cols[1]):
+                    val = val + matrix_a[i][k] * matrix_b[k][j]
+                list_1.append(val)
+            matrix_c.append(list_1)
+        return matrix_c
+
 
 def identity(n):
+    """
+    :param n: dimension for nxn matrix
+    :type n: int
+    :return: Identity matrix of shape [n, n]
+    """
+    n = int(n)
     return [[int(row == column) for column in range(n)] for row in range(n)] 
 
-def transpose(matrix):
-    return map(list , zip(*matrix))
+
+def transpose(matrix, return_map=True):
+    if _check_not_integer(matrix):
+        if return_map:
+            return map(list, zip(*matrix))
+        else:
+            # mt = []
+            # for i in range(len(matrix[0])):
+            #     mt.append([row[i] for row in matrix])
+            # return mt
+            return [[row[i] for row in matrix] for i in range(len(matrix[0]))]
+
 
 def minor(matrix, row, column):
     minor = matrix[:row] + matrix[row + 1:]
     minor = [row[:column] + row[column + 1:] for row in minor]
     return minor
 
+
 def determinant(matrix):
-    if len(matrix) == 1: return matrix[0][0]
+    if len(matrix) == 1:
+        return matrix[0][0]
     
     res = 0
     for x in range(len(matrix)):
-        res += matrix[0][x] * determinant(minor(matrix , 0 , x)) * (-1) ** x
+        res += matrix[0][x] * determinant(minor(matrix, 0, x)) * (-1) ** x
     return res
 
+
 def inverse(matrix):
     det = determinant(matrix)
-    if det == 0: return None
+    if det == 0:
+        return None
 
-    matrixMinor = [[] for _ in range(len(matrix))]
+    matrix_minor = [[] for _ in range(len(matrix))]
     for i in range(len(matrix)):
         for j in range(len(matrix)):
-            matrixMinor[i].append(determinant(minor(matrix , i , j)))
+            matrix_minor[i].append(determinant(minor(matrix, i, j)))
     
-    cofactors = [[x * (-1) ** (row + col) for col, x in enumerate(matrixMinor[row])] for row in range(len(matrix))]
+    cofactors = [[x * (-1) ** (row + col) for col, x in enumerate(matrix_minor[row])] for row in range(len(matrix))]
     adjugate = transpose(cofactors)
-    return scalarMultiply(adjugate , 1/det)
+    return scalar_multiply(adjugate, 1/det)
+
+
+def _check_not_integer(matrix):
+    try:
+        rows = len(matrix)
+        cols = len(matrix[0])
+        return True
+    except TypeError:
+        raise TypeError("Cannot input an integer value, it must be a matrix")
+
+
+def _shape(matrix):
+    return list((len(matrix), len(matrix[0])))
+
+
+def _verify_matrix_sizes(matrix_a, matrix_b):
+    shape = _shape(matrix_a)
+    shape += _shape(matrix_b)
+    if shape[0] != shape[2] or shape[1] != shape[3]:
+        raise ValueError(f"operands could not be broadcast together with shape "
+                         f"({shape[0], shape[1]}), ({shape[2], shape[3]})")
+    return [shape[0], shape[2]], [shape[1], shape[3]]
+
 
 def main():
     matrix_a = [[12, 10], [3, 9]]
@@ -68,9 +135,10 @@ def main():
     print('Add Operation, %s + %s = %s \n' %(matrix_a, matrix_b, (add(matrix_a, matrix_b))))
     print('Multiply Operation, %s * %s = %s \n' %(matrix_a, matrix_b, multiply(matrix_a, matrix_b)))
     print('Identity:  %s \n' %identity(5))
-    print('Minor of %s = %s \n' %(matrix_c, minor(matrix_c , 1 , 2)))
+    print('Minor of %s = %s \n' %(matrix_c, minor(matrix_c, 1, 2)))
     print('Determinant of %s = %s \n' %(matrix_b, determinant(matrix_b)))
     print('Inverse of %s = %s\n'%(matrix_d, inverse(matrix_d)))
 
+
 if __name__ == '__main__':
     main()
diff --git a/matrix/tests/pytest.ini b/matrix/tests/pytest.ini
new file mode 100644
index 000000000000..8a978b56ef8b
--- /dev/null
+++ b/matrix/tests/pytest.ini
@@ -0,0 +1,3 @@
+[pytest]
+markers =
+    mat_ops: tests for matrix operations
diff --git a/matrix/tests/test_matrix_operation.py b/matrix/tests/test_matrix_operation.py
new file mode 100644
index 000000000000..8b81b65d0fc8
--- /dev/null
+++ b/matrix/tests/test_matrix_operation.py
@@ -0,0 +1,112 @@
+"""
+Testing here assumes that numpy and linalg is ALWAYS correct!!!!
+
+If running from PyCharm you can place the following line in "Additional Arguments" for the pytest run configuration
+-vv -m mat_ops -p no:cacheprovider
+"""
+
+# standard libraries
+import sys
+import numpy as np
+import pytest
+import logging
+
+# Custom/local libraries
+from matrix import matrix_operation as matop
+
+mat_a = [[12, 10], [3, 9]]
+mat_b = [[3, 4], [7, 4]]
+mat_c = [[3, 0, 2], [2, 0, -2], [0, 1, 1]]
+mat_d = [[3, 0, -2], [2, 0, 2], [0, 1, 1]]
+mat_e = [[3, 0, 2], [2, 0, -2], [0, 1, 1], [2, 0, -2]]
+mat_f = [1]
+mat_h = [2]
+
+logger = logging.getLogger()
+logger.level = logging.DEBUG
+stream_handler = logging.StreamHandler(sys.stdout)
+logger.addHandler(stream_handler)
+
+
+@pytest.mark.mat_ops
+@pytest.mark.parametrize(('mat1', 'mat2'), [(mat_a, mat_b), (mat_c, mat_d), (mat_d, mat_e),
+                                            (mat_f, mat_h)])
+def test_addition(mat1, mat2):
+    if (np.array(mat1)).shape < (2, 2) or (np.array(mat2)).shape < (2, 2):
+        with pytest.raises(TypeError):
+            logger.info(f"\n\t{test_addition.__name__} returned integer")
+            matop.add(mat1, mat2)
+    elif (np.array(mat1)).shape == (np.array(mat2)).shape:
+        logger.info(f"\n\t{test_addition.__name__} with same matrix dims")
+        act = (np.array(mat1) + np.array(mat2)).tolist()
+        theo = matop.add(mat1, mat2)
+        assert theo == act
+    else:
+        with pytest.raises(ValueError):
+            logger.info(f"\n\t{test_addition.__name__} with different matrix dims")
+            matop.add(mat1, mat2)
+
+
+@pytest.mark.mat_ops
+@pytest.mark.parametrize(('mat1', 'mat2'), [(mat_a, mat_b), (mat_c, mat_d), (mat_d, mat_e),
+                                            (mat_f, mat_h)])
+def test_subtraction(mat1, mat2):
+    if (np.array(mat1)).shape < (2, 2) or (np.array(mat2)).shape < (2, 2):
+        with pytest.raises(TypeError):
+            logger.info(f"\n\t{test_subtraction.__name__} returned integer")
+            matop.subtract(mat1, mat2)
+    elif (np.array(mat1)).shape == (np.array(mat2)).shape:
+        logger.info(f"\n\t{test_subtraction.__name__} with same matrix dims")
+        act = (np.array(mat1) - np.array(mat2)).tolist()
+        theo = matop.subtract(mat1, mat2)
+        assert theo == act
+    else:
+        with pytest.raises(ValueError):
+            logger.info(f"\n\t{test_subtraction.__name__} with different matrix dims")
+            assert matop.subtract(mat1, mat2)
+
+
+@pytest.mark.mat_ops
+@pytest.mark.parametrize(('mat1', 'mat2'), [(mat_a, mat_b), (mat_c, mat_d), (mat_d, mat_e),
+                                            (mat_f, mat_h)])
+def test_multiplication(mat1, mat2):
+    if (np.array(mat1)).shape < (2, 2) or (np.array(mat2)).shape < (2, 2):
+        logger.info(f"\n\t{test_multiplication.__name__} returned integer")
+        with pytest.raises(TypeError):
+            matop.add(mat1, mat2)
+    elif (np.array(mat1)).shape == (np.array(mat2)).shape:
+        logger.info(f"\n\t{test_multiplication.__name__} meets dim requirements")
+        act = (np.matmul(mat1, mat2)).tolist()
+        theo = matop.multiply(mat1, mat2)
+        assert theo == act
+    else:
+        with pytest.raises(ValueError):
+            logger.info(f"\n\t{test_multiplication.__name__} does not meet dim requirements")
+            assert matop.subtract(mat1, mat2)
+
+
+@pytest.mark.mat_ops
+def test_scalar_multiply():
+    act = (3.5 * np.array(mat_a)).tolist()
+    theo = matop.scalar_multiply(mat_a, 3.5)
+    assert theo == act
+
+
+@pytest.mark.mat_ops
+def test_identity():
+    act = (np.identity(5)).tolist()
+    theo = matop.identity(5)
+    assert theo == act
+
+
+@pytest.mark.mat_ops
+@pytest.mark.parametrize('mat', [mat_a, mat_b, mat_c, mat_d, mat_e, mat_f])
+def test_transpose(mat):
+    if (np.array(mat)).shape < (2, 2):
+        with pytest.raises(TypeError):
+            logger.info(f"\n\t{test_transpose.__name__} returned integer")
+            matop.transpose(mat)
+    else:
+        act = (np.transpose(mat)).tolist()
+        theo = matop.transpose(mat, return_map=False)
+        assert theo == act

From f5e6d4e8cddb920439ed9a94b79f2af9a4fa2ac6 Mon Sep 17 00:00:00 2001
From: Christian Clauss <cclauss@me.com>
Date: Sat, 20 Jul 2019 09:36:55 +0200
Subject: [PATCH 134/348] Update DIRECTORY.md (#1046)

* Update DIRECTORY.md

* Remove blank lines
---
 DIRECTORY.md | 27 ++++++++++++++-------------
 1 file changed, 14 insertions(+), 13 deletions(-)

diff --git a/DIRECTORY.md b/DIRECTORY.md
index 66128228abc3..fc06a8cd1548 100644
--- a/DIRECTORY.md
+++ b/DIRECTORY.md
@@ -5,6 +5,7 @@
   * [newton method](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/newton_method.py)
   * [newton raphson method](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/newton_raphson_method.py)
 ## Backtracking
+  * [all combinations](https://github.com/TheAlgorithms/Python/blob/master/backtracking/all_combinations.py)
   * [all permutations](https://github.com/TheAlgorithms/Python/blob/master/backtracking/all_permutations.py)
   * [all subsequences](https://github.com/TheAlgorithms/Python/blob/master/backtracking/all_subsequences.py)
   * [minimax](https://github.com/TheAlgorithms/Python/blob/master/backtracking/minimax.py)
@@ -27,7 +28,6 @@
   * [morse code implementation](https://github.com/TheAlgorithms/Python/blob/master/ciphers/morse_code_implementation.py)
   * [onepad cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/onepad_cipher.py)
   * [playfair cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/playfair_cipher.py)
-  * [prehistoric men](https://github.com/TheAlgorithms/Python/blob/master/ciphers/prehistoric_men.txt)
   * [rabin miller](https://github.com/TheAlgorithms/Python/blob/master/ciphers/rabin_miller.py)
   * [rot13](https://github.com/TheAlgorithms/Python/blob/master/ciphers/rot13.py)
   * [rsa cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/rsa_cipher.py)
@@ -39,6 +39,7 @@
   * [vigenere cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/vigenere_cipher.py)
   * [xor cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/xor_cipher.py)
 ## Compression
+  * [burrows wheeler](https://github.com/TheAlgorithms/Python/blob/master/compression/burrows_wheeler.py)
   * [huffman](https://github.com/TheAlgorithms/Python/blob/master/compression/huffman.py)
   * [peak signal to noise ratio](https://github.com/TheAlgorithms/Python/blob/master/compression/peak_signal_to_noise_ratio.py)
   * Image Data
@@ -100,8 +101,10 @@
 ## Dynamic Programming
   * [abbreviation](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/abbreviation.py)
   * [bitmask](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/bitmask.py)
+  * [climbing stairs](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/climbing_stairs.py)
   * [coin change](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/coin_change.py)
   * [edit distance](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/edit_distance.py)
+  * [factorial](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/factorial.py)
   * [fast fibonacci](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/fast_fibonacci.py)
   * [fibonacci](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/fibonacci.py)
   * [floyd warshall](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/floyd_warshall.py)
@@ -142,9 +145,9 @@
   * [eulerian path and circuit for undirected graph](https://github.com/TheAlgorithms/Python/blob/master/graphs/eulerian_path_and_circuit_for_undirected_graph.py)
   * [even tree](https://github.com/TheAlgorithms/Python/blob/master/graphs/even_tree.py)
   * [finding bridges](https://github.com/TheAlgorithms/Python/blob/master/graphs/finding_bridges.py)
-  * [floyd warshall](https://github.com/TheAlgorithms/Python/blob/master/graphs/floyd_warshall.py)
   * [graph list](https://github.com/TheAlgorithms/Python/blob/master/graphs/graph_list.py)
   * [graph matrix](https://github.com/TheAlgorithms/Python/blob/master/graphs/graph_matrix.py)
+  * [graphs floyd warshall](https://github.com/TheAlgorithms/Python/blob/master/graphs/graphs_floyd_warshall.py)
   * [kahns algorithm long](https://github.com/TheAlgorithms/Python/blob/master/graphs/kahns_algorithm_long.py)
   * [kahns algorithm topo](https://github.com/TheAlgorithms/Python/blob/master/graphs/kahns_algorithm_topo.py)
   * [minimum spanning tree kruskal](https://github.com/TheAlgorithms/Python/blob/master/graphs/minimum_spanning_tree_kruskal.py)
@@ -170,13 +173,17 @@
   * [knn sklearn](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/knn_sklearn.py)
   * [linear regression](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/linear_regression.py)
   * [logistic regression](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/logistic_regression.py)
+  * [NaiveBayes](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/NaiveBayes.ipynb)
   * [perceptron](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/perceptron.py)
+  * [reuters one vs rest classifier](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/reuters_one_vs_rest_classifier.ipynb)
   * [scoring functions](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/scoring_functions.py)
   * Random Forest Classification
     * [random forest classification](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/random_forest_classification/random_forest_classification.py)
+    * [random forest classifier](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/random_forest_classification/random_forest_classifier.ipynb)
     * [Social Network Ads](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/random_forest_classification/Social_Network_Ads.csv)
   * Random Forest Regression
     * [Position Salaries](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/random_forest_regression/Position_Salaries.csv)
+    * [random forest regression](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/random_forest_regression/random_forest_regression.ipynb)
     * [random forest regression](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/random_forest_regression/random_forest_regression.py)
 ## Maths
   * [3n+1](https://github.com/TheAlgorithms/Python/blob/master/maths/3n+1.py)
@@ -197,7 +204,7 @@
   * [find max](https://github.com/TheAlgorithms/Python/blob/master/maths/find_max.py)
   * [find min](https://github.com/TheAlgorithms/Python/blob/master/maths/find_min.py)
   * [greater common divisor](https://github.com/TheAlgorithms/Python/blob/master/maths/greater_common_divisor.py)
-  * [lucas series](https://github.com/TheAlgorithms/Python/blob/master/maths/lucas%20series.py)
+  * [lucas series](https://github.com/TheAlgorithms/Python/blob/master/maths/lucas_series.py)
   * [modular exponential](https://github.com/TheAlgorithms/Python/blob/master/maths/modular_exponential.py)
   * [newton raphson](https://github.com/TheAlgorithms/Python/blob/master/maths/newton_raphson.py)
   * [prime check](https://github.com/TheAlgorithms/Python/blob/master/maths/prime_check.py)
@@ -208,6 +215,8 @@
   * [volume](https://github.com/TheAlgorithms/Python/blob/master/maths/volume.py)
 ## Matrix
   * [matrix operation](https://github.com/TheAlgorithms/Python/blob/master/matrix/matrix_operation.py)
+  * [nth fibonacci using matrix exponentiation](https://github.com/TheAlgorithms/Python/blob/master/matrix/nth_fibonacci_using_matrix_exponentiation.py)
+  * [rotate matrix](https://github.com/TheAlgorithms/Python/blob/master/matrix/rotate_matrix.py)
   * [searching in sorted matrix](https://github.com/TheAlgorithms/Python/blob/master/matrix/searching_in_sorted_matrix.py)
   * [spiral print](https://github.com/TheAlgorithms/Python/blob/master/matrix/spiral_print.py)
 ## Networking Flow
@@ -216,16 +225,17 @@
 ## Neural Network
   * [back propagation neural network](https://github.com/TheAlgorithms/Python/blob/master/neural_network/back_propagation_neural_network.py)
   * [convolution neural network](https://github.com/TheAlgorithms/Python/blob/master/neural_network/convolution_neural_network.py)
+  * [fully connected neural network](https://github.com/TheAlgorithms/Python/blob/master/neural_network/fully_connected_neural_network.ipynb)
   * [perceptron](https://github.com/TheAlgorithms/Python/blob/master/neural_network/perceptron.py)
 ## Other
   * [anagrams](https://github.com/TheAlgorithms/Python/blob/master/other/anagrams.py)
   * [binary exponentiation](https://github.com/TheAlgorithms/Python/blob/master/other/binary_exponentiation.py)
   * [binary exponentiation 2](https://github.com/TheAlgorithms/Python/blob/master/other/binary_exponentiation_2.py)
   * [detecting english programmatically](https://github.com/TheAlgorithms/Python/blob/master/other/detecting_english_programmatically.py)
-  * [dictionary](https://github.com/TheAlgorithms/Python/blob/master/other/dictionary.txt)
   * [euclidean gcd](https://github.com/TheAlgorithms/Python/blob/master/other/euclidean_gcd.py)
   * [finding primes](https://github.com/TheAlgorithms/Python/blob/master/other/finding_primes.py)
   * [fischer yates shuffle](https://github.com/TheAlgorithms/Python/blob/master/other/fischer_yates_shuffle.py)
+  * [Food wastage analysis from 1961-2013 (FAO)](https://github.com/TheAlgorithms/Python/blob/master/other/Food%20wastage%20analysis%20from%201961-2013%20(FAO).ipynb)
   * [frequency finder](https://github.com/TheAlgorithms/Python/blob/master/other/frequency_finder.py)
   * [game of life](https://github.com/TheAlgorithms/Python/blob/master/other/game_of_life.py)
   * [linear congruential generator](https://github.com/TheAlgorithms/Python/blob/master/other/linear_congruential_generator.py)
@@ -238,8 +248,6 @@
   * [two sum](https://github.com/TheAlgorithms/Python/blob/master/other/two_sum.py)
   * [word patterns](https://github.com/TheAlgorithms/Python/blob/master/other/word_patterns.py)
   * [words](https://github.com/TheAlgorithms/Python/blob/master/other/words)
-  *   Pycache  
-    * [password generator.cpython-37](https://github.com/TheAlgorithms/Python/blob/master/other/__pycache__/password_generator.cpython-37.pyc)
 ## Project Euler
   * Problem 01
     * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_01/sol1.py)
@@ -281,16 +289,13 @@
     * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_10/sol1.py)
     * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_10/sol2.py)
   * Problem 11
-    * [grid](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_11/grid.txt)
     * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_11/sol1.py)
     * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_11/sol2.py)
   * Problem 12
     * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_12/sol1.py)
     * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_12/sol2.py)
   * Problem 13
-    * [num](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_13/num.txt)
     * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_13/sol1.py)
-    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_13/sol2.py)
   * Problem 14
     * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_14/sol1.py)
     * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_14/sol2.py)
@@ -309,7 +314,6 @@
   * Problem 21
     * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_21/sol1.py)
   * Problem 22
-    * [p022 names](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_22/p022_names.txt)
     * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_22/sol1.py)
     * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_22/sol2.py)
   * Problem 234
@@ -337,8 +341,6 @@
     * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_53/sol1.py)
   * Problem 76
     * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_76/sol1.py)
-## Scripts
-  * [build directory md](https://github.com/TheAlgorithms/Python/blob/master/scripts/build_directory_md.py)
 ## Searches
   * [binary search](https://github.com/TheAlgorithms/Python/blob/master/searches/binary_search.py)
   * [interpolation search](https://github.com/TheAlgorithms/Python/blob/master/searches/interpolation_search.py)
@@ -347,7 +349,6 @@
   * [quick select](https://github.com/TheAlgorithms/Python/blob/master/searches/quick_select.py)
   * [sentinel linear search](https://github.com/TheAlgorithms/Python/blob/master/searches/sentinel_linear_search.py)
   * [tabu search](https://github.com/TheAlgorithms/Python/blob/master/searches/tabu_search.py)
-  * [tabu test data](https://github.com/TheAlgorithms/Python/blob/master/searches/tabu_test_data.txt)
   * [ternary search](https://github.com/TheAlgorithms/Python/blob/master/searches/ternary_search.py)
 ## Sorts
   * [bitonic sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/bitonic_sort.py)

From 61fec83242bb00766141ffa2571414bbba68ab6e Mon Sep 17 00:00:00 2001
From: QuantumNovice <43876848+QuantumNovice@users.noreply.github.com>
Date: Sat, 20 Jul 2019 17:32:40 +0500
Subject: [PATCH 135/348] Adds Gaussian Function in maths section  (#1054)

* Create gaussian.py

* Update gaussian.py

* Update gaussian.py

* Create gaussian.png

* Add files via upload

* Create prime_factors.py

* Update prime_factors.py

* Update prime_factors.py
---
 maths/gaussian.py         |  61 ++++++++++++++++++++++++++++++++++++++
 maths/images/gaussian.png | Bin 0 -> 53511 bytes
 maths/prime_factors.py    |  52 ++++++++++++++++++++++++++++++++
 3 files changed, 113 insertions(+)
 create mode 100644 maths/gaussian.py
 create mode 100644 maths/images/gaussian.png
 create mode 100644 maths/prime_factors.py

diff --git a/maths/gaussian.py b/maths/gaussian.py
new file mode 100644
index 000000000000..f3a47a3f6a1b
--- /dev/null
+++ b/maths/gaussian.py
@@ -0,0 +1,61 @@
+
+"""
+Reference: https://en.wikipedia.org/wiki/Gaussian_function
+
+python/black : True
+python : 3.7.3
+
+"""
+from numpy import pi, sqrt, exp
+
+
+
+def gaussian(x, mu: float = 0.0, sigma: float = 1.0) -> int:
+    """
+    >>> gaussian(1)
+    0.24197072451914337
+      
+    >>> gaussian(24)
+    3.342714441794458e-126
+
+    Supports NumPy Arrays
+    Use numpy.meshgrid with this to generate gaussian blur on images.
+    >>> import numpy as np
+    >>> x = np.arange(15)
+    >>> gaussian(x)
+    array([3.98942280e-01, 2.41970725e-01, 5.39909665e-02, 4.43184841e-03,
+           1.33830226e-04, 1.48671951e-06, 6.07588285e-09, 9.13472041e-12,
+           5.05227108e-15, 1.02797736e-18, 7.69459863e-23, 2.11881925e-27,
+           2.14638374e-32, 7.99882776e-38, 1.09660656e-43])
+           
+    >>> gaussian(15)
+    5.530709549844416e-50
+
+    >>> gaussian([1,2, 'string'])
+    Traceback (most recent call last):
+        ...
+    TypeError: unsupported operand type(s) for -: 'list' and 'float'
+
+    >>> gaussian('hello world')
+    Traceback (most recent call last):
+        ...
+    TypeError: unsupported operand type(s) for -: 'str' and 'float'
+
+    >>> gaussian(10**234) # doctest: +IGNORE_EXCEPTION_DETAIL
+    Traceback (most recent call last):
+        ...
+    OverflowError: (34, 'Result too large')
+
+    >>> gaussian(10**-326)
+    0.3989422804014327
+
+    >>> gaussian(2523, mu=234234, sigma=3425)
+    0.0
+  """
+    return 1 / sqrt(2 * pi * sigma ** 2) * exp(-(x - mu) ** 2 / 2 * sigma ** 2)
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()
diff --git a/maths/images/gaussian.png b/maths/images/gaussian.png
new file mode 100644
index 0000000000000000000000000000000000000000..eb007c7e21b2296c17a11ebf4dee30cfa2e2f6b1
GIT binary patch
literal 53511
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%0AAvI%JD6*Pf82X=-HgWCAtm5l0EcOP$}
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

literal 0
HcmV?d00001

diff --git a/maths/prime_factors.py b/maths/prime_factors.py
new file mode 100644
index 000000000000..eb3de00de6a7
--- /dev/null
+++ b/maths/prime_factors.py
@@ -0,0 +1,52 @@
+"""
+python/black : True
+"""
+from typing import List
+
+
+def prime_factors(n: int) -> List[int]:
+    """
+    Returns prime factors of n as a list.
+    
+    >>> prime_factors(0)
+    []
+    >>> prime_factors(100)
+    [2, 2, 5, 5]
+    >>> prime_factors(2560)
+    [2, 2, 2, 2, 2, 2, 2, 2, 2, 5]
+    >>> prime_factors(10**-2)
+    []
+    >>> prime_factors(0.02)
+    []
+    >>> x = prime_factors(10**241) # doctest: +NORMALIZE_WHITESPACE
+    >>> x == [2]*241 + [5]*241
+    True
+    >>> prime_factors(10**-354)
+    []
+    >>> prime_factors('hello')
+    Traceback (most recent call last):
+        ...
+    TypeError: '<=' not supported between instances of 'int' and 'str'
+    >>> prime_factors([1,2,'hello'])
+    Traceback (most recent call last):
+        ...
+    TypeError: '<=' not supported between instances of 'int' and 'list'
+
+    """
+    i = 2
+    factors = []
+    while i * i <= n:
+        if n % i:
+            i += 1
+        else:
+            n //= i
+            factors.append(i)
+    if n > 1:
+        factors.append(n)
+    return factors
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()

From 5b5beb61d63b97562ba0b5d161b9a2e23fb8bcf5 Mon Sep 17 00:00:00 2001
From: QuantumNovice <43876848+QuantumNovice@users.noreply.github.com>
Date: Sat, 20 Jul 2019 20:33:04 +0500
Subject: [PATCH 136/348] Update newton_raphson_method.py (#1057)

---
 arithmetic_analysis/newton_raphson_method.py | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/arithmetic_analysis/newton_raphson_method.py b/arithmetic_analysis/newton_raphson_method.py
index 5e7e2f930abc..569f96476afc 100644
--- a/arithmetic_analysis/newton_raphson_method.py
+++ b/arithmetic_analysis/newton_raphson_method.py
@@ -1,5 +1,5 @@
 # Implementing Newton Raphson method in Python
-# Author: Haseeb
+# Author: Syed Haseeb Shah (github.com/QuantumNovice)
 
 from sympy import diff
 from decimal import Decimal
@@ -30,7 +30,3 @@ def NewtonRaphson(func, a):
 
     # Exponential Roots
     print ('exp(x) - 1 = 0', NewtonRaphson('exp(x) - 1', 0))
-    
-    
-    
-

From 0f0953070750f9f9813ea599e74d04a9c34e5dd2 Mon Sep 17 00:00:00 2001
From: Christian Clauss <cclauss@me.com>
Date: Sat, 20 Jul 2019 18:31:08 +0200
Subject: [PATCH 137/348] dijkstra.py: Use r"strings" to fix two pylint
 warnings (#1052)

```
=============================== warnings summary ===============================
graphs/dijkstra.py:81
  /home/travis/build/TheAlgorithms/Python/graphs/dijkstra.py:81: DeprecationWarning: invalid escape sequence \
    """
graphs/dijkstra.py:97
  /home/travis/build/TheAlgorithms/Python/graphs/dijkstra.py:97: DeprecationWarning: invalid escape sequence \
    """
-- Docs: https://docs.pytest.org/en/latest/warnings.html
=================== 126 passed, 7 warnings in 19.35 seconds ====================
```
---
 graphs/dijkstra.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/graphs/dijkstra.py b/graphs/dijkstra.py
index 52354b5c916b..5f09a45cf2c4 100644
--- a/graphs/dijkstra.py
+++ b/graphs/dijkstra.py
@@ -71,7 +71,7 @@ def dijkstra(graph, start, end):
     "F": [["C", 3], ["E", 3]],
 }
 
-"""
+r"""
 Layout of G2:
 
 E -- 1 --> B -- 1 --> C -- 1 --> D -- 1 --> F
@@ -87,7 +87,7 @@ def dijkstra(graph, start, end):
     "F": [],
 }
 
-"""
+r"""
 Layout of G3:
 
 E -- 1 --> B -- 1 --> C -- 1 --> D -- 1 --> F

From b35f5d971b45ed0740dc6f7a4a8b3a05f516a258 Mon Sep 17 00:00:00 2001
From: John Law <johnlaw.po@gmail.com>
Date: Sun, 21 Jul 2019 00:40:00 +0800
Subject: [PATCH 138/348] Update CONTRIBUTING.md (#1059)

---
 CONTRIBUTING.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 02235ee89973..3202b817f1c5 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -69,7 +69,7 @@ We want your work to be readable by others; therefore, we encourage you to note
       """
   	This function sums two integers a and b
   	Return: a + b
-  	"""
+      """
       return a + b
   ```
 

From 93fdc9f2a1d64c08e6f1ef5ebbb1470e4ee5c4e2 Mon Sep 17 00:00:00 2001
From: Christian Clauss <cclauss@me.com>
Date: Sun, 21 Jul 2019 08:16:28 +0200
Subject: [PATCH 139/348] Travis CI: Add pytest --doctest-modules maths (#1020)

* Travis CI: Add pytest --doctest-modules maths

* Update lucas_series.py

* Update lucas_series.py
---
 .travis.yml                    |  4 ----
 maths/abs_min.py               |  9 ++++++---
 maths/binary_exponentiation.py | 17 +++++++++--------
 maths/lucas_series.py          | 28 ++++++++++++++++++----------
 maths/sieve_of_eratosthenes.py |  6 ++----
 5 files changed, 35 insertions(+), 29 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index a3ff22fb09b7..bea512264c19 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -18,10 +18,6 @@ script:
       --ignore=machine_learning/perceptron.py
       --ignore=machine_learning/random_forest_classification/random_forest_classification.py
       --ignore=machine_learning/random_forest_regression/random_forest_regression.py
-      --ignore=maths/abs_min.py
-      --ignore=maths/binary_exponentiation.py
-      --ignore=maths/lucas_series.py
-      --ignore=maths/sieve_of_eratosthenes.py
 after_success:
   - python scripts/build_directory_md.py
   - cat DIRECTORY.md
diff --git a/maths/abs_min.py b/maths/abs_min.py
index d546196aa1b5..abb0c9051b7d 100644
--- a/maths/abs_min.py
+++ b/maths/abs_min.py
@@ -1,10 +1,11 @@
-from abs import abs_val
+from .abs import abs_val
+
 
 def absMin(x):
     """
-    # >>>absMin([0,5,1,11])
+    >>> absMin([0,5,1,11])
     0
-    # >>absMin([3,-10,-2])
+    >>> absMin([3,-10,-2])
     -2
     """
     j = x[0]
@@ -13,9 +14,11 @@ def absMin(x):
             j = i
     return j
 
+
 def main():
     a = [-3,-1,2,-11]
     print(absMin(a))  # = -1
 
+
 if __name__ == '__main__':
     main()
\ No newline at end of file
diff --git a/maths/binary_exponentiation.py b/maths/binary_exponentiation.py
index cf789afc6f22..a8d736adfea0 100644
--- a/maths/binary_exponentiation.py
+++ b/maths/binary_exponentiation.py
@@ -17,11 +17,12 @@ def binary_exponentiation(a, n):
         return b * b
 
 
-try:
-    BASE = int(input('Enter Base : '))
-    POWER = int(input("Enter Power : "))
-except ValueError:
-    print("Invalid literal for integer")
-
-RESULT = binary_exponentiation(BASE, POWER)
-print("{}^({}) : {}".format(BASE, POWER, RESULT))
+if __name__ == "__main__":
+    try:
+        BASE = int(input("Enter Base : ").strip())
+        POWER = int(input("Enter Power : ").strip())
+    except ValueError:
+        print("Invalid literal for integer")
+
+    RESULT = binary_exponentiation(BASE, POWER)
+    print("{}^({}) : {}".format(BASE, POWER, RESULT))
diff --git a/maths/lucas_series.py b/maths/lucas_series.py
index 91ea1ba72a56..9ae437dc9f54 100644
--- a/maths/lucas_series.py
+++ b/maths/lucas_series.py
@@ -1,13 +1,21 @@
 # Lucas Sequence Using Recursion
 
 def recur_luc(n):
-  if n == 1:
-    return n
-  if n == 0:
-    return 2
-  return (recur_luc(n-1) + recur_luc(n-2))
-    
-limit = int(input("How many terms to include in Lucas series:"))
-print("Lucas series:")
-for i in range(limit):
-  print(recur_luc(i))
+    """
+    >>> recur_luc(1)
+    1
+    >>> recur_luc(0)
+    2
+    """
+    if n == 1:
+        return n
+    if n == 0:
+        return 2
+    return recur_luc(n - 1) + recur_luc(n - 2)
+
+
+if __name__ == "__main__":
+    limit = int(input("How many terms to include in Lucas series:"))
+    print("Lucas series:")
+    for i in range(limit):
+        print(recur_luc(i))
diff --git a/maths/sieve_of_eratosthenes.py b/maths/sieve_of_eratosthenes.py
index 11c123693694..cedd04f92aa0 100644
--- a/maths/sieve_of_eratosthenes.py
+++ b/maths/sieve_of_eratosthenes.py
@@ -2,9 +2,6 @@
 
 import math
 
-N = int(input("Enter n: "))
-
-
 def sieve(n):
     """Sieve of Eratosthones."""
     l = [True] * (n + 1)
@@ -26,4 +23,5 @@ def sieve(n):
     return prime
 
 
-print(sieve(N))
+if __name__ == "__main__":
+    print(sieve(int(input("Enter n: ").strip())))

From c964d743b6275e31548f605d5b2d583656960de0 Mon Sep 17 00:00:00 2001
From: QuantumNovice <43876848+QuantumNovice@users.noreply.github.com>
Date: Sun, 21 Jul 2019 13:35:42 +0500
Subject: [PATCH 140/348] Added Mobius Function (#1058)

* Add files via upload

* Update mobius_function.py

* Add files via upload

* Add files via upload

* Add files via upload

* Add files via upload

* Add files via upload

* Add files via upload

* Update mobius_function.py

* Delete mobius_function.py

* Add files via upload
---
 maths/is_square_free.py  | 39 ++++++++++++++++++++++++++++++++++++
 maths/mobius_function.py | 43 ++++++++++++++++++++++++++++++++++++++++
 2 files changed, 82 insertions(+)
 create mode 100644 maths/is_square_free.py
 create mode 100644 maths/mobius_function.py

diff --git a/maths/is_square_free.py b/maths/is_square_free.py
new file mode 100644
index 000000000000..acc13fa5f833
--- /dev/null
+++ b/maths/is_square_free.py
@@ -0,0 +1,39 @@
+"""
+References: wikipedia:square free number
+python/black : True
+flake8 : True
+"""
+from typing import List
+
+
+def is_square_free(factors: List[int]) -> bool:
+    """
+    # doctest: +NORMALIZE_WHITESPACE
+    This functions takes a list of prime factors as input.
+    returns True if the factors are square free.
+    >>> is_square_free([1, 1, 2, 3, 4])
+    False
+    
+    These are wrong but should return some value
+    it simply checks for repition in the numbers.
+    >>> is_square_free([1, 3, 4, 'sd', 0.0])
+    True
+    
+    >>> is_square_free([1, 0.5, 2, 0.0])
+    True
+    >>> is_square_free([1, 2, 2, 5])
+    False
+    >>> is_square_free('asd')
+    True
+    >>> is_square_free(24)
+    Traceback (most recent call last):
+        ...
+    TypeError: 'int' object is not iterable
+    """
+    return len(set(factors)) == len(factors)
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()
diff --git a/maths/mobius_function.py b/maths/mobius_function.py
new file mode 100644
index 000000000000..15fb3d4380f4
--- /dev/null
+++ b/maths/mobius_function.py
@@ -0,0 +1,43 @@
+"""
+Refrences: https://en.wikipedia.org/wiki/M%C3%B6bius_function
+References: wikipedia:square free number
+python/black : True
+flake8 : True
+"""
+
+from maths.prime_factors import prime_factors
+from maths.is_square_free import is_square_free
+
+
+def mobius(n: int) -> int:
+    """
+    Mobius function
+    >>> mobius(24)
+    0
+    >>> mobius(-1)
+    1
+    >>> mobius('asd')
+    Traceback (most recent call last):
+        ...
+    TypeError: '<=' not supported between instances of 'int' and 'str'
+    >>> mobius(10**400)
+    0
+    >>> mobius(10**-400)
+    1
+    >>> mobius(-1424)
+    1
+    >>> mobius([1, '2', 2.0])
+    Traceback (most recent call last):
+        ...
+    TypeError: '<=' not supported between instances of 'int' and 'list'
+    """
+    factors = prime_factors(n)
+    if is_square_free(factors):
+        return -1 if len(factors) % 2 else 1
+    return 0
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()

From 05e567c2f92dc746969fe859cd806d5928067f52 Mon Sep 17 00:00:00 2001
From: QuantumNovice <43876848+QuantumNovice@users.noreply.github.com>
Date: Sun, 21 Jul 2019 16:03:39 +0500
Subject: [PATCH 141/348] Code to change contrast (#1060)

* Add files via upload

* Update requirements.txt

* Add files via upload

* Add files via upload

* Add files via upload

* Add files via upload
---
 digital_image_processing/change_contrast.py | 35 +++++++++++++++++++++
 requirements.txt                            |  1 +
 2 files changed, 36 insertions(+)
 create mode 100644 digital_image_processing/change_contrast.py

diff --git a/digital_image_processing/change_contrast.py b/digital_image_processing/change_contrast.py
new file mode 100644
index 000000000000..76f1a3e1fcd8
--- /dev/null
+++ b/digital_image_processing/change_contrast.py
@@ -0,0 +1,35 @@
+"""
+Changing contrast with PIL
+
+This algorithm is used in
+https://noivce.pythonanywhere.com/ python web app.
+
+python/black: True
+flake8 : True
+"""
+
+from PIL import Image
+
+
+def change_contrast(img: Image, level: float) -> Image:
+    """
+    Function to change contrast
+    """
+    factor = (259 * (level + 255)) / (255 * (259 - level))
+
+    def contrast(c: int) -> float:
+        """
+        Fundamental Transformation/Operation that'll be performed on
+        every bit.
+        """
+        return 128 + factor * (c - 128)
+
+    return img.point(contrast)
+
+
+if __name__ == "__main__":
+    # Load image
+    with Image.open("image_data/lena.jpg") as img:
+        # Change contrast to 170
+        cont_img = change_contrast(img, 170)
+        cont_img.save("image_data/lena_high_contrast.png", format="png")
diff --git a/requirements.txt b/requirements.txt
index 91d3df33323d..a3e62cf968f7 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -5,6 +5,7 @@ mypy
 numpy
 opencv-python
 pandas
+pillow
 pytest
 sklearn
 sympy

From b2ed8d443c03bd9fa8cc523bcefcca4eeff04c2e Mon Sep 17 00:00:00 2001
From: Christian Clauss <cclauss@me.com>
Date: Tue, 23 Jul 2019 00:07:09 +0200
Subject: [PATCH 142/348] rotate_matrix.py: Add type hints for return values
 (#1023)

* rotate_matrix.py: Add type hints for return values

@obelisk0114 Your review please?

* Fix typo

* Run the code thru python/black

https://github.com/python/black

* Fix 270 comment

* Simplify with get_data() and test the alternatives

* ) * 3

* Update rotate_matrix.py

* Update rotate_matrix.py
---
 matrix/rotate_matrix.py | 115 ++++++++++++++++++++--------------------
 1 file changed, 58 insertions(+), 57 deletions(-)

diff --git a/matrix/rotate_matrix.py b/matrix/rotate_matrix.py
index e3495e647954..822851826121 100644
--- a/matrix/rotate_matrix.py
+++ b/matrix/rotate_matrix.py
@@ -1,99 +1,100 @@
 # -*- coding: utf-8 -*-
 
 """
-	In this problem, we want to rotate the matrix elements by 90, 180, 270 (counterclockwise)
-	Discussion in stackoverflow: 
-   https://stackoverflow.com/questions/42519/how-do-you-rotate-a-two-dimensional-array
+In this problem, we want to rotate the matrix elements by 90, 180, 270 (counterclockwise)
+Discussion in stackoverflow:
+https://stackoverflow.com/questions/42519/how-do-you-rotate-a-two-dimensional-array
 """
 
 
-def rotate_90(matrix: [[]]):
+def make_matrix(row_size: int = 4) -> [[int]]:
     """
-    >>> rotate_90([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]])
-    [[4, 8, 12, 16], [3, 7, 11, 15], [2, 6, 10, 14], [1, 5, 9, 13]]
+    >>> make_matrix()
+    [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]]
+    >>> make_matrix(1)
+    [[1]]
+    >>> make_matrix(-2)
+    [[1, 2], [3, 4]]
+    >>> make_matrix(3)
+    [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
+    >>> make_matrix() == make_matrix(4)
+    True
     """
-    
-    transpose(matrix)
-    reverse_row(matrix)
-    return matrix
-    
+    row_size = abs(row_size) or 4
+    return [[1 + x + y * row_size for x in range(row_size)] for y in range(row_size)]
+
 
-def rotate_180(matrix: [[]]):
+def rotate_90(matrix: [[]]) -> [[]]:
     """
-    >>> rotate_180([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]])
-    [[16, 15, 14, 13], [12, 11, 10, 9], [8, 7, 6, 5], [4, 3, 2, 1]]
+    >>> rotate_90(make_matrix())
+    [[4, 8, 12, 16], [3, 7, 11, 15], [2, 6, 10, 14], [1, 5, 9, 13]]
+    >>> rotate_90(make_matrix()) == transpose(reverse_column(make_matrix()))
+    True
     """
-    
-    reverse_column(matrix)
-    reverse_row(matrix)
-    
+
+    return reverse_row(transpose(matrix))
+    # OR.. transpose(reverse_column(matrix))
+
+
+def rotate_180(matrix: [[]]) -> [[]]:
     """
-    OR
-    
-    reverse_row(matrix)
-    reverse_column(matrix)
+    >>> rotate_180(make_matrix())
+    [[16, 15, 14, 13], [12, 11, 10, 9], [8, 7, 6, 5], [4, 3, 2, 1]]
+    >>> rotate_180(make_matrix()) == reverse_column(reverse_row(make_matrix()))
+    True
     """
-    
-    return matrix
 
-    
-def rotate_270(matrix: [[]]):
+    return reverse_row(reverse_column(matrix))
+    # OR.. reverse_column(reverse_row(matrix))
+
+
+def rotate_270(matrix: [[]]) -> [[]]:
     """
-    >>> rotate_270([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]])
+    >>> rotate_270(make_matrix())
     [[13, 9, 5, 1], [14, 10, 6, 2], [15, 11, 7, 3], [16, 12, 8, 4]]
+    >>> rotate_270(make_matrix()) == transpose(reverse_row(make_matrix()))
+    True
     """
-    
-    transpose(matrix)
-    reverse_column(matrix)
-    
-    """
-    OR
-    
-    reverse_row(matrix)
-    transpose(matrix)
-    """
-    
-    return matrix
 
+    return reverse_column(transpose(matrix))
+    # OR.. transpose(reverse_row(matrix))
 
-def transpose(matrix: [[]]):
+
+def transpose(matrix: [[]]) -> [[]]:
     matrix[:] = [list(x) for x in zip(*matrix)]
     return matrix
-    
-    
-def reverse_row(matrix: [[]]):
+
+
+def reverse_row(matrix: [[]]) -> [[]]:
     matrix[:] = matrix[::-1]
     return matrix
 
 
-def reverse_column(matrix: [[]]):
+def reverse_column(matrix: [[]]) -> [[]]:
     matrix[:] = [x[::-1] for x in matrix]
     return matrix
-    
-    
-def print_matrix(matrix: [[]]):
+
+
+def print_matrix(matrix: [[]]) -> [[]]:
     for i in matrix:
         print(*i)
 
 
-if __name__ == '__main__':
-    matrix = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]]
+if __name__ == "__main__":
+    matrix = make_matrix()
     print("\norigin:\n")
     print_matrix(matrix)
-    rotate_90(matrix)
     print("\nrotate 90 counterclockwise:\n")
-    print_matrix(matrix)
+    print_matrix(rotate_90(matrix))
 
-    matrix = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]]
+    matrix = make_matrix()
     print("\norigin:\n")
     print_matrix(matrix)
-    rotate_180(matrix)
     print("\nrotate 180:\n")
-    print_matrix(matrix)
+    print_matrix(rotate_180(matrix))
 
-    matrix = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]]
+    matrix = make_matrix()
     print("\norigin:\n")
     print_matrix(matrix)
-    rotate_270(matrix)
     print("\nrotate 270 counterclockwise:\n")
-    print_matrix(matrix)
+    print_matrix(rotate_270(matrix))

From 7c3ef9885393681c83c68e9733fa2a5fd9651203 Mon Sep 17 00:00:00 2001
From: "Md. Mahbubur Rahman" <mahbuburrahman2111@gmail.com>
Date: Wed, 24 Jul 2019 18:32:05 +0900
Subject: [PATCH 143/348] Implement ruling hash to appropriate complexity of
 Rabin Karp (#1066)

* Added matrix exponentiation approach for finding fibonacci number.

* Implemented the way of finding nth fibonacci.
* Complexity is about O(log(n)*8)

* Updated the matrix exponentiation approach of finding nth fibonacci.

- Removed some extra spaces
- Added the complexity of bruteforce algorithm
- Removed unused function called zerro()
- Added some docktest based on request

* Updated the matrix exponentiation approach of finding nth fibonacci.

- Removed some extra spaces
- Added the complexity of bruteforce algorithm
- Removed unused function called zerro()
- Added some docktest based on request

* Updated Rabin Karp algorithm.

- Previous solution is based on the hash function of python.
- Implemented ruling hash to get the appropriate complexity of rabin karp.

* Updated Rabin Karp algorithm.

- Previous solution is based on the hash function of python.
- Implemented ruling hash to get the appropriate complexity of rabin karp.

*  Implemented ruling hash to appropriate complexity of Rabin Karp

Added unit pattern testing
---
 strings/rabin_karp.py | 48 +++++++++++++++++++++++++++++++++++--------
 1 file changed, 39 insertions(+), 9 deletions(-)

diff --git a/strings/rabin_karp.py b/strings/rabin_karp.py
index 04a849266ead..7c36f7659e24 100644
--- a/strings/rabin_karp.py
+++ b/strings/rabin_karp.py
@@ -1,6 +1,11 @@
+# Numbers of alphabet which we call base
+alphabet_size = 256
+# Modulus to hash a string
+modulus = 1000003
+
+
 def rabin_karp(pattern, text):
     """
-
     The Rabin-Karp Algorithm for finding a pattern within a piece of text
     with complexity O(nm), most efficient when it is used with multiple patterns
     as it is able to check if any of a set of patterns match a section of text in o(1) given the precomputed hashes.
@@ -12,22 +17,42 @@ def rabin_karp(pattern, text):
     2) Step through the text one character at a time passing a window with the same length as the pattern
         calculating the hash of the text within the window compare it with the hash of the pattern. Only testing
         equality if the hashes match
-
     """
     p_len = len(pattern)
-    p_hash = hash(pattern)
+    t_len = len(text)
+    if p_len > t_len:
+        return False
+
+    p_hash = 0
+    text_hash = 0
+    modulus_power = 1
 
-    for i in range(0, len(text) - (p_len - 1)):
+    # Calculating the hash of pattern and substring of text
+    for i in range(p_len):
+        p_hash = (ord(pattern[i]) + p_hash * alphabet_size) % modulus
+        text_hash = (ord(text[i]) + text_hash * alphabet_size) % modulus
+        if i == p_len - 1:
+            continue
+        modulus_power = (modulus_power * alphabet_size) % modulus
 
-        # written like this t
-        text_hash = hash(text[i:i + p_len])
-        if text_hash == p_hash and \
-                text[i:i + p_len] == pattern:
+    for i in range(0, t_len - p_len + 1):
+        if text_hash == p_hash and text[i : i + p_len] == pattern:
             return True
+        if i == t_len - p_len:
+            continue
+        # Calculating the ruling hash
+        text_hash = (
+            (text_hash - ord(text[i]) * modulus_power) * alphabet_size
+            + ord(text[i + p_len])
+        ) % modulus
     return False
 
 
-if __name__ == '__main__':
+def test_rabin_karp():
+    """
+    >>> test_rabin_karp()
+    Success.
+    """
     # Test 1)
     pattern = "abc1abc12"
     text1 = "alskfjaldsabc1abc1abc12k23adsfabcabc"
@@ -48,3 +73,8 @@ def rabin_karp(pattern, text):
     pattern = "abcdabcy"
     text = "abcxabcdabxabcdabcdabcy"
     assert rabin_karp(pattern, text)
+    print("Success.")
+
+
+if __name__ == "__main__":
+    test_rabin_karp()

From 46bcee0978fe507891a8e3b8892437fafed28c08 Mon Sep 17 00:00:00 2001
From: QuantumNovice <43876848+QuantumNovice@users.noreply.github.com>
Date: Wed, 24 Jul 2019 17:34:22 +0500
Subject: [PATCH 144/348] Add badges to the top of README.md (#1064)

* Update README.md

* Update README.md

* Update README.md

* Update README.md

* Update README.md

* Update README.md

* Update README.md

* Update README.md

* Update README.md

* Update README.md

* Update README.md

* Update README.md

* Update README.md

* Update README.md

* Update README.md

* Update README.md

* Update README.md

* Update README.md

* Update README.md

* Update README.md

* Update README.md

* Update README.md

* Update README.md

* Update README.md

* Update README.md

* Update README.md

* Update README.md

* Update README.md

* Update README.md

* Update README.md

* Update README.md

* Update README.md

* Update README.md

* Update README.md

* Update README.md

* Update README.md

* Update README.md

* Update README.md

* Update README.md

* Update README.md

* Update README.md

* Update README.md

* Update README.md

* Update README.md

* Update README.md

* Update README.md

* Update README.md

* Update README.md

* Update README.md
---
 README.md | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/README.md b/README.md
index 30eccd361673..d4f4acbadb6d 100644
--- a/README.md
+++ b/README.md
@@ -1,9 +1,11 @@
 # The Algorithms - Python <!-- [![Build Status](https://travis-ci.org/TheAlgorithms/Python.svg)](https://travis-ci.org/TheAlgorithms/Python) -->
-
-[![Donate](https://img.shields.io/badge/Donate-PayPal-green.svg)](https://www.paypal.me/TheAlgorithms/100) &nbsp;
-[![Gitter chat](https://badges.gitter.im/gitterHQ/gitter.png)](https://gitter.im/TheAlgorithms) &nbsp;
-[![Open in Gitpod](https://gitpod.io/button/open-in-gitpod.svg)](https://gitpod.io/#https://github.com/TheAlgorithms/Python)
-
+[![Donate](https://img.shields.io/badge/Donate-PayPal-green.svg?logo=paypal&style=flat-square)](https://www.paypal.me/TheAlgorithms/100)&nbsp;
+[![Build Status](https://img.shields.io/travis/TheAlgorithms/Python.svg?label=Travis%20CI&logo=travis&style=flat-square)](https://travis-ci.org/TheAlgorithms/Python)&nbsp;
+[![LGTM](https://img.shields.io/lgtm/alerts/github/TheAlgorithms/Python.svg?label=LGTM&logo=LGTM&style=flat-square)](https://lgtm.com/projects/g/TheAlgorithms/Python/alerts)&nbsp;
+[![Gitter chat](https://img.shields.io/badge/Chat-Gitter-ff69b4.svg?label=Chat&logo=gitter&style=flat-square)](https://gitter.im/TheAlgorithms)&nbsp;
+[![contributions welcome](https://img.shields.io/static/v1.svg?label=Contributions&message=Welcome&color=0059b3&style=flat-square)](https://github.com/TheAlgorithms/Python/blob/master/CONTRIBUTING.md)&nbsp;
+![](https://img.shields.io/github/repo-size/TheAlgorithms/Python.svg?label=Repo%20size&style=flat-square)&nbsp;
+<!--[![Tested on Python 3.7](https://img.shields.io/badge/Tested%20-Python%203.7-blue.svg?logo=python&style=flat-square)]( https://www.python.org/downloads) &nbsp;-->
 ### All algorithms implemented in Python (for education)
 
 These implementations are for learning purposes. They may be less efficient than the implementations in the Python standard library.
@@ -24,6 +26,8 @@ Chetan Kaushik
 
 Read our [Contribution Guidelines](CONTRIBUTING.md) before you contribute.
 
+[![Open in Gitpod](https://gitpod.io/button/open-in-gitpod.svg?style=flat-square)](https://gitpod.io/#https://github.com/TheAlgorithms/Python)
+
 ## Community Channel
 
 We're on [Gitter](https://gitter.im/TheAlgorithms)! Please join us.

From 3c8e9314b6b36b3721d9df50ffd7dc20bfb2fc7d Mon Sep 17 00:00:00 2001
From: Christian Clauss <cclauss@me.com>
Date: Thu, 25 Jul 2019 09:49:00 +0200
Subject: [PATCH 145/348] Travis CI: Add a flake8 test for unused imports
 (#1038)

---
 .travis.yml                      |   2 +-
 graphs/bfs.py                    |  21 +-
 maths/volume.py                  |  10 +-
 other/primelib.py                | 390 +++++++++++++++----------------
 project_euler/problem_13/sol1.py |  10 +-
 5 files changed, 212 insertions(+), 221 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index bea512264c19..6d432c660ddd 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -6,7 +6,7 @@ before_install: pip install --upgrade pip setuptools
 install: pip install -r requirements.txt
 before_script:
   - black --check . || true
-  - flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
+  - flake8 . --count --select=E9,F401,F63,F7,F82 --show-source --statistics
 script:
   - mypy --ignore-missing-imports .
   - pytest . --doctest-modules
diff --git a/graphs/bfs.py b/graphs/bfs.py
index 6bbdd9e25435..ebbde0c82ce6 100644
--- a/graphs/bfs.py
+++ b/graphs/bfs.py
@@ -16,10 +16,19 @@
 
 """
 
-import collections
+G = {'A': ['B', 'C'],
+     'B': ['A', 'D', 'E'],
+     'C': ['A', 'F'],
+     'D': ['B'],
+     'E': ['B', 'F'],
+     'F': ['C', 'E']}
 
 
 def bfs(graph, start):
+    """
+    >>> ''.join(sorted(bfs(G, 'A')))
+    'ABCDEF'
+    """
     explored, queue = set(), [start]  # collections.deque([start])
     explored.add(start)
     while queue:
@@ -31,11 +40,5 @@ def bfs(graph, start):
     return explored
 
 
-G = {'A': ['B', 'C'],
-     'B': ['A', 'D', 'E'],
-     'C': ['A', 'F'],
-     'D': ['B'],
-     'E': ['B', 'F'],
-     'F': ['C', 'E']}
-
-print(bfs(G, 'A'))
+if __name__ == '__main__':
+    print(bfs(G, 'A'))
diff --git a/maths/volume.py b/maths/volume.py
index 171bc538f5a4..38de7516d9b2 100644
--- a/maths/volume.py
+++ b/maths/volume.py
@@ -6,8 +6,6 @@
 
 from math import pi
 
-PI = pi
-
 
 def vol_cube(side_length):
     """Calculate the Volume of a Cube."""
@@ -39,9 +37,7 @@ def vol_right_circ_cone(radius, height):
     volume = (1/3) * pi * radius^2 * height
     """
 
-    import math
-
-    return (float(1) / 3) * PI * (radius ** 2) * height
+    return (float(1) / 3) * pi * (radius ** 2) * height
 
 
 def vol_prism(area_of_base, height):
@@ -71,7 +67,7 @@ def vol_sphere(radius):
     V = (4/3) * pi * r^3
     Wikipedia reference: https://en.wikipedia.org/wiki/Sphere
     """
-    return (float(4) / 3) * PI * radius ** 3
+    return (float(4) / 3) * pi * radius ** 3
 
 
 def vol_circular_cylinder(radius, height):
@@ -80,7 +76,7 @@ def vol_circular_cylinder(radius, height):
     Wikipedia reference: https://en.wikipedia.org/wiki/Cylinder
     volume = pi * radius^2 * height
     """
-    return PI * radius ** 2 * height
+    return pi * radius ** 2 * height
 
 
 def main():
diff --git a/other/primelib.py b/other/primelib.py
index c371bc1b9861..c000213a7a42 100644
--- a/other/primelib.py
+++ b/other/primelib.py
@@ -16,7 +16,7 @@
 greatestPrimeFactor(number)
 smallestPrimeFactor(number)
 getPrime(n)
-getPrimesBetween(pNumber1, pNumber2) 
+getPrimesBetween(pNumber1, pNumber2)
 
 ----
 
@@ -39,34 +39,36 @@
 
 """
 
+from math import sqrt
+
+
 def isPrime(number):
     """
         input: positive integer 'number'
         returns true if 'number' is prime otherwise false.
     """
-    import math # for function sqrt
-    
+
     # precondition
     assert isinstance(number,int) and (number >= 0) , \
     "'number' must been an int and positive"
-    
+
     status = True
-    
-    # 0 and 1 are none primes. 
+
+    # 0 and 1 are none primes.
     if number <= 1:
         status = False
-    
-    for divisor in range(2,int(round(math.sqrt(number)))+1):
-        
+
+    for divisor in range(2,int(round(sqrt(number)))+1):
+
         # if 'number' divisible by 'divisor' then sets 'status'
-        # of false and break up the loop. 
+        # of false and break up the loop.
         if number % divisor == 0:
             status = False
             break
-    
+
     # precondition
-    assert isinstance(status,bool), "'status' must been from type bool"    
-    
+    assert isinstance(status,bool), "'status' must been from type bool"
+
     return status
 
 # ------------------------------------------
@@ -75,37 +77,37 @@ def sieveEr(N):
     """
         input: positive integer 'N' > 2
         returns a list of prime numbers from 2 up to N.
-        
+
         This function implements the algorithm called
-        sieve of erathostenes.         
-        
+        sieve of erathostenes.
+
     """
-    
+
     # precondition
     assert isinstance(N,int) and (N > 2), "'N' must been an int and > 2"
-    
+
     # beginList: conatins all natural numbers from 2 upt to N
     beginList = [x for x in range(2,N+1)]
 
-    ans = [] # this list will be returns.     
-    
+    ans = [] # this list will be returns.
+
     # actual sieve of erathostenes
     for i in range(len(beginList)):
-        
+
         for j in range(i+1,len(beginList)):
-            
+
             if (beginList[i] != 0) and \
             (beginList[j] % beginList[i] == 0):
                 beginList[j] = 0
-    
-    # filters actual prime numbers.           
+
+    # filters actual prime numbers.
     ans = [x for x in beginList if x != 0]
-    
+
     # precondition
-    assert isinstance(ans,list), "'ans' must been from type list"    
-    
+    assert isinstance(ans,list), "'ans' must been from type list"
+
     return ans
-    
+
 
 # --------------------------------
 
@@ -114,203 +116,201 @@ def getPrimeNumbers(N):
         input: positive integer 'N' > 2
         returns a list of prime numbers from 2 up to N (inclusive)
         This function is more efficient as function 'sieveEr(...)'
-    """    
-    
+    """
+
     # precondition
     assert isinstance(N,int) and (N > 2), "'N' must been an int and > 2"
-    
-    ans = []    
-    
-    # iterates over all numbers between 2 up to N+1 
+
+    ans = []
+
+    # iterates over all numbers between 2 up to N+1
     # if a number is prime then appends to list 'ans'
     for number in range(2,N+1):
-        
+
         if isPrime(number):
-            
+
             ans.append(number)
-   
+
     # precondition
     assert isinstance(ans,list), "'ans' must been from type list"
-        
+
     return ans
 
 
 # -----------------------------------------
-    
+
 def primeFactorization(number):
     """
-        input: positive integer 'number' 
+        input: positive integer 'number'
         returns a list of the prime number factors of 'number'
     """
 
-    import math    # for function sqrt
-    
     # precondition
     assert isinstance(number,int) and number >= 0, \
     "'number' must been an int and >= 0"
-    
+
     ans = [] # this list will be returns of the function.
 
     # potential prime number factors.
 
-    factor = 2    
+    factor = 2
 
     quotient = number
-    
-    
+
+
     if number == 0 or number == 1:
-        
+
         ans.append(number)
-        
-    # if 'number' not prime then builds the prime factorization of 'number'    
+
+    # if 'number' not prime then builds the prime factorization of 'number'
     elif not isPrime(number):
-    
+
         while (quotient != 1):
-            
+
             if isPrime(factor) and (quotient % factor == 0):
                     ans.append(factor)
                     quotient /= factor
             else:
                     factor += 1
-    
+
     else:
         ans.append(number)
-    
+
     # precondition
-    assert isinstance(ans,list), "'ans' must been from type list"    
-    
+    assert isinstance(ans,list), "'ans' must been from type list"
+
     return ans
-    
+
 
 # -----------------------------------------
-    
+
 def greatestPrimeFactor(number):
     """
         input: positive integer 'number' >= 0
         returns the greatest prime number factor of 'number'
     """
-    
+
     # precondition
     assert isinstance(number,int) and (number >= 0), \
     "'number' bust been an int and >= 0"
-    
-    ans = 0    
-    
+
+    ans = 0
+
     # prime factorization of 'number'
     primeFactors = primeFactorization(number)
 
-    ans = max(primeFactors)     
-    
+    ans = max(primeFactors)
+
     # precondition
-    assert isinstance(ans,int), "'ans' must been from type int"    
-    
+    assert isinstance(ans,int), "'ans' must been from type int"
+
     return ans
-    
+
 
 # ----------------------------------------------
-    
-    
+
+
 def smallestPrimeFactor(number):
     """
         input: integer 'number' >= 0
         returns the smallest prime number factor of 'number'
     """
-    
+
     # precondition
     assert isinstance(number,int) and (number >= 0), \
     "'number' bust been an int and >= 0"
-    
-    ans = 0    
-    
+
+    ans = 0
+
     # prime factorization of 'number'
     primeFactors = primeFactorization(number)
-    
+
     ans = min(primeFactors)
 
     # precondition
-    assert isinstance(ans,int), "'ans' must been from type int"    
-    
+    assert isinstance(ans,int), "'ans' must been from type int"
+
     return ans
-    
-    
+
+
 # ----------------------
-    
+
 def isEven(number):
     """
         input: integer 'number'
         returns true if 'number' is even, otherwise false.
-    """   
+    """
 
     # precondition
-    assert isinstance(number, int), "'number' must been an int" 
+    assert isinstance(number, int), "'number' must been an int"
     assert isinstance(number % 2 == 0, bool), "compare bust been from type bool"
-    
+
     return number % 2 == 0
-    
+
 # ------------------------
-    
+
 def isOdd(number):
     """
         input: integer 'number'
         returns true if 'number' is odd, otherwise false.
-    """   
+    """
 
     # precondition
-    assert isinstance(number, int), "'number' must been an int" 
+    assert isinstance(number, int), "'number' must been an int"
     assert isinstance(number % 2 != 0, bool), "compare bust been from type bool"
-    
+
     return number % 2 != 0
-    
+
 # ------------------------
-    
-    
+
+
 def goldbach(number):
     """
         Goldbach's assumption
         input: a even positive integer 'number' > 2
         returns a list of two prime numbers whose sum is equal to 'number'
     """
-    
+
     # precondition
     assert isinstance(number,int) and (number > 2) and isEven(number), \
     "'number' must been an int, even and > 2"
-    
+
     ans = [] # this list will returned
-    
+
     # creates a list of prime numbers between 2 up to 'number'
     primeNumbers = getPrimeNumbers(number)
-    lenPN = len(primeNumbers)    
+    lenPN = len(primeNumbers)
 
     # run variable for while-loops.
     i = 0
     j = None
-    
+
     # exit variable. for break up the loops
     loop = True
-    
+
     while (i < lenPN and loop):
-        
+
         j = i+1
-        
-        
+
+
         while (j < lenPN and loop):
-            
+
             if primeNumbers[i] + primeNumbers[j] == number:
                 loop = False
                 ans.append(primeNumbers[i])
                 ans.append(primeNumbers[j])
-                
+
             j += 1
 
         i += 1
-        
+
     # precondition
     assert isinstance(ans,list) and (len(ans) == 2) and \
     (ans[0] + ans[1] == number) and isPrime(ans[0]) and isPrime(ans[1]), \
     "'ans' must contains two primes. And sum of elements must been eq 'number'"
-        
+
     return ans
-    
+
 # ----------------------------------------------
 
 def gcd(number1,number2):
@@ -319,173 +319,173 @@ def gcd(number1,number2):
         input: two positive integer 'number1' and 'number2'
         returns the greatest common divisor of 'number1' and 'number2'
     """
-    
+
     # precondition
     assert isinstance(number1,int) and isinstance(number2,int) \
     and (number1 >= 0) and (number2 >= 0), \
     "'number1' and 'number2' must been positive integer."
 
-    rest = 0    
-    
+    rest = 0
+
     while number2 != 0:
-        
+
         rest = number1 % number2
         number1 = number2
         number2 = rest
 
     # precondition
     assert isinstance(number1,int) and (number1 >= 0), \
-    "'number' must been from type int and positive"    
-    
+    "'number' must been from type int and positive"
+
     return number1
-    
+
 # ----------------------------------------------------
-    
+
 def kgV(number1, number2):
     """
         Least common multiple
         input: two positive integer 'number1' and 'number2'
         returns the least common multiple of 'number1' and 'number2'
     """
-    
+
     # precondition
     assert isinstance(number1,int) and isinstance(number2,int) \
     and (number1 >= 1) and (number2 >= 1), \
     "'number1' and 'number2' must been positive integer."
-    
+
     ans = 1 # actual answer that will be return.
-     
+
     # for kgV (x,1)
     if number1 > 1 and number2 > 1:
-        
+
         # builds the prime factorization of 'number1' and 'number2'
         primeFac1 = primeFactorization(number1)
         primeFac2 = primeFactorization(number2)
-        
+
     elif number1 == 1 or number2 == 1:
-        
+
         primeFac1 = []
         primeFac2 = []
         ans = max(number1,number2)
-    
+
     count1 = 0
     count2 = 0
-     
+
     done = [] # captured numbers int both 'primeFac1' and 'primeFac2'
-    
+
     # iterates through primeFac1
     for n in primeFac1:
-        
+
         if n not in done:
-        
+
             if n in primeFac2:
-            
+
                 count1 = primeFac1.count(n)
                 count2 = primeFac2.count(n)
-            
+
                 for i in range(max(count1,count2)):
                     ans *= n
-        
+
             else:
-                
+
                 count1 = primeFac1.count(n)
-                
+
                 for i in range(count1):
                     ans *= n
-                    
+
             done.append(n)
-    
+
     # iterates through primeFac2
     for n in primeFac2:
-        
+
         if n not in done:
-            
+
             count2 = primeFac2.count(n)
-            
+
             for i in range(count2):
                 ans *= n
-                    
+
             done.append(n)
-    
+
     # precondition
     assert isinstance(ans,int) and (ans >= 0), \
-    "'ans' must been from type int and positive"    
-    
+    "'ans' must been from type int and positive"
+
     return ans
-    
+
 # ----------------------------------
-    
+
 def getPrime(n):
     """
         Gets the n-th prime number.
         input: positive integer 'n' >= 0
         returns the n-th prime number, beginning at index 0
     """
-    
+
     # precondition
     assert isinstance(n,int) and (n >= 0), "'number' must been a positive int"
-    
+
     index = 0
     ans = 2 # this variable holds the answer
-    
+
     while index < n:
-        
+
         index += 1
-        
-        ans += 1   # counts to the next number     
-        
+
+        ans += 1   # counts to the next number
+
         # if ans not prime then
-        # runs to the next prime number. 
+        # runs to the next prime number.
         while not isPrime(ans):
             ans += 1
-    
+
     # precondition
     assert isinstance(ans,int) and isPrime(ans), \
-    "'ans' must been a prime number and from type int"    
-    
+    "'ans' must been a prime number and from type int"
+
     return ans
-    
+
 # ---------------------------------------------------
-    
+
 def getPrimesBetween(pNumber1, pNumber2):
     """
         input: prime numbers 'pNumber1' and 'pNumber2'
                 pNumber1 < pNumber2
         returns a list of all prime numbers between 'pNumber1' (exclusiv)
-                and 'pNumber2' (exclusiv) 
+                and 'pNumber2' (exclusiv)
     """
-    
+
     # precondition
     assert isPrime(pNumber1) and isPrime(pNumber2) and (pNumber1 < pNumber2), \
     "The arguments must been prime numbers and 'pNumber1' < 'pNumber2'"
-    
+
     number = pNumber1 + 1 # jump to the next number
-    
+
     ans = [] # this list will be returns.
-    
+
     # if number is not prime then
-    # fetch the next prime number. 
+    # fetch the next prime number.
     while not isPrime(number):
         number += 1
-    
+
     while number < pNumber2:
-        
+
         ans.append(number)
-        
+
         number += 1
-        
-        # fetch the next prime number. 
+
+        # fetch the next prime number.
         while not isPrime(number):
             number += 1
-            
+
     # precondition
     assert isinstance(ans,list) and ans[0] != pNumber1 \
     and ans[len(ans)-1] != pNumber2, \
     "'ans' must been a list without the arguments"
-            
+
     # 'ans' contains not 'pNumber1' and 'pNumber2' !
     return ans
-    
+
 # ----------------------------------------------------
 
 def getDivisors(n):
@@ -493,25 +493,23 @@ def getDivisors(n):
         input: positive integer 'n' >= 1
         returns all divisors of n (inclusive 1 and 'n')
     """
-    
+
     # precondition
     assert isinstance(n,int) and (n >= 1), "'n' must been int and >= 1"
 
-    from math import sqrt        
-        
     ans = [] # will be returned.
-    
+
     for divisor in range(1,n+1):
-        
+
         if n % divisor == 0:
             ans.append(divisor)
-       
-       
+
+
     #precondition
     assert ans[0] == 1 and ans[len(ans)-1] == n, \
     "Error in function getDivisiors(...)"
-    
-    
+
+
     return ans
 
 
@@ -523,18 +521,18 @@ def isPerfectNumber(number):
         input: positive integer 'number' > 1
         returns true if 'number' is a perfect number otherwise false.
     """
-    
+
     # precondition
     assert isinstance(number,int) and (number > 1), \
     "'number' must been an int and >= 1"
-    
+
     divisors = getDivisors(number)
- 
+
     # precondition
     assert isinstance(divisors,list) and(divisors[0] == 1) and  \
     (divisors[len(divisors)-1] == number), \
     "Error in help-function getDivisiors(...)"
-    
+
     # summed all divisors up to 'number' (exclusive), hence [:-1]
     return sum(divisors[:-1]) == number
 
@@ -545,13 +543,13 @@ def simplifyFraction(numerator, denominator):
         input: two integer 'numerator' and 'denominator'
         assumes: 'denominator' != 0
         returns: a tuple with simplify numerator and denominator.
-    """      
-    
+    """
+
     # precondition
     assert isinstance(numerator, int) and isinstance(denominator,int) \
     and (denominator != 0), \
     "The arguments must been from type int and 'denominator' != 0"
-    
+
     # build the greatest common divisor of numerator and denominator.
     gcdOfFraction = gcd(abs(numerator), abs(denominator))
 
@@ -559,46 +557,46 @@ def simplifyFraction(numerator, denominator):
     assert isinstance(gcdOfFraction, int) and (numerator % gcdOfFraction == 0) \
     and (denominator % gcdOfFraction == 0), \
     "Error in function gcd(...,...)"
-    
+
     return (numerator // gcdOfFraction, denominator // gcdOfFraction)
-    
+
 # -----------------------------------------------------------------
-    
+
 def factorial(n):
     """
         input: positive integer 'n'
         returns the factorial of 'n' (n!)
     """
-    
+
     # precondition
     assert isinstance(n,int) and (n >= 0), "'n' must been a int and >= 0"
-    
+
     ans = 1 # this will be return.
-    
+
     for factor in range(1,n+1):
         ans *= factor
-    
+
     return ans
-    
+
 # -------------------------------------------------------------------
-    
+
 def fib(n):
     """
         input: positive integer 'n'
         returns the n-th fibonacci term , indexing by 0
-    """  
-    
+    """
+
     # precondition
     assert isinstance(n, int) and (n >= 0), "'n' must been an int and >= 0"
-    
+
     tmp = 0
     fib1 = 1
     ans = 1 # this will be return
-    
+
     for i in range(n-1):
-        
+
         tmp = ans
         ans += fib1
         fib1 = tmp
-        
+
     return ans
diff --git a/project_euler/problem_13/sol1.py b/project_euler/problem_13/sol1.py
index 983347675b3f..e36065ec8e11 100644
--- a/project_euler/problem_13/sol1.py
+++ b/project_euler/problem_13/sol1.py
@@ -3,18 +3,12 @@
 Work out the first ten digits of the sum of the following one-hundred 50-digit
 numbers.
 """
-from __future__ import print_function
-import os
-
-try:
-    raw_input  # Python 2
-except NameError:
-    raw_input = input  # Python 3
 
 
 def solution(array):
     """Returns the first ten digits of the sum of the array elements.
-    
+
+    >>> import os
     >>> sum = 0
     >>> array = []
     >>> with open(os.path.dirname(__file__) + "/num.txt","r") as f:

From c27bd5144fd48c1a30d10f0d230fabb4fd0b3925 Mon Sep 17 00:00:00 2001
From: QuantumNovice <43876848+QuantumNovice@users.noreply.github.com>
Date: Thu, 25 Jul 2019 23:38:24 +0500
Subject: [PATCH 146/348] in_static_equilibrium checks if a 2D static system is
 in equilibrium (#1062)

* Add files via upload

* Add files via upload

* Create .a

* Add files via upload

* Add files via upload

* Rename static_solver.py to in_static_equilibrium.py

* Delete .a

* Update in_static_equilibrium.py

* Add files via upload

* Add files via upload

* Update in_static_equilibrium.py

* Add files via upload

* Add files via upload

* Add files via upload

* Add files via upload

* pyTests added

* Add files via upload

* Delete red_black_tree.py

* Add files via upload
---
 .../image_data/2D_problems.JPG                |  Bin 0 -> 58752 bytes
 .../image_data/2D_problems_1.JPG              |  Bin 0 -> 41392 bytes
 arithmetic_analysis/in_static_equilibrium.py  |   89 ++
 data_structures/binary_tree/red_black_tree.py | 1376 +++++++++--------
 4 files changed, 800 insertions(+), 665 deletions(-)
 create mode 100644 arithmetic_analysis/image_data/2D_problems.JPG
 create mode 100644 arithmetic_analysis/image_data/2D_problems_1.JPG
 create mode 100644 arithmetic_analysis/in_static_equilibrium.py

diff --git a/arithmetic_analysis/image_data/2D_problems.JPG b/arithmetic_analysis/image_data/2D_problems.JPG
new file mode 100644
index 0000000000000000000000000000000000000000..8887cf6416856496c3bb725e0e8ca3b517370cc0
GIT binary patch
literal 58752
zcmeFYbyQs2)-PBD2!!D7P6+PqA$X8Lf=h4;f)-LZgamg2B)Gc-LQ%L&2*E8B65OQ<
zEeP`JoO}D;+pq5*-|hE}9^L)Ut}#c=+I#J_*8HuxcTHROKkrungzCy_$^bMpG{76w
z2XMbiIH?2%+5rHXngC7!0Duj^K$8MIKyetVmLNa`5P*T=(NGuEv$FsAMzsJC_UzFD
zuuv>6>bES40JM95yYdJB*YOtue<AP}0)HX!7Xp7F@V_Afn2G3rS`eftOW{)@#y|L~
z<fK1&bU|SNAUXM;{6DP;?ASl>`pcU5-%xA*68SF#{zBj{1pY$cF9iMt0YQEN2}yo2
zNkKtIL4HXAVMzfIz`r{O0H^{i0U*?!_p6V|9XvhVB>DJUK)jYVu2#0Z)~?QcU`sbX
z0bYJSfV3Rg&C=S*)|1i7)*k30!+zY_$<7G0kzqFw(d5^3Q?zves``1@>iKECvi5Vb
zmat)$lf}c421|mS-JESbEg8YiZ(Tr=U>W8=dzVD<f1KuHmX-Ffv6Iw&uKf2Fs9!S7
zf1itwj}Nbp5U;C;J)eMtgajYIAfKQh52^(Z$k)Zw63pWQV)=Uq&uu~09zZuwpsNex
zA01j+xq5lZFnf6cZ6xh1?L@3>Y(#jhEQM@%1O#j>c`R*&1bA$Oglxn_1jGgH1gx0<
zKD>?fKSp=+@_75_*f!RDwr_2nZCyM;C^Q84nEC!T>Hn@VQ4sxO(0>a*N=8&0NktD^
zOHbS9D3bkSIeGZScmxGs{U1xrD<~u?&G$dGlji#ajDMNvfA7ryOK8bT+gM9l|1o!0
zkG~DCXY2mIw%TujvZzqo--JW)e`8R+qEznDqes$w|2p9R6@fp`pfnD3-#_#dbtmKh
z1IJ&3{6`@F1=nA2{YMD=M~(l|uD{^=j}Z8e8vmtT{~v?vpEj<o3(BzdL0Pc(3jjp`
z7AEFHObo1tm=CeBu&{B69;0jw95MnzTp~&`YAQ-HN(vf!b|xA+HaZGQW?p8tryN||
zT-1zwLVTQp?3`Sje{_O|g^i8#2#56XV^U69N?OkU__*%^5MiU8q1&RPF#{eDp`jC@
z-S+_)P<cj7RA%yz<mBHEv<K)Im=CeAAK^SkHGmKT9-yJ4Kfpl8#Kb_QCD8&=*8vzr
zn8Zv13J*zMT4FJ~lM03=<zurvtLrAyoq)3nS$VvBghNh2Nkz@}g#9T8r?7~qn7D+b
z;&UZs6;(BLy;raG4GfKpt!-@W>>YrPAWtuEAF!`q*!vIR5s^{R$tfRG)6zeE&L}7>
zDlRE4E3c^k+5l;UHZ`~O^!D`+41OE>J~=f#GduTl9=5u+zOlKry|cTAI5|B#zqmwR
zUH>5$8UX!oV*Nw1|4A+)lw1!mFwilu{*Vjpfe(t%i7+sk1RfGAyu`9}Ct(&0#U_20
zlwa5Vh($;jPG;pXfkVzJyvm07L$p67`>zT1?*Eo#{}Ak-a=`$&=xC_LLni{r0j`y!
zpXNRIe-Yu{>R&jCkM|I!jru$Yl-W<6zA>sWfuyIUeah5nY<yd2|F*tDfI&=$x<w}V
z_LT*kZ`brm^JT->Z#>{V;956TY`W6H&+p<|?=+*<7lfCcl`ba8t<(2mS$QYVL+zqQ
zrE8geMp~g_KkXV)F(1Q~`kUMO*q68UBea7vO3LwRK?u(O&qz?@1jB86di|_c3=v;l
z>X7F576v(NuLyRUZ@G$BuvMGM?g)9H>8IRzS0b=Sb8QeG@CvR8jpb=*^e^Y()jgq6
zTIXs6J|KxlF6A00G+4~bQ1o916|RNXP3C>oNFZ2}Y|Iz5@YO;Dd$|c3%wgErxX;$#
zh^+Eh^yZS(9y@bi>=-0++YFbrow%A>!mr*E3cOpiYrLTn=}0MEK<X<w*iA7R64~7Y
z((1~(-1qRjY<-8eGwQJ>lt=+D{~JhOxqU5;p;!OTrPePoS+FkQ^TJMH?qIRg938?;
z0cl@B{7@l+{#S=O>^+Nal_gK6YA=z5UNOg@XQm_`x^Y;aBwa_jL$V6qz*-C=S_rN|
zmi=VIqsP;0&DtOC0VkTC374$*fQdLWJ-E=#u730fBc->QbdQ=RV{;CfG|E^>zEKIg
z(13DeoIW53`cx*Qm3)fk!64lkn+AwU^YTPtPd<Ci7Q>QAL}`Fig5H;gX)Aa~HGQ_1
zH;?S>79Xz|4>U{E@3+44U?o>&;8ccb^lF24q|V;5L^Hg3(zTj5KjepPR>`1gyz(QN
zes34;0D@X|K)Ty`A#;J<6<GTGVX7gSG*P0gBOvh$Alc8Wc+`>hVk7k^I65oP1Wt<f
zMA=<|(W~r4i-6^)PvH)B9#-1R*qrvK%WbDq)$ZmZh`u1~@MZsM&b^c6Bb_*DHg9FM
zK?%mY*E4OI6eF+gdx%-+w5isYLwFugDPS>P<`McC(5)OZ^sXIh8%z~W9aY&+ZaiXM
zbiS(BenGNp_U5QG%WDLnnWUtgXDyxRN1*Q3bv=$=E{48b$kUA>7~fj1l25f>4Uj|0
z;5I7s(%#!|RZF&k%hrG^!FpN;qoO<f)rQWG3c<k#&2j$yNjpJIlb+4Ozbnf{Bt)wc
zL+k0~hl9K(VukDz<+1^4O#m%0DV9DJmdFS=p`Q@x@mmv;@qKImx4JcsuRK|7X!gjV
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

literal 0
HcmV?d00001

diff --git a/arithmetic_analysis/image_data/2D_problems_1.JPG b/arithmetic_analysis/image_data/2D_problems_1.JPG
new file mode 100644
index 0000000000000000000000000000000000000000..aa9f4536201498e50d1d3d50f88143f700ed32b9
GIT binary patch
literal 41392
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
Dx^_5`

literal 0
HcmV?d00001

diff --git a/arithmetic_analysis/in_static_equilibrium.py b/arithmetic_analysis/in_static_equilibrium.py
new file mode 100644
index 000000000000..48eb6135eba7
--- /dev/null
+++ b/arithmetic_analysis/in_static_equilibrium.py
@@ -0,0 +1,89 @@
+"""
+Checks if a system of forces is in static equilibrium.
+
+python/black : true
+flake8 : passed
+mypy : passed
+"""
+
+from numpy import array, cos, sin, radians, cross  # type: ignore
+from typing import List
+
+
+def polar_force(
+    magnitude: float, angle: float, radian_mode: bool = False
+) -> List[float]:
+    """
+    Resolves force along rectangular components.
+    (force, angle) => (force_x, force_y)
+    >>> polar_force(10, 45)
+    [7.0710678118654755, 7.071067811865475]
+    >>> polar_force(10, 3.14, radian_mode=True)
+    [-9.999987317275394, 0.01592652916486828]
+    """
+    if radian_mode:
+        return [magnitude * cos(angle), magnitude * sin(angle)]
+    return [magnitude * cos(radians(angle)), magnitude * sin(radians(angle))]
+
+
+def in_static_equilibrium(
+    forces: array, location: array, eps: float = 10 ** -1
+) -> bool:
+    """
+    Check if a system is in equilibrium.
+    It takes two numpy.array objects.
+    forces ==>  [
+                        [force1_x, force1_y],
+                        [force2_x, force2_y],
+                        ....]
+    location ==>  [
+                        [x1, y1],
+                        [x2, y2],
+                        ....]
+    >>> force = array([[1, 1], [-1, 2]])
+    >>> location = array([[1, 0], [10, 0]])
+    >>> in_static_equilibrium(force, location)
+    False
+    """
+    # summation of moments is zero
+    moments: array = cross(location, forces)
+    sum_moments: float = sum(moments)
+    return abs(sum_moments) < eps
+
+
+if __name__ == "__main__":
+    # Test to check if it works
+    forces = array(
+        [
+            polar_force(718.4, 180 - 30),
+            polar_force(879.54, 45),
+            polar_force(100, -90)
+        ])
+
+    location = array([[0, 0], [0, 0], [0, 0]])
+
+    assert in_static_equilibrium(forces, location)
+
+    # Problem 1 in image_data/2D_problems.jpg
+    forces = array(
+        [
+            polar_force(30 * 9.81, 15),
+            polar_force(215, 180 - 45),
+            polar_force(264, 90 - 30),
+        ]
+    )
+
+    location = array([[0, 0], [0, 0], [0, 0]])
+
+    assert in_static_equilibrium(forces, location)
+
+    # Problem in image_data/2D_problems_1.jpg
+    forces = array([[0, -2000], [0, -1200], [0, 15600], [0, -12400]])
+
+    location = array([[0, 0], [6, 0], [10, 0], [12, 0]])
+
+    assert in_static_equilibrium(forces, location)
+
+    import doctest
+
+    doctest.testmod()
diff --git a/data_structures/binary_tree/red_black_tree.py b/data_structures/binary_tree/red_black_tree.py
index 4ca1301dd8fe..526f5ec27987 100644
--- a/data_structures/binary_tree/red_black_tree.py
+++ b/data_structures/binary_tree/red_black_tree.py
@@ -1,665 +1,711 @@
-class RedBlackTree:
-    """
-    A Red-Black tree, which is a self-balancing BST (binary search
-    tree).
-
-    This tree has similar performance to AVL trees, but the balancing is
-    less strict, so it will perform faster for writing/deleting nodes
-    and slower for reading in the average case, though, because they're
-    both balanced binary search trees, both will get the same asymptotic
-    perfomance.
-
-    To read more about them, https://en.wikipedia.org/wiki/Red–black_tree
-
-    Unless otherwise specified, all asymptotic runtimes are specified in
-    terms of the size of the tree.
-    """
-    def __init__(self, label=None, color=0, parent=None, left=None, right=None):
-        """Initialize a new Red-Black Tree node with the given values:
-            label: The value associated with this node
-            color: 0 if black, 1 if red
-            parent: The parent to this node
-            left: This node's left child
-            right: This node's right child
-        """
-        self.label = label
-        self.parent = parent
-        self.left = left
-        self.right = right
-        self.color = color
-
-    # Here are functions which are specific to red-black trees
-
-    def rotate_left(self):
-        """Rotate the subtree rooted at this node to the left and
-        returns the new root to this subtree.
-
-        Perfoming one rotation can be done in O(1).
-        """
-        parent = self.parent
-        right = self.right
-        self.right = right.left
-        if self.right:
-            self.right.parent = self
-        self.parent = right
-        right.left = self
-        if parent is not None:
-            if parent.left is self:
-                parent.left = right
-            else:
-                parent.right = right
-        right.parent = parent
-        return right
-    
-    def rotate_right(self):
-        """Rotate the subtree rooted at this node to the right and
-        returns the new root to this subtree.
-
-        Performing one rotation can be done in O(1).
-        """
-        parent = self.parent
-        left = self.left
-        self.left = left.right
-        if self.left:
-            self.left.parent = self
-        self.parent = left
-        left.right = self
-        if parent is not None:
-            if parent.right is self:
-                parent.right = left
-            else:
-                parent.left = left
-        left.parent = parent
-        return left
-
-    def insert(self, label):
-        """Inserts label into the subtree rooted at self, performs any
-        rotations necessary to maintain balance, and then returns the
-        new root to this subtree (likely self).
-
-        This is guaranteed to run in O(log(n)) time.
-        """
-        if self.label is None:
-            # Only possible with an empty tree
-            self.label = label
-            return self
-        if self.label == label:
-            return self
-        elif self.label > label:
-            if self.left:
-                self.left.insert(label)
-            else:
-                self.left = RedBlackTree(label, 1, self)
-                self.left._insert_repair()
-        else:
-            if self.right:
-                self.right.insert(label)
-            else:
-                self.right = RedBlackTree(label, 1, self)
-                self.right._insert_repair()
-        return self.parent or self
-
-    def _insert_repair(self):
-        """Repair the coloring from inserting into a tree."""
-        if self.parent is None:
-            # This node is the root, so it just needs to be black
-            self.color = 0
-        elif color(self.parent) == 0:
-            # If the parent is black, then it just needs to be red
-            self.color = 1
-        else:
-            uncle = self.parent.sibling
-            if color(uncle) == 0:
-                if self.is_left() and self.parent.is_right():
-                    self.parent.rotate_right()
-                    self.right._insert_repair()
-                elif self.is_right() and self.parent.is_left():
-                    self.parent.rotate_left()
-                    self.left._insert_repair()
-                elif self.is_left():
-                    self.grandparent.rotate_right()
-                    self.parent.color = 0
-                    self.parent.right.color = 1
-                else:
-                    self.grandparent.rotate_left()
-                    self.parent.color = 0
-                    self.parent.left.color = 1
-            else:
-                self.parent.color = 0
-                uncle.color = 0
-                self.grandparent.color = 1
-                self.grandparent._insert_repair()
-
-    def remove(self, label):
-        """Remove label from this tree."""
-        if self.label == label:
-            if self.left and self.right:
-                # It's easier to balance a node with at most one child,
-                # so we replace this node with the greatest one less than
-                # it and remove that.
-                value = self.left.get_max()
-                self.label = value
-                self.left.remove(value)
-            else:
-                # This node has at most one non-None child, so we don't
-                # need to replace
-                child = self.left or self.right
-                if self.color == 1:
-                    # This node is red, and its child is black
-                    # The only way this happens to a node with one child
-                    # is if both children are None leaves.
-                    # We can just remove this node and call it a day.
-                    if self.is_left():
-                        self.parent.left = None
-                    else:
-                        self.parent.right = None
-                else:
-                    # The node is black
-                    if child is None:
-                        # This node and its child are black
-                        if self.parent is None:
-                            # The tree is now empty
-                            return RedBlackTree(None)
-                        else:
-                            self._remove_repair()
-                            if self.is_left():
-                                self.parent.left = None
-                            else:
-                                self.parent.right = None
-                            self.parent = None
-                    else:
-                        # This node is black and its child is red
-                        # Move the child node here and make it black
-                        self.label = child.label
-                        self.left = child.left
-                        self.right = child.right
-                        if self.left:
-                            self.left.parent = self
-                        if self.right:
-                            self.right.parent = self
-        elif self.label > label:
-            if self.left:
-                self.left.remove(label)
-        else:
-            if self.right:
-                self.right.remove(label)
-        return self.parent or self
-
-    def _remove_repair(self):
-        """Repair the coloring of the tree that may have been messed up."""
-        if color(self.sibling) == 1:
-            self.sibling.color = 0
-            self.parent.color = 1
-            if self.is_left():
-                self.parent.rotate_left()
-            else:
-                self.parent.rotate_right()
-        if color(self.parent) == 0 and color(self.sibling) == 0 \
-                and color(self.sibling.left) == 0 \
-                and color(self.sibling.right) == 0:
-            self.sibling.color = 1
-            self.parent._remove_repair()
-            return
-        if color(self.parent) == 1 and color(self.sibling) == 0 \
-                and color(self.sibling.left) == 0 \
-                and color(self.sibling.right) == 0:
-            self.sibling.color = 1
-            self.parent.color = 0
-            return
-        if (self.is_left() 
-                and color(self.sibling) == 0
-                and color(self.sibling.right) == 0
-                and color(self.sibling.left) == 1):
-            self.sibling.rotate_right()
-            self.sibling.color = 0
-            self.sibling.right.color = 1
-        if (self.is_right()
-                and color(self.sibling) == 0
-                and color(self.sibling.right) == 1
-                and color(self.sibling.left) == 0):
-            self.sibling.rotate_left()
-            self.sibling.color = 0
-            self.sibling.left.color = 1
-        if (self.is_left()
-                and color(self.sibling) == 0
-                and color(self.sibling.right) == 1):
-            self.parent.rotate_left()
-            self.grandparent.color = self.parent.color
-            self.parent.color = 0
-            self.parent.sibling.color = 0
-        if (self.is_right()
-                and color(self.sibling) == 0
-                and color(self.sibling.left) == 1):
-            self.parent.rotate_right()
-            self.grandparent.color = self.parent.color
-            self.parent.color = 0
-            self.parent.sibling.color = 0
-
-    def check_color_properties(self):
-        """Check the coloring of the tree, and return True iff the tree
-        is colored in a way which matches these five properties:
-        (wording stolen from wikipedia article)
-         1. Each node is either red or black.
-         2. The root node is black.
-         3. All leaves are black.
-         4. If a node is red, then both its children are black.
-         5. Every path from any node to all of its descendent NIL nodes
-            has the same number of black nodes.
-
-        This function runs in O(n) time, because properties 4 and 5 take
-        that long to check.
-        """
-        # I assume property 1 to hold because there is nothing that can
-        # make the color be anything other than 0 or 1.
-
-        # Property 2
-        if self.color:
-            # The root was red
-            print('Property 2')
-            return False;
-
-        # Property 3 does not need to be checked, because None is assumed
-        # to be black and is all the leaves.
-
-        # Property 4
-        if not self.check_coloring():
-            print('Property 4')
-            return False
-
-        # Property 5
-        if self.black_height() is None:
-            print('Property 5')
-            return False
-        # All properties were met
-        return True
-
-    def check_coloring(self):
-        """A helper function to recursively check Property 4 of a
-        Red-Black Tree. See check_color_properties for more info.
-        """
-        if self.color == 1:
-            if color(self.left) == 1 or color(self.right) == 1:
-                return False
-        if self.left and not self.left.check_coloring():
-            return False
-        if self.right and not self.right.check_coloring():
-            return False
-        return True
-
-    def black_height(self):
-        """Returns the number of black nodes from this node to the
-        leaves of the tree, or None if there isn't one such value (the
-        tree is color incorrectly).
-        """
-        if self is None:
-            # If we're already at a leaf, there is no path
-            return 1
-        left = RedBlackTree.black_height(self.left)
-        right = RedBlackTree.black_height(self.right)
-        if left is None or right is None:
-            # There are issues with coloring below children nodes
-            return None
-        if left != right:
-            # The two children have unequal depths
-            return None
-        # Return the black depth of children, plus one if this node is
-        # black
-        return left + (1-self.color)
-
-    # Here are functions which are general to all binary search trees
-
-    def __contains__(self, label):
-        """Search through the tree for label, returning True iff it is
-        found somewhere in the tree.
-        
-        Guaranteed to run in O(log(n)) time.
-        """
-        return self.search(label) is not None
-
-    def search(self, label):
-        """Search through the tree for label, returning its node if
-        it's found, and None otherwise.
-
-        This method is guaranteed to run in O(log(n)) time.
-        """
-        if self.label == label:
-            return self
-        elif label > self.label:
-            if self.right is None:
-                return None
-            else:
-                return self.right.search(label)
-        else:
-            if self.left is None:
-                return None
-            else:
-                return self.left.search(label)
-
-    def floor(self, label):
-        """Returns the largest element in this tree which is at most label.
-        
-        This method is guaranteed to run in O(log(n)) time."""
-        if self.label == label:
-            return self.label
-        elif self.label > label:
-            if self.left:
-                return self.left.floor(label)
-            else:
-                return None
-        else:
-            if self.right:
-                attempt = self.right.floor(label)
-                if attempt is not None:
-                    return attempt
-            return self.label
-
-    def ceil(self, label):
-        """Returns the smallest element in this tree which is at least label.
-        
-        This method is guaranteed to run in O(log(n)) time.
-        """
-        if self.label == label:
-            return self.label
-        elif self.label < label:
-            if self.right:
-                return self.right.ceil(label)
-            else:
-                return None
-        else:
-            if self.left:
-                attempt = self.left.ceil(label)
-                if attempt is not None:
-                    return attempt
-            return self.label
-
-    def get_max(self):
-        """Returns the largest element in this tree.
-
-        This method is guaranteed to run in O(log(n)) time.
-        """
-        if self.right:
-            # Go as far right as possible
-            return self.right.get_max()
-        else:
-            return self.label
-
-    def get_min(self):
-        """Returns the smallest element in this tree.
-
-        This method is guaranteed to run in O(log(n)) time.
-        """
-        if self.left:
-            # Go as far left as possible
-            return self.left.get_min()
-        else:
-            return self.label
-
-    @property
-    def grandparent(self):
-        """Get the current node's grandparent, or None if it doesn't exist."""
-        if self.parent is None:
-            return None
-        else:
-            return self.parent.parent
-    
-    @property
-    def sibling(self):
-        """Get the current node's sibling, or None if it doesn't exist."""
-        if self.parent is None:
-            return None
-        elif self.parent.left is self:
-            return self.parent.right
-        else:
-            return self.parent.left
-
-    def is_left(self):
-        """Returns true iff this node is the left child of its parent."""
-        return self.parent and self.parent.left is self
-
-    def is_right(self):
-        """Returns true iff this node is the right child of its parent."""
-        return self.parent and self.parent.right is self
-
-    def __bool__(self):
-        return True
-
-    def __len__(self):
-        """
-        Return the number of nodes in this tree.
-        """
-        ln = 1
-        if self.left:
-            ln += len(self.left)
-        if self.right:
-            ln += len(self.right)
-        return ln
-
-    def preorder_traverse(self):
-        yield self.label
-        if self.left:
-            yield from self.left.preorder_traverse()
-        if self.right:
-            yield from self.right.preorder_traverse()
-
-    def inorder_traverse(self):
-        if self.left:
-            yield from self.left.inorder_traverse()
-        yield self.label
-        if self.right:
-            yield from self.right.inorder_traverse()
-
-
-    def postorder_traverse(self):
-        if self.left:
-            yield from self.left.postorder_traverse()
-        if self.right:
-            yield from self.right.postorder_traverse()
-        yield self.label
-
-    def __repr__(self):
-        from pprint import pformat
-        if self.left is None and self.right is None:
-            return "'%s %s'" % (self.label, (self.color and 'red') or 'blk')
-        return pformat({'%s %s' % (self.label, (self.color and 'red') or 'blk'):
-                            (self.left, self.right)},
-                       indent=1)
-
-    def __eq__(self, other):
-        """Test if two trees are equal."""
-        if self.label == other.label:
-            return self.left == other.left and self.right == other.right
-        else:
-            return False
-
-def color(node):
-    """Returns the color of a node, allowing for None leaves."""
-    if node is None:
-        return 0
-    else:
-        return node.color
-
-"""
-Code for testing the various functions of the red-black tree.
-"""
-
-def test_rotations():
-    """Test that the rotate_left and rotate_right functions work."""
-    # Make a tree to test on
-    tree = RedBlackTree(0)
-    tree.left = RedBlackTree(-10, parent=tree)
-    tree.right = RedBlackTree(10, parent=tree)
-    tree.left.left = RedBlackTree(-20, parent=tree.left)
-    tree.left.right = RedBlackTree(-5, parent=tree.left)
-    tree.right.left = RedBlackTree(5, parent=tree.right)
-    tree.right.right = RedBlackTree(20, parent=tree.right)
-    # Make the right rotation
-    left_rot = RedBlackTree(10)
-    left_rot.left = RedBlackTree(0, parent=left_rot)
-    left_rot.left.left = RedBlackTree(-10, parent=left_rot.left)
-    left_rot.left.right = RedBlackTree(5, parent=left_rot.left)
-    left_rot.left.left.left = RedBlackTree(-20, parent=left_rot.left.left)
-    left_rot.left.left.right = RedBlackTree(-5, parent=left_rot.left.left)
-    left_rot.right = RedBlackTree(20, parent=left_rot)
-    tree = tree.rotate_left()
-    if tree != left_rot:
-        return False
-    tree = tree.rotate_right()
-    tree = tree.rotate_right()
-    # Make the left rotation
-    right_rot = RedBlackTree(-10)
-    right_rot.left = RedBlackTree(-20, parent=right_rot)
-    right_rot.right = RedBlackTree(0, parent=right_rot)
-    right_rot.right.left = RedBlackTree(-5, parent=right_rot.right)
-    right_rot.right.right = RedBlackTree(10, parent=right_rot.right)
-    right_rot.right.right.left = RedBlackTree(5, parent=right_rot.right.right)
-    right_rot.right.right.right = RedBlackTree(20, parent=right_rot.right.right)
-    if tree != right_rot:
-        return False
-    return True
-
-def test_insertion_speed():
-    """Test that the tree balances inserts to O(log(n)) by doing a lot
-    of them.
-    """
-    tree = RedBlackTree(-1)
-    for i in range(300000):
-        tree = tree.insert(i)
-    return True
-
-def test_insert():
-    """Test the insert() method of the tree correctly balances, colors,
-    and inserts.
-    """
-    tree = RedBlackTree(0)
-    tree.insert(8)
-    tree.insert(-8)
-    tree.insert(4)
-    tree.insert(12)
-    tree.insert(10)
-    tree.insert(11)
-    ans = RedBlackTree(0, 0)
-    ans.left = RedBlackTree(-8, 0, ans)
-    ans.right = RedBlackTree(8, 1, ans)
-    ans.right.left = RedBlackTree(4, 0, ans.right)
-    ans.right.right = RedBlackTree(11, 0, ans.right)
-    ans.right.right.left = RedBlackTree(10, 1, ans.right.right)
-    ans.right.right.right = RedBlackTree(12, 1, ans.right.right)
-    return tree == ans
-
-def test_insert_and_search():
-    """Tests searching through the tree for values."""
-    tree = RedBlackTree(0)
-    tree.insert(8)
-    tree.insert(-8)
-    tree.insert(4)
-    tree.insert(12)
-    tree.insert(10)
-    tree.insert(11)
-    if 5 in tree or -6 in tree or -10 in tree or 13 in tree:
-        # Found something not in there
-        return False
-    if not (11 in tree and 12 in tree and -8 in tree and 0 in tree):
-        # Didn't find something in there
-        return False
-    return True
-
-def test_insert_delete():
-    """Test the insert() and delete() method of the tree, verifying the
-    insertion and removal of elements, and the balancing of the tree.
-    """
-    tree = RedBlackTree(0)
-    tree = tree.insert(-12)
-    tree = tree.insert(8)
-    tree = tree.insert(-8)
-    tree = tree.insert(15)
-    tree = tree.insert(4)
-    tree = tree.insert(12)
-    tree = tree.insert(10)
-    tree = tree.insert(9)
-    tree = tree.insert(11)
-    tree = tree.remove(15)
-    tree = tree.remove(-12)
-    tree = tree.remove(9)
-    if not tree.check_color_properties():
-        return False
-    if list(tree.inorder_traverse()) != [-8, 0, 4, 8, 10, 11, 12]:
-        return False
-    return True
-
-def test_floor_ceil():
-    """Tests the floor and ceiling functions in the tree."""
-    tree = RedBlackTree(0)
-    tree.insert(-16)
-    tree.insert(16)
-    tree.insert(8)
-    tree.insert(24)
-    tree.insert(20)
-    tree.insert(22)
-    tuples = [(-20, None, -16), (-10, -16, 0), (8, 8, 8), (50, 24, None)]
-    for val, floor, ceil in tuples:
-        if tree.floor(val) != floor or tree.ceil(val) != ceil:
-            return False
-    return True
-
-def test_min_max():
-    """Tests the min and max functions in the tree."""
-    tree = RedBlackTree(0)
-    tree.insert(-16)
-    tree.insert(16)
-    tree.insert(8)
-    tree.insert(24)
-    tree.insert(20)
-    tree.insert(22)
-    if tree.get_max() != 22 or tree.get_min() != -16:
-        return False
-    return True
-
-def test_tree_traversal():
-    """Tests the three different tree traversal functions."""
-    tree = RedBlackTree(0)
-    tree.insert(-16)
-    tree.insert(16)
-    tree.insert(8)
-    tree.insert(24)
-    tree.insert(20)
-    tree.insert(22)
-    if list(tree.inorder_traverse()) != [-16, 0, 8, 16, 20, 22, 24]:
-        return False
-    if list(tree.preorder_traverse()) != [0, -16, 16, 8, 22, 20, 24]:
-        return False
-    if list(tree.postorder_traverse()) != [-16, 8, 20, 24, 22, 16, 0]:
-        return False
-    return True
-
-def main():
-    if test_rotations():
-        print('Rotating right and left works!')
-    else:
-        print('Rotating right and left doesn\'t work. :(')
-    if test_insert():
-        print('Inserting works!')
-    else:
-        print('Inserting doesn\'t work :(')
-    if test_insert_and_search():
-        print('Searching works!')
-    else:
-        print('Searching doesn\'t work :(')
-    if test_insert_delete():
-        print('Deleting works!')
-    else:
-        print('Deleting doesn\'t work :(')
-    if test_floor_ceil():
-        print('Floor and ceil work!')
-    else:
-        print('Floor and ceil don\'t work :(')
-    if test_tree_traversal():
-        print('Tree traversal works!')
-    else:
-        print('Tree traversal doesn\'t work :(')
-    print('Testing tree balancing...')
-    print('This should only be a few seconds.')
-    test_insertion_speed()
-    print('Done!')
-
-if __name__ == '__main__':
-    main()
+"""
+python/black : true
+flake8 : passed
+"""
+
+
+class RedBlackTree:
+    """
+    A Red-Black tree, which is a self-balancing BST (binary search
+    tree).
+    This tree has similar performance to AVL trees, but the balancing is
+    less strict, so it will perform faster for writing/deleting nodes
+    and slower for reading in the average case, though, because they're
+    both balanced binary search trees, both will get the same asymptotic
+    perfomance.
+    To read more about them, https://en.wikipedia.org/wiki/Red–black_tree
+    Unless otherwise specified, all asymptotic runtimes are specified in
+    terms of the size of the tree.
+    """
+
+    def __init__(self, label=None, color=0, parent=None, left=None, right=None):
+        """Initialize a new Red-Black Tree node with the given values:
+            label: The value associated with this node
+            color: 0 if black, 1 if red
+            parent: The parent to this node
+            left: This node's left child
+            right: This node's right child
+        """
+        self.label = label
+        self.parent = parent
+        self.left = left
+        self.right = right
+        self.color = color
+
+    # Here are functions which are specific to red-black trees
+
+    def rotate_left(self):
+        """Rotate the subtree rooted at this node to the left and
+        returns the new root to this subtree.
+        Perfoming one rotation can be done in O(1).
+        """
+        parent = self.parent
+        right = self.right
+        self.right = right.left
+        if self.right:
+            self.right.parent = self
+        self.parent = right
+        right.left = self
+        if parent is not None:
+            if parent.left == self:
+                parent.left = right
+            else:
+                parent.right = right
+        right.parent = parent
+        return right
+
+    def rotate_right(self):
+        """Rotate the subtree rooted at this node to the right and
+        returns the new root to this subtree.
+        Performing one rotation can be done in O(1).
+        """
+        parent = self.parent
+        left = self.left
+        self.left = left.right
+        if self.left:
+            self.left.parent = self
+        self.parent = left
+        left.right = self
+        if parent is not None:
+            if parent.right is self:
+                parent.right = left
+            else:
+                parent.left = left
+        left.parent = parent
+        return left
+
+    def insert(self, label):
+        """Inserts label into the subtree rooted at self, performs any
+        rotations necessary to maintain balance, and then returns the
+        new root to this subtree (likely self).
+        This is guaranteed to run in O(log(n)) time.
+        """
+        if self.label is None:
+            # Only possible with an empty tree
+            self.label = label
+            return self
+        if self.label == label:
+            return self
+        elif self.label > label:
+            if self.left:
+                self.left.insert(label)
+            else:
+                self.left = RedBlackTree(label, 1, self)
+                self.left._insert_repair()
+        else:
+            if self.right:
+                self.right.insert(label)
+            else:
+                self.right = RedBlackTree(label, 1, self)
+                self.right._insert_repair()
+        return self.parent or self
+
+    def _insert_repair(self):
+        """Repair the coloring from inserting into a tree."""
+        if self.parent is None:
+            # This node is the root, so it just needs to be black
+            self.color = 0
+        elif color(self.parent) == 0:
+            # If the parent is black, then it just needs to be red
+            self.color = 1
+        else:
+            uncle = self.parent.sibling
+            if color(uncle) == 0:
+                if self.is_left() and self.parent.is_right():
+                    self.parent.rotate_right()
+                    self.right._insert_repair()
+                elif self.is_right() and self.parent.is_left():
+                    self.parent.rotate_left()
+                    self.left._insert_repair()
+                elif self.is_left():
+                    self.grandparent.rotate_right()
+                    self.parent.color = 0
+                    self.parent.right.color = 1
+                else:
+                    self.grandparent.rotate_left()
+                    self.parent.color = 0
+                    self.parent.left.color = 1
+            else:
+                self.parent.color = 0
+                uncle.color = 0
+                self.grandparent.color = 1
+                self.grandparent._insert_repair()
+
+    def remove(self, label):
+        """Remove label from this tree."""
+        if self.label == label:
+            if self.left and self.right:
+                # It's easier to balance a node with at most one child,
+                # so we replace this node with the greatest one less than
+                # it and remove that.
+                value = self.left.get_max()
+                self.label = value
+                self.left.remove(value)
+            else:
+                # This node has at most one non-None child, so we don't
+                # need to replace
+                child = self.left or self.right
+                if self.color == 1:
+                    # This node is red, and its child is black
+                    # The only way this happens to a node with one child
+                    # is if both children are None leaves.
+                    # We can just remove this node and call it a day.
+                    if self.is_left():
+                        self.parent.left = None
+                    else:
+                        self.parent.right = None
+                else:
+                    # The node is black
+                    if child is None:
+                        # This node and its child are black
+                        if self.parent is None:
+                            # The tree is now empty
+                            return RedBlackTree(None)
+                        else:
+                            self._remove_repair()
+                            if self.is_left():
+                                self.parent.left = None
+                            else:
+                                self.parent.right = None
+                            self.parent = None
+                    else:
+                        # This node is black and its child is red
+                        # Move the child node here and make it black
+                        self.label = child.label
+                        self.left = child.left
+                        self.right = child.right
+                        if self.left:
+                            self.left.parent = self
+                        if self.right:
+                            self.right.parent = self
+        elif self.label > label:
+            if self.left:
+                self.left.remove(label)
+        else:
+            if self.right:
+                self.right.remove(label)
+        return self.parent or self
+
+    def _remove_repair(self):
+        """Repair the coloring of the tree that may have been messed up."""
+        if color(self.sibling) == 1:
+            self.sibling.color = 0
+            self.parent.color = 1
+            if self.is_left():
+                self.parent.rotate_left()
+            else:
+                self.parent.rotate_right()
+        if (
+            color(self.parent) == 0
+            and color(self.sibling) == 0
+            and color(self.sibling.left) == 0
+            and color(self.sibling.right) == 0
+        ):
+            self.sibling.color = 1
+            self.parent._remove_repair()
+            return
+        if (
+            color(self.parent) == 1
+            and color(self.sibling) == 0
+            and color(self.sibling.left) == 0
+            and color(self.sibling.right) == 0
+        ):
+            self.sibling.color = 1
+            self.parent.color = 0
+            return
+        if (
+            self.is_left()
+            and color(self.sibling) == 0
+            and color(self.sibling.right) == 0
+            and color(self.sibling.left) == 1
+        ):
+            self.sibling.rotate_right()
+            self.sibling.color = 0
+            self.sibling.right.color = 1
+        if (
+            self.is_right()
+            and color(self.sibling) == 0
+            and color(self.sibling.right) == 1
+            and color(self.sibling.left) == 0
+        ):
+            self.sibling.rotate_left()
+            self.sibling.color = 0
+            self.sibling.left.color = 1
+        if (
+            self.is_left()
+            and color(self.sibling) == 0
+            and color(self.sibling.right) == 1
+        ):
+            self.parent.rotate_left()
+            self.grandparent.color = self.parent.color
+            self.parent.color = 0
+            self.parent.sibling.color = 0
+        if (
+            self.is_right()
+            and color(self.sibling) == 0
+            and color(self.sibling.left) == 1
+        ):
+            self.parent.rotate_right()
+            self.grandparent.color = self.parent.color
+            self.parent.color = 0
+            self.parent.sibling.color = 0
+
+    def check_color_properties(self):
+        """Check the coloring of the tree, and return True iff the tree
+        is colored in a way which matches these five properties:
+        (wording stolen from wikipedia article)
+         1. Each node is either red or black.
+         2. The root node is black.
+         3. All leaves are black.
+         4. If a node is red, then both its children are black.
+         5. Every path from any node to all of its descendent NIL nodes
+            has the same number of black nodes.
+        This function runs in O(n) time, because properties 4 and 5 take
+        that long to check.
+        """
+        # I assume property 1 to hold because there is nothing that can
+        # make the color be anything other than 0 or 1.
+
+        # Property 2
+        if self.color:
+            # The root was red
+            print("Property 2")
+            return False
+
+        # Property 3 does not need to be checked, because None is assumed
+        # to be black and is all the leaves.
+
+        # Property 4
+        if not self.check_coloring():
+            print("Property 4")
+            return False
+
+        # Property 5
+        if self.black_height() is None:
+            print("Property 5")
+            return False
+        # All properties were met
+        return True
+
+    def check_coloring(self):
+        """A helper function to recursively check Property 4 of a
+        Red-Black Tree. See check_color_properties for more info.
+        """
+        if self.color == 1:
+            if color(self.left) == 1 or color(self.right) == 1:
+                return False
+        if self.left and not self.left.check_coloring():
+            return False
+        if self.right and not self.right.check_coloring():
+            return False
+        return True
+
+    def black_height(self):
+        """Returns the number of black nodes from this node to the
+        leaves of the tree, or None if there isn't one such value (the
+        tree is color incorrectly).
+        """
+        if self is None:
+            # If we're already at a leaf, there is no path
+            return 1
+        left = RedBlackTree.black_height(self.left)
+        right = RedBlackTree.black_height(self.right)
+        if left is None or right is None:
+            # There are issues with coloring below children nodes
+            return None
+        if left != right:
+            # The two children have unequal depths
+            return None
+        # Return the black depth of children, plus one if this node is
+        # black
+        return left + (1 - self.color)
+
+    # Here are functions which are general to all binary search trees
+
+    def __contains__(self, label):
+        """Search through the tree for label, returning True iff it is
+        found somewhere in the tree.
+        Guaranteed to run in O(log(n)) time.
+        """
+        return self.search(label) is not None
+
+    def search(self, label):
+        """Search through the tree for label, returning its node if
+        it's found, and None otherwise.
+        This method is guaranteed to run in O(log(n)) time.
+        """
+        if self.label == label:
+            return self
+        elif label > self.label:
+            if self.right is None:
+                return None
+            else:
+                return self.right.search(label)
+        else:
+            if self.left is None:
+                return None
+            else:
+                return self.left.search(label)
+
+    def floor(self, label):
+        """Returns the largest element in this tree which is at most label.
+        This method is guaranteed to run in O(log(n)) time."""
+        if self.label == label:
+            return self.label
+        elif self.label > label:
+            if self.left:
+                return self.left.floor(label)
+            else:
+                return None
+        else:
+            if self.right:
+                attempt = self.right.floor(label)
+                if attempt is not None:
+                    return attempt
+            return self.label
+
+    def ceil(self, label):
+        """Returns the smallest element in this tree which is at least label.
+        This method is guaranteed to run in O(log(n)) time.
+        """
+        if self.label == label:
+            return self.label
+        elif self.label < label:
+            if self.right:
+                return self.right.ceil(label)
+            else:
+                return None
+        else:
+            if self.left:
+                attempt = self.left.ceil(label)
+                if attempt is not None:
+                    return attempt
+            return self.label
+
+    def get_max(self):
+        """Returns the largest element in this tree.
+        This method is guaranteed to run in O(log(n)) time.
+        """
+        if self.right:
+            # Go as far right as possible
+            return self.right.get_max()
+        else:
+            return self.label
+
+    def get_min(self):
+        """Returns the smallest element in this tree.
+        This method is guaranteed to run in O(log(n)) time.
+        """
+        if self.left:
+            # Go as far left as possible
+            return self.left.get_min()
+        else:
+            return self.label
+
+    @property
+    def grandparent(self):
+        """Get the current node's grandparent, or None if it doesn't exist."""
+        if self.parent is None:
+            return None
+        else:
+            return self.parent.parent
+
+    @property
+    def sibling(self):
+        """Get the current node's sibling, or None if it doesn't exist."""
+        if self.parent is None:
+            return None
+        elif self.parent.left is self:
+            return self.parent.right
+        else:
+            return self.parent.left
+
+    def is_left(self):
+        """Returns true iff this node is the left child of its parent."""
+        return self.parent and self.parent.left is self
+
+    def is_right(self):
+        """Returns true iff this node is the right child of its parent."""
+        return self.parent and self.parent.right is self
+
+    def __bool__(self):
+        return True
+
+    def __len__(self):
+        """
+        Return the number of nodes in this tree.
+        """
+        ln = 1
+        if self.left:
+            ln += len(self.left)
+        if self.right:
+            ln += len(self.right)
+        return ln
+
+    def preorder_traverse(self):
+        yield self.label
+        if self.left:
+            yield from self.left.preorder_traverse()
+        if self.right:
+            yield from self.right.preorder_traverse()
+
+    def inorder_traverse(self):
+        if self.left:
+            yield from self.left.inorder_traverse()
+        yield self.label
+        if self.right:
+            yield from self.right.inorder_traverse()
+
+    def postorder_traverse(self):
+        if self.left:
+            yield from self.left.postorder_traverse()
+        if self.right:
+            yield from self.right.postorder_traverse()
+        yield self.label
+
+    def __repr__(self):
+        from pprint import pformat
+
+        if self.left is None and self.right is None:
+            return "'%s %s'" % (self.label, (self.color and "red") or "blk")
+        return pformat(
+            {
+                "%s %s"
+                % (self.label, (self.color and "red") or "blk"): (self.left, self.right)
+            },
+            indent=1,
+        )
+
+    def __eq__(self, other):
+        """Test if two trees are equal."""
+        if self.label == other.label:
+            return self.left == other.left and self.right == other.right
+        else:
+            return False
+
+
+def color(node):
+    """Returns the color of a node, allowing for None leaves."""
+    if node is None:
+        return 0
+    else:
+        return node.color
+
+
+"""
+Code for testing the various
+functions of the red-black tree.
+"""
+
+
+def test_rotations():
+    """Test that the rotate_left and rotate_right functions work."""
+    # Make a tree to test on
+    tree = RedBlackTree(0)
+    tree.left = RedBlackTree(-10, parent=tree)
+    tree.right = RedBlackTree(10, parent=tree)
+    tree.left.left = RedBlackTree(-20, parent=tree.left)
+    tree.left.right = RedBlackTree(-5, parent=tree.left)
+    tree.right.left = RedBlackTree(5, parent=tree.right)
+    tree.right.right = RedBlackTree(20, parent=tree.right)
+    # Make the right rotation
+    left_rot = RedBlackTree(10)
+    left_rot.left = RedBlackTree(0, parent=left_rot)
+    left_rot.left.left = RedBlackTree(-10, parent=left_rot.left)
+    left_rot.left.right = RedBlackTree(5, parent=left_rot.left)
+    left_rot.left.left.left = RedBlackTree(-20, parent=left_rot.left.left)
+    left_rot.left.left.right = RedBlackTree(-5, parent=left_rot.left.left)
+    left_rot.right = RedBlackTree(20, parent=left_rot)
+    tree = tree.rotate_left()
+    if tree != left_rot:
+        return False
+    tree = tree.rotate_right()
+    tree = tree.rotate_right()
+    # Make the left rotation
+    right_rot = RedBlackTree(-10)
+    right_rot.left = RedBlackTree(-20, parent=right_rot)
+    right_rot.right = RedBlackTree(0, parent=right_rot)
+    right_rot.right.left = RedBlackTree(-5, parent=right_rot.right)
+    right_rot.right.right = RedBlackTree(10, parent=right_rot.right)
+    right_rot.right.right.left = RedBlackTree(5, parent=right_rot.right.right)
+    right_rot.right.right.right = RedBlackTree(20, parent=right_rot.right.right)
+    if tree != right_rot:
+        return False
+    return True
+
+
+def test_insertion_speed():
+    """Test that the tree balances inserts to O(log(n)) by doing a lot
+    of them.
+    """
+    tree = RedBlackTree(-1)
+    for i in range(300000):
+        tree = tree.insert(i)
+    return True
+
+
+def test_insert():
+    """Test the insert() method of the tree correctly balances, colors,
+    and inserts.
+    """
+    tree = RedBlackTree(0)
+    tree.insert(8)
+    tree.insert(-8)
+    tree.insert(4)
+    tree.insert(12)
+    tree.insert(10)
+    tree.insert(11)
+    ans = RedBlackTree(0, 0)
+    ans.left = RedBlackTree(-8, 0, ans)
+    ans.right = RedBlackTree(8, 1, ans)
+    ans.right.left = RedBlackTree(4, 0, ans.right)
+    ans.right.right = RedBlackTree(11, 0, ans.right)
+    ans.right.right.left = RedBlackTree(10, 1, ans.right.right)
+    ans.right.right.right = RedBlackTree(12, 1, ans.right.right)
+    return tree == ans
+
+
+def test_insert_and_search():
+    """Tests searching through the tree for values."""
+    tree = RedBlackTree(0)
+    tree.insert(8)
+    tree.insert(-8)
+    tree.insert(4)
+    tree.insert(12)
+    tree.insert(10)
+    tree.insert(11)
+    if 5 in tree or -6 in tree or -10 in tree or 13 in tree:
+        # Found something not in there
+        return False
+    if not (11 in tree and 12 in tree and -8 in tree and 0 in tree):
+        # Didn't find something in there
+        return False
+    return True
+
+
+def test_insert_delete():
+    """Test the insert() and delete() method of the tree, verifying the
+    insertion and removal of elements, and the balancing of the tree.
+    """
+    tree = RedBlackTree(0)
+    tree = tree.insert(-12)
+    tree = tree.insert(8)
+    tree = tree.insert(-8)
+    tree = tree.insert(15)
+    tree = tree.insert(4)
+    tree = tree.insert(12)
+    tree = tree.insert(10)
+    tree = tree.insert(9)
+    tree = tree.insert(11)
+    tree = tree.remove(15)
+    tree = tree.remove(-12)
+    tree = tree.remove(9)
+    if not tree.check_color_properties():
+        return False
+    if list(tree.inorder_traverse()) != [-8, 0, 4, 8, 10, 11, 12]:
+        return False
+    return True
+
+
+def test_floor_ceil():
+    """Tests the floor and ceiling functions in the tree."""
+    tree = RedBlackTree(0)
+    tree.insert(-16)
+    tree.insert(16)
+    tree.insert(8)
+    tree.insert(24)
+    tree.insert(20)
+    tree.insert(22)
+    tuples = [(-20, None, -16), (-10, -16, 0), (8, 8, 8), (50, 24, None)]
+    for val, floor, ceil in tuples:
+        if tree.floor(val) != floor or tree.ceil(val) != ceil:
+            return False
+    return True
+
+
+def test_min_max():
+    """Tests the min and max functions in the tree."""
+    tree = RedBlackTree(0)
+    tree.insert(-16)
+    tree.insert(16)
+    tree.insert(8)
+    tree.insert(24)
+    tree.insert(20)
+    tree.insert(22)
+    if tree.get_max() != 22 or tree.get_min() != -16:
+        return False
+    return True
+
+
+def test_tree_traversal():
+    """Tests the three different tree traversal functions."""
+    tree = RedBlackTree(0)
+    tree = tree.insert(-16)
+    tree.insert(16)
+    tree.insert(8)
+    tree.insert(24)
+    tree.insert(20)
+    tree.insert(22)
+    if list(tree.inorder_traverse()) != [-16, 0, 8, 16, 20, 22, 24]:
+        return False
+    if list(tree.preorder_traverse()) != [0, -16, 16, 8, 22, 20, 24]:
+        return False
+    if list(tree.postorder_traverse()) != [-16, 8, 20, 24, 22, 16, 0]:
+        return False
+    return True
+
+
+def test_tree_chaining():
+    """Tests the three different tree chaning functions."""
+    tree = RedBlackTree(0)
+    tree = tree.insert(-16).insert(16).insert(8).insert(24).insert(20).insert(22)
+    if list(tree.inorder_traverse()) != [-16, 0, 8, 16, 20, 22, 24]:
+        return False
+    if list(tree.preorder_traverse()) != [0, -16, 16, 8, 22, 20, 24]:
+        return False
+    if list(tree.postorder_traverse()) != [-16, 8, 20, 24, 22, 16, 0]:
+        return False
+    return True
+
+
+def print_results(msg: str, passes: bool) -> None:
+    print(str(msg), "works!" if passes else "doesn't work :(")
+
+
+def pytests():
+    assert test_rotations()
+    assert test_insert()
+    assert test_insert_and_search()
+    assert test_insert_delete()
+    assert test_floor_ceil()
+    assert test_tree_traversal()
+    assert test_tree_chaining()
+
+
+def main():
+    """
+    >>> pytests()
+    """
+    print_results("Rotating right and left", test_rotations())
+
+    print_results("Inserting", test_insert())
+
+    print_results("Searching", test_insert_and_search())
+
+    print_results("Deleting", test_insert_delete())
+
+    print_results("Floor and ceil", test_floor_ceil())
+
+    print_results("Tree traversal", test_tree_traversal())
+
+    print_results("Tree traversal", test_tree_chaining())
+
+
+    print("Testing tree balancing...")
+    print("This should only be a few seconds.")
+    test_insertion_speed()
+    print("Done!")
+
+
+if __name__ == "__main__":
+    main()

From 46bc6738d78de3a05901881c919e8d91a28b8ef4 Mon Sep 17 00:00:00 2001
From: obelisk0114 <obelisk0114@yahoo.com.tw>
Date: Fri, 26 Jul 2019 03:25:38 -0700
Subject: [PATCH 147/348] Add doctest to maths/sieve_of_eratosthenes.py and
 remove other/finding_primes.py (#1078)

Both of the two files implemented sieve of eratosthenes.
However, there was a bug in other/finding_primes.py, and the time complexity was larger than the other.
Therefore, remove other/finding_primes.py and add doctest tomaths/sieve_of_eratosthenes.py.
---
 maths/sieve_of_eratosthenes.py | 38 ++++++++++++++++++++++++++++++++--
 other/finding_primes.py        | 21 -------------------
 2 files changed, 36 insertions(+), 23 deletions(-)
 delete mode 100644 other/finding_primes.py

diff --git a/maths/sieve_of_eratosthenes.py b/maths/sieve_of_eratosthenes.py
index cedd04f92aa0..44c7f8a02682 100644
--- a/maths/sieve_of_eratosthenes.py
+++ b/maths/sieve_of_eratosthenes.py
@@ -1,19 +1,53 @@
-"""Sieve of Eratosthones."""
+# -*- coding: utf-8 -*-
+
+"""
+Sieve of Eratosthones
+
+The sieve of Eratosthenes is an algorithm used to find prime numbers, less than or equal to a given value.
+Illustration: https://upload.wikimedia.org/wikipedia/commons/b/b9/Sieve_of_Eratosthenes_animation.gif
+Reference: https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes
+
+doctest provider: Bruno Simas Hadlich (https://github.com/brunohadlich)
+Also thanks Dmitry (https://github.com/LizardWizzard) for finding the problem
+"""
+
 
 import math
 
+
 def sieve(n):
-    """Sieve of Eratosthones."""
+    """
+    Returns a list with all prime numbers up to n.
+    
+    >>> sieve(50)
+    [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]
+    >>> sieve(25)
+    [2, 3, 5, 7, 11, 13, 17, 19, 23]
+    >>> sieve(10)
+    [2, 3, 5, 7]
+    >>> sieve(9)
+    [2, 3, 5, 7]
+    >>> sieve(2)
+    [2]
+    >>> sieve(1)
+    []
+    """
+
     l = [True] * (n + 1)
     prime = []
     start = 2
     end = int(math.sqrt(n))
+
     while start <= end:
+        # If start is a prime
         if l[start] is True:
             prime.append(start)
+
+            # Set multiples of start be False
             for i in range(start * start, n + 1, start):
                 if l[i] is True:
                     l[i] = False
+
         start += 1
 
     for j in range(end + 1, n + 1):
diff --git a/other/finding_primes.py b/other/finding_primes.py
deleted file mode 100644
index 035a14f4a335..000000000000
--- a/other/finding_primes.py
+++ /dev/null
@@ -1,21 +0,0 @@
-'''
--The sieve of Eratosthenes is an algorithm used to find prime numbers, less than or equal to a given value.
--Illustration: https://upload.wikimedia.org/wikipedia/commons/b/b9/Sieve_of_Eratosthenes_animation.gif
-'''
-from __future__ import print_function
-
-
-from math import sqrt
-def SOE(n):
-    check = round(sqrt(n)) #Need not check for multiples past the square root of n
-    
-    sieve = [False if i <2 else True for i in range(n+1)] #Set every index to False except for index 0 and 1
-    
-    for i in range(2, check):
-        if(sieve[i] == True):                  #If i is a prime  
-            for j in range(i+i, n+1, i):       #Step through the list in increments of i(the multiples of the prime)   
-                sieve[j] = False               #Sets every multiple of i to False 
-    
-    for i in range(n+1):
-        if(sieve[i] == True):
-            print(i, end=" ")

From 3b63857b657ef9e552368d66fe536a0454c6307f Mon Sep 17 00:00:00 2001
From: Jasper <46252815+jasper256@users.noreply.github.com>
Date: Fri, 26 Jul 2019 12:28:32 -0400
Subject: [PATCH 148/348] added automated doctest to decimal_to_hexadecimal.py
 in conversions (#1071)

* added automated doctest to decimal_to_hexadecimal.py in conversions

* improved error handling and added more test cases in decimal_to_hexadecimal.py

* implemented 0x notation and simplified AssertionError

* fixed negative notation and added comparison test against Python hex function
---
 conversions/decimal_to_hexadecimal.py | 59 ++++++++++++++++++++-------
 1 file changed, 45 insertions(+), 14 deletions(-)

diff --git a/conversions/decimal_to_hexadecimal.py b/conversions/decimal_to_hexadecimal.py
index f91fac063adc..e6435f1ef570 100644
--- a/conversions/decimal_to_hexadecimal.py
+++ b/conversions/decimal_to_hexadecimal.py
@@ -21,23 +21,54 @@
 }
 
 def decimal_to_hexadecimal(decimal):
-    """ take decimal value, return hexadecimal representation as str """
+    """
+        take integer decimal value, return hexadecimal representation as str beginning with 0x
+        >>> decimal_to_hexadecimal(5)
+        '0x5'
+        >>> decimal_to_hexadecimal(15)
+        '0xf'
+        >>> decimal_to_hexadecimal(37)
+        '0x25'
+        >>> decimal_to_hexadecimal(255)
+        '0xff'
+        >>> decimal_to_hexadecimal(4096)
+        '0x1000'
+        >>> decimal_to_hexadecimal(999098)
+        '0xf3eba'
+        >>> # negatives work too
+        >>> decimal_to_hexadecimal(-256)
+        '-0x100'
+        >>> # floats are acceptable if equivalent to an int
+        >>> decimal_to_hexadecimal(17.0)
+        '0x11'
+        >>> # other floats will error
+        >>> decimal_to_hexadecimal(16.16) # doctest: +ELLIPSIS
+        Traceback (most recent call last):
+        ...
+        AssertionError
+        >>> # strings will error as well
+        >>> decimal_to_hexadecimal('0xfffff') # doctest: +ELLIPSIS
+        Traceback (most recent call last):
+        ...
+        AssertionError
+        >>> # results are the same when compared to Python's default hex function
+        >>> decimal_to_hexadecimal(-256) == hex(-256)
+        True
+    """
+    assert type(decimal) in (int, float) and decimal == int(decimal)
     hexadecimal = ''
+    negative = False
+    if decimal < 0:
+        negative = True
+        decimal *= -1
     while decimal > 0:
-        remainder = decimal % 16
-        decimal -= remainder
+        decimal, remainder = divmod(decimal, 16)
         hexadecimal = values[remainder] + hexadecimal
-        decimal /= 16
+    hexadecimal = '0x' + hexadecimal
+    if negative:
+        hexadecimal = '-' + hexadecimal
     return hexadecimal
 
-def main():
-    """ print test cases """
-    print("5 in hexadecimal is", decimal_to_hexadecimal(5))
-    print("15 in hexadecimal is", decimal_to_hexadecimal(15))
-    print("37 in hexadecimal is", decimal_to_hexadecimal(37))
-    print("255 in hexadecimal is", decimal_to_hexadecimal(255))
-    print("4096 in hexadecimal is", decimal_to_hexadecimal(4096))
-    print("999098 in hexadecimal is", decimal_to_hexadecimal(999098))
-
 if __name__ == '__main__':
-    main()
\ No newline at end of file
+    import doctest
+    doctest.testmod()

From a0817bdcf0c5ce17a7798fc0ede1821cd1bc983f Mon Sep 17 00:00:00 2001
From: Christian Clauss <cclauss@me.com>
Date: Sun, 28 Jul 2019 17:27:23 +0200
Subject: [PATCH 149/348] Rewrite build_directory_md.py (#1076)

* Rewrite build_directory_md.py

* Regenerate DIRECTORY.md
---
 .travis.yml                   |  2 +-
 DIRECTORY.md                  | 23 +++++----
 scripts/build_directory_md.py | 94 +++++++++++++----------------------
 3 files changed, 48 insertions(+), 71 deletions(-)
 mode change 100644 => 100755 scripts/build_directory_md.py

diff --git a/.travis.yml b/.travis.yml
index 6d432c660ddd..d09ef9de262d 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -19,5 +19,5 @@ script:
       --ignore=machine_learning/random_forest_classification/random_forest_classification.py
       --ignore=machine_learning/random_forest_regression/random_forest_regression.py
 after_success:
-  - python scripts/build_directory_md.py
+  - scripts/build_directory_md.py > DIRECTORY.md
   - cat DIRECTORY.md
diff --git a/DIRECTORY.md b/DIRECTORY.md
index fc06a8cd1548..d97791bb5dd3 100644
--- a/DIRECTORY.md
+++ b/DIRECTORY.md
@@ -1,5 +1,6 @@
 ## Arithmetic Analysis
   * [bisection](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/bisection.py)
+  * [in static equilibrium](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/in_static_equilibrium.py)
   * [intersection](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/intersection.py)
   * [lu decomposition](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/lu_decomposition.py)
   * [newton method](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/newton_method.py)
@@ -42,7 +43,6 @@
   * [burrows wheeler](https://github.com/TheAlgorithms/Python/blob/master/compression/burrows_wheeler.py)
   * [huffman](https://github.com/TheAlgorithms/Python/blob/master/compression/huffman.py)
   * [peak signal to noise ratio](https://github.com/TheAlgorithms/Python/blob/master/compression/peak_signal_to_noise_ratio.py)
-  * Image Data
 ## Conversions
   * [decimal to binary](https://github.com/TheAlgorithms/Python/blob/master/conversions/decimal_to_binary.py)
   * [decimal to hexadecimal](https://github.com/TheAlgorithms/Python/blob/master/conversions/decimal_to_hexadecimal.py)
@@ -62,9 +62,9 @@
     * [double hash](https://github.com/TheAlgorithms/Python/blob/master/data_structures/hashing/double_hash.py)
     * [hash table](https://github.com/TheAlgorithms/Python/blob/master/data_structures/hashing/hash_table.py)
     * [hash table with linked list](https://github.com/TheAlgorithms/Python/blob/master/data_structures/hashing/hash_table_with_linked_list.py)
-    * [quadratic probing](https://github.com/TheAlgorithms/Python/blob/master/data_structures/hashing/quadratic_probing.py)
     * Number Theory
       * [prime numbers](https://github.com/TheAlgorithms/Python/blob/master/data_structures/hashing/number_theory/prime_numbers.py)
+    * [quadratic probing](https://github.com/TheAlgorithms/Python/blob/master/data_structures/hashing/quadratic_probing.py)
   * Heap
     * [heap](https://github.com/TheAlgorithms/Python/blob/master/data_structures/heap/heap.py)
   * Linked List
@@ -87,6 +87,7 @@
   * Trie
     * [trie](https://github.com/TheAlgorithms/Python/blob/master/data_structures/trie/trie.py)
 ## Digital Image Processing
+  * [change contrast](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/change_contrast.py)
   * Edge Detection
     * [canny](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/edge_detection/canny.py)
   * Filters
@@ -94,7 +95,6 @@
     * [gaussian filter](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/filters/gaussian_filter.py)
     * [median filter](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/filters/median_filter.py)
     * [sobel filter](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/filters/sobel_filter.py)
-  * Image Data
 ## Divide And Conquer
   * [closest pair of points](https://github.com/TheAlgorithms/Python/blob/master/divide_and_conquer/closest_pair_of_points.py)
   * [max subarray sum](https://github.com/TheAlgorithms/Python/blob/master/divide_and_conquer/max_subarray_sum.py)
@@ -167,24 +167,22 @@
     * [lib](https://github.com/TheAlgorithms/Python/blob/master/linear_algebra_python/src/lib.py)
     * [tests](https://github.com/TheAlgorithms/Python/blob/master/linear_algebra_python/src/tests.py)
 ## Machine Learning
+  * [NaiveBayes](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/NaiveBayes.ipynb)
   * [decision tree](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/decision_tree.py)
   * [gradient descent](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/gradient_descent.py)
   * [k means clust](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/k_means_clust.py)
   * [knn sklearn](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/knn_sklearn.py)
   * [linear regression](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/linear_regression.py)
   * [logistic regression](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/logistic_regression.py)
-  * [NaiveBayes](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/NaiveBayes.ipynb)
   * [perceptron](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/perceptron.py)
-  * [reuters one vs rest classifier](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/reuters_one_vs_rest_classifier.ipynb)
-  * [scoring functions](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/scoring_functions.py)
   * Random Forest Classification
     * [random forest classification](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/random_forest_classification/random_forest_classification.py)
     * [random forest classifier](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/random_forest_classification/random_forest_classifier.ipynb)
-    * [Social Network Ads](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/random_forest_classification/Social_Network_Ads.csv)
   * Random Forest Regression
-    * [Position Salaries](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/random_forest_regression/Position_Salaries.csv)
     * [random forest regression](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/random_forest_regression/random_forest_regression.ipynb)
     * [random forest regression](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/random_forest_regression/random_forest_regression.py)
+  * [reuters one vs rest classifier](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/reuters_one_vs_rest_classifier.ipynb)
+  * [scoring functions](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/scoring_functions.py)
 ## Maths
   * [3n+1](https://github.com/TheAlgorithms/Python/blob/master/maths/3n+1.py)
   * [abs](https://github.com/TheAlgorithms/Python/blob/master/maths/abs.py)
@@ -203,11 +201,15 @@
   * [find lcm](https://github.com/TheAlgorithms/Python/blob/master/maths/find_lcm.py)
   * [find max](https://github.com/TheAlgorithms/Python/blob/master/maths/find_max.py)
   * [find min](https://github.com/TheAlgorithms/Python/blob/master/maths/find_min.py)
+  * [gaussian](https://github.com/TheAlgorithms/Python/blob/master/maths/gaussian.py)
   * [greater common divisor](https://github.com/TheAlgorithms/Python/blob/master/maths/greater_common_divisor.py)
+  * [is square free](https://github.com/TheAlgorithms/Python/blob/master/maths/is_square_free.py)
   * [lucas series](https://github.com/TheAlgorithms/Python/blob/master/maths/lucas_series.py)
+  * [mobius function](https://github.com/TheAlgorithms/Python/blob/master/maths/mobius_function.py)
   * [modular exponential](https://github.com/TheAlgorithms/Python/blob/master/maths/modular_exponential.py)
   * [newton raphson](https://github.com/TheAlgorithms/Python/blob/master/maths/newton_raphson.py)
   * [prime check](https://github.com/TheAlgorithms/Python/blob/master/maths/prime_check.py)
+  * [prime factors](https://github.com/TheAlgorithms/Python/blob/master/maths/prime_factors.py)
   * [segmented sieve](https://github.com/TheAlgorithms/Python/blob/master/maths/segmented_sieve.py)
   * [sieve of eratosthenes](https://github.com/TheAlgorithms/Python/blob/master/maths/sieve_of_eratosthenes.py)
   * [simpson rule](https://github.com/TheAlgorithms/Python/blob/master/maths/simpson_rule.py)
@@ -219,6 +221,8 @@
   * [rotate matrix](https://github.com/TheAlgorithms/Python/blob/master/matrix/rotate_matrix.py)
   * [searching in sorted matrix](https://github.com/TheAlgorithms/Python/blob/master/matrix/searching_in_sorted_matrix.py)
   * [spiral print](https://github.com/TheAlgorithms/Python/blob/master/matrix/spiral_print.py)
+  * Tests
+    * [test matrix operation](https://github.com/TheAlgorithms/Python/blob/master/matrix/tests/test_matrix_operation.py)
 ## Networking Flow
   * [ford fulkerson](https://github.com/TheAlgorithms/Python/blob/master/networking_flow/ford_fulkerson.py)
   * [minimum cut](https://github.com/TheAlgorithms/Python/blob/master/networking_flow/minimum_cut.py)
@@ -228,6 +232,7 @@
   * [fully connected neural network](https://github.com/TheAlgorithms/Python/blob/master/neural_network/fully_connected_neural_network.ipynb)
   * [perceptron](https://github.com/TheAlgorithms/Python/blob/master/neural_network/perceptron.py)
 ## Other
+  * [Food wastage analysis from 1961-2013 (FAO)](https://github.com/TheAlgorithms/Python/blob/master/other/Food%20wastage%20analysis%20from%201961-2013%20(FAO).ipynb)
   * [anagrams](https://github.com/TheAlgorithms/Python/blob/master/other/anagrams.py)
   * [binary exponentiation](https://github.com/TheAlgorithms/Python/blob/master/other/binary_exponentiation.py)
   * [binary exponentiation 2](https://github.com/TheAlgorithms/Python/blob/master/other/binary_exponentiation_2.py)
@@ -235,7 +240,6 @@
   * [euclidean gcd](https://github.com/TheAlgorithms/Python/blob/master/other/euclidean_gcd.py)
   * [finding primes](https://github.com/TheAlgorithms/Python/blob/master/other/finding_primes.py)
   * [fischer yates shuffle](https://github.com/TheAlgorithms/Python/blob/master/other/fischer_yates_shuffle.py)
-  * [Food wastage analysis from 1961-2013 (FAO)](https://github.com/TheAlgorithms/Python/blob/master/other/Food%20wastage%20analysis%20from%201961-2013%20(FAO).ipynb)
   * [frequency finder](https://github.com/TheAlgorithms/Python/blob/master/other/frequency_finder.py)
   * [game of life](https://github.com/TheAlgorithms/Python/blob/master/other/game_of_life.py)
   * [linear congruential generator](https://github.com/TheAlgorithms/Python/blob/master/other/linear_congruential_generator.py)
@@ -247,7 +251,6 @@
   * [tower of hanoi](https://github.com/TheAlgorithms/Python/blob/master/other/tower_of_hanoi.py)
   * [two sum](https://github.com/TheAlgorithms/Python/blob/master/other/two_sum.py)
   * [word patterns](https://github.com/TheAlgorithms/Python/blob/master/other/word_patterns.py)
-  * [words](https://github.com/TheAlgorithms/Python/blob/master/other/words)
 ## Project Euler
   * Problem 01
     * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_01/sol1.py)
diff --git a/scripts/build_directory_md.py b/scripts/build_directory_md.py
old mode 100644
new mode 100755
index 47192701880d..2ebd445b3667
--- a/scripts/build_directory_md.py
+++ b/scripts/build_directory_md.py
@@ -1,71 +1,45 @@
-"""
-This is a simple script that will scan through the current directory
-and generate the corresponding DIRECTORY.md file, can also specify
-files or folders to be ignored.
-"""
+#!/usr/bin/env python3
+
 import os
+from typing import Iterator
+
+URL_BASE = "https://github.com/TheAlgorithms/Python/blob/master"
+
 
+def good_filepaths(top_dir: str = ".") -> Iterator[str]:
+    for dirpath, dirnames, filenames in os.walk(top_dir):
+        dirnames[:] = [d for d in dirnames if d != "scripts" and d[0] not in "._"]
+        for filename in filenames:
+            if filename == "__init__.py":
+                continue
+            if os.path.splitext(filename)[1] in (".py", ".ipynb"):
+                yield os.path.join(dirpath, filename).lstrip("./")
 
-# Target URL (master)
-URL = "https://github.com/TheAlgorithms/Python/blob/master/"
 
+def md_prefix(i):
+    return f"{i * '  '}*" if i else "##"
 
-def tree(d, ignores, ignores_ext):
-    return _markdown(d, ignores, ignores_ext, 0)
-    
 
-def _markdown(parent, ignores, ignores_ext, depth):
-    out = ""
-    dirs, files = [], []
-    for i in os.listdir(parent):
-        full = os.path.join(parent, i)
-        name, ext = os.path.splitext(i)
-        if i not in ignores and ext not in ignores_ext:
-            if os.path.isfile(full):
-                # generate list
-                pre = parent.replace("./", "").replace(" ", "%20")
-                # replace all spaces to safe URL
-                child = i.replace(" ", "%20")
-                files.append((pre, child, name))
-            else:
-                dirs.append(i)   
-    # Sort files
-    files.sort(key=lambda e: e[2].lower())
-    for f in files:
-        pre, child, name = f
-        out += "  " * depth + "* [" + name.replace("_", " ") + "](" + URL + pre + "/" + child + ")\n"
-    # Sort directories
-    dirs.sort()
-    for i in dirs:
-        full = os.path.join(parent, i)
-        i = i.replace("_", " ").title()
-        if depth == 0:
-            out += "## " + i + "\n"
-        else:
-            out += "  " * depth + "* " + i + "\n"
-        out += _markdown(full, ignores, ignores_ext, depth+1)
-    return out
+def print_path(old_path: str, new_path: str) -> str:
+    old_parts = old_path.split(os.sep)
+    for i, new_part in enumerate(new_path.split(os.sep)):
+        if i + 1 > len(old_parts) or old_parts[i] != new_part:
+            if new_part:
+                print(f"{md_prefix(i)} {new_part.replace('_', ' ').title()}")
+    return new_path
 
 
-# Specific files or folders with the given names will be ignored
-ignores = [".vs",
-    ".gitignore",
-    ".git",
-    "scripts",
-    "__init__.py",
-    "requirements.txt",
-    ".github"
-]
-# Files with given entensions will be ignored
-ignores_ext = [
-    ".md",
-    ".ipynb",
-    ".png",
-    ".jpg",
-    ".yml"
-]
+def print_directory_md(top_dir: str = ".") -> None:
+    old_path = ""
+    for filepath in sorted(good_filepaths()):
+        filepath, filename = os.path.split(filepath)
+        if filepath != old_path:
+            old_path = print_path(old_path, filepath)
+        indent = (filepath.count(os.sep) + 1) if filepath else 0
+        url = "/".join((URL_BASE, filepath, filename)).replace(" ", "%20")
+        filename = os.path.splitext(filename.replace("_", " "))[0]
+        print(f"{md_prefix(indent)} [{filename}]({url})")
 
 
 if __name__ == "__main__":
-    with open("DIRECTORY.md", "w+") as f:
-        f.write(tree(".", ignores, ignores_ext))
+    print_directory_md(".")

From 7b2c9541691a8a1d6ac523287225bfc368146403 Mon Sep 17 00:00:00 2001
From: Abhijeeth S <abhikampurath@gmail.com>
Date: Tue, 30 Jul 2019 12:17:54 +0530
Subject: [PATCH 150/348] LargestOfVeryLargeNumbers (#818)

* LargestOfVeryLargeNumbers

Finds the largest among two very large numbers of the form x^y. Numbers like 512^513 etc

* Rename LargestOfVeryLargeNumbers to LargestOfVeryLargeNumbers.py

* Input() statements have been indented.

input() statements are indented under if __name__ == "__main__":

* largest_of_very_large_numbers.py
---
 maths/largest_of_very_large_numbers.py | 35 ++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 maths/largest_of_very_large_numbers.py

diff --git a/maths/largest_of_very_large_numbers.py b/maths/largest_of_very_large_numbers.py
new file mode 100644
index 000000000000..d2dc0af18126
--- /dev/null
+++ b/maths/largest_of_very_large_numbers.py
@@ -0,0 +1,35 @@
+# Author: Abhijeeth S
+
+import math
+
+
+def res(x, y):
+    if 0 not in (x, y):
+        # We use the relation x^y = y*log10(x), where 10 is the base.
+        return y * math.log10(x)
+    else:
+        if x == 0:  # 0 raised to any number is 0
+            return 0
+        elif y == 0:
+            return 1  # any number raised to 0 is 1
+
+
+if __name__ == "__main__":  # Main function
+    # Read two numbers from input and typecast them to int using map function.
+    # Here x is the base and y is the power.
+    prompt = "Enter the base and the power separated by a comma: "
+    x1, y1 = map(int, input(prompt).split(","))
+    x2, y2 = map(int, input(prompt).split(","))
+
+    # We find the log of each number, using the function res(), which takes two
+    # arguments.
+    res1 = res(x1, y1)
+    res2 = res(x2, y2)
+
+    # We check for the largest number
+    if res1 > res2:
+        print("Largest number is", x1, "^", y1)
+    elif res2 > res1:
+        print("Largest number is", x2, "^", y2)
+    else:
+        print("Both are equal")

From a9ecdb33ca04d44c979d8d9c1c99df312f4dd50c Mon Sep 17 00:00:00 2001
From: Christian Clauss <cclauss@me.com>
Date: Tue, 30 Jul 2019 12:02:13 +0200
Subject: [PATCH 151/348] Validate Python filenames (#1086)

---
 .travis.yml                                   |  1 +
 .../{NaiveBayes.ipynb => naive_bayes.ipynb}   |  0
 ...wastage_analysis_from_1961-2013_fao.ipynb} |  0
 scripts/validate_filenames.py                 | 28 +++++++++++++++++++
 4 files changed, 29 insertions(+)
 rename machine_learning/{NaiveBayes.ipynb => naive_bayes.ipynb} (100%)
 rename other/{Food wastage analysis from 1961-2013 (FAO).ipynb => food_wastage_analysis_from_1961-2013_fao.ipynb} (100%)
 create mode 100755 scripts/validate_filenames.py

diff --git a/.travis.yml b/.travis.yml
index d09ef9de262d..c46d0d1d653a 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -8,6 +8,7 @@ before_script:
   - black --check . || true
   - flake8 . --count --select=E9,F401,F63,F7,F82 --show-source --statistics
 script:
+  - scripts/validate_filenames.py  # no uppercase and no spaces
   - mypy --ignore-missing-imports .
   - pytest . --doctest-modules
       --ignore=data_structures/stacks/balanced_parentheses.py
diff --git a/machine_learning/NaiveBayes.ipynb b/machine_learning/naive_bayes.ipynb
similarity index 100%
rename from machine_learning/NaiveBayes.ipynb
rename to machine_learning/naive_bayes.ipynb
diff --git a/other/Food wastage analysis from 1961-2013 (FAO).ipynb b/other/food_wastage_analysis_from_1961-2013_fao.ipynb
similarity index 100%
rename from other/Food wastage analysis from 1961-2013 (FAO).ipynb
rename to other/food_wastage_analysis_from_1961-2013_fao.ipynb
diff --git a/scripts/validate_filenames.py b/scripts/validate_filenames.py
new file mode 100755
index 000000000000..9e1f1503321b
--- /dev/null
+++ b/scripts/validate_filenames.py
@@ -0,0 +1,28 @@
+#!/usr/bin/env python3
+
+import os
+from build_directory_md import good_filepaths
+
+filepaths = list(good_filepaths())
+assert filepaths, "good_filepaths() failed!"
+
+
+upper_files = [file for file in filepaths if file != file.lower()]
+if upper_files:
+    print(f"{len(upper_files)} files contain uppercase characters:")
+    print("\n".join(upper_files) + "\n")
+
+space_files = [file for file in filepaths if " " in file]
+if space_files:
+    print(f"{len(space_files)} files contain space characters:")
+    print("\n".join(space_files) + "\n")
+
+nodir_files = [file for file in filepaths if os.sep not in file]
+if nodir_files:
+    print(f"{len(nodir_files)} files are not in a directory:")
+    print("\n".join(nodir_files) + "\n")
+
+bad_files = len(upper_files + space_files + nodir_files)
+if bad_files:
+    import sys
+    sys.exit(bad_files)

From 861a8c36316a0bb10ee93f5560ce3313ef991399 Mon Sep 17 00:00:00 2001
From: obelisk0114 <obelisk0114@yahoo.com.tw>
Date: Tue, 30 Jul 2019 09:00:24 -0700
Subject: [PATCH 152/348] Add Lucas_Lehmer_primality_test (#1050)

* Add Lucas_Lehmer_primality_test

* Add explanation for Lucas_Lehmer_primality_test

* Update and rename Lucas_Lehmer_primality_test.py to lucas_lehmer_primality_test.py
---
 maths/lucas_lehmer_primality_test.py | 42 ++++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)
 create mode 100644 maths/lucas_lehmer_primality_test.py

diff --git a/maths/lucas_lehmer_primality_test.py b/maths/lucas_lehmer_primality_test.py
new file mode 100644
index 000000000000..44e41ba58d93
--- /dev/null
+++ b/maths/lucas_lehmer_primality_test.py
@@ -0,0 +1,42 @@
+# -*- coding: utf-8 -*-
+"""
+        In mathematics, the Lucas–Lehmer test (LLT) is a primality test for Mersenne numbers.
+        https://en.wikipedia.org/wiki/Lucas%E2%80%93Lehmer_primality_test
+        
+        A Mersenne number is a number that is one less than a power of two.
+        That is M_p = 2^p - 1
+        https://en.wikipedia.org/wiki/Mersenne_prime
+        
+        The Lucas–Lehmer test is the primality test used by the 
+        Great Internet Mersenne Prime Search (GIMPS) to locate large primes.
+"""
+
+
+# Primality test 2^p - 1
+# Return true if 2^p - 1 is prime
+def lucas_lehmer_test(p: int) -> bool:
+    """
+    >>> lucas_lehmer_test(p=7)
+    True
+    
+    >>> lucas_lehmer_test(p=11)
+    False
+    
+    # M_11 = 2^11 - 1 = 2047 = 23 * 89
+    """
+
+    if p < 2:
+        raise ValueError("p should not be less than 2!")
+    elif p == 2:
+        return True
+
+    s = 4
+    M = (1 << p) - 1
+    for i in range(p - 2):
+        s = ((s * s) - 2) % M
+    return s == 0
+
+
+if __name__ == "__main__":
+    print(lucas_lehmer_test(7))
+    print(lucas_lehmer_test(11))

From e58a5e68424df74a4c7b30df04162c775044405c Mon Sep 17 00:00:00 2001
From: FrogBattle <44649323+FrogBattle@users.noreply.github.com>
Date: Tue, 30 Jul 2019 17:06:48 +0100
Subject: [PATCH 153/348] Update tim_sort.py (#972)

* Update tim_sort.py


Update tim_sort.py

The previous algorithm was skipping numbers, according to issue #959, and my own tests.
The version I am applying uses a while loop, which works correctly and is easier to compute, as there is no break statement.

* Update tim_sort.py
---
 sorts/tim_sort.py | 47 ++++++++++++++++++++++++-----------------------
 1 file changed, 24 insertions(+), 23 deletions(-)

diff --git a/sorts/tim_sort.py b/sorts/tim_sort.py
index b4032b91aec1..b95ff34cf384 100644
--- a/sorts/tim_sort.py
+++ b/sorts/tim_sort.py
@@ -1,10 +1,6 @@
-from __future__ import print_function
 def binary_search(lst, item, start, end):
     if start == end:
-        if lst[start] > item:
-            return start
-        else:
-            return start + 1
+        return start if lst[start] > item else start + 1
     if start > end:
         return start
 
@@ -23,7 +19,7 @@ def insertion_sort(lst):
     for index in range(1, length):
         value = lst[index]
         pos = binary_search(lst, value, 0, index - 1)
-        lst = lst[:pos] + [value] + lst[pos:index] + lst[index+1:]
+        lst = lst[:pos] + [value] + lst[pos:index] + lst[index + 1 :]
 
     return lst
 
@@ -42,30 +38,34 @@ def merge(left, right):
 
 
 def tim_sort(lst):
-    runs, sorted_runs = [], []
+    """
+    >>> tim_sort("Python")
+    ['P', 'h', 'n', 'o', 't', 'y']
+    >>> tim_sort((1.1, 1, 0, -1, -1.1))
+    [-1.1, -1, 0, 1, 1.1]
+    >>> tim_sort(list(reversed(list(range(7)))))
+    [0, 1, 2, 3, 4, 5, 6]
+    >>> tim_sort([3, 2, 1]) == insertion_sort([3, 2, 1])
+    True
+    >>> tim_sort([3, 2, 1]) == sorted([3, 2, 1])
+    True
+    """
     length = len(lst)
+    runs, sorted_runs = [], []
     new_run = [lst[0]]
     sorted_array = []
-
-    for i in range(1, length):
-        if i == length - 1:
-            new_run.append(lst[i])
-            runs.append(new_run)
-            break
-
+    i = 1
+    while i < length:
         if lst[i] < lst[i - 1]:
-            if not new_run:
-                runs.append([lst[i - 1]])
-                new_run.append(lst[i])
-            else:
-                runs.append(new_run)
-                new_run = []
+            runs.append(new_run)
+            new_run = [lst[i]]
         else:
             new_run.append(lst[i])
+        i += 1
+    runs.append(new_run)
 
     for run in runs:
         sorted_runs.append(insertion_sort(run))
-
     for run in sorted_runs:
         sorted_array = merge(sorted_array, run)
 
@@ -74,9 +74,10 @@ def tim_sort(lst):
 
 def main():
 
-    lst = [5,9,10,3,-4,5,178,92,46,-18,0,7]
+    lst = [5, 9, 10, 3, -4, 5, 178, 92, 46, -18, 0, 7]
     sorted_lst = tim_sort(lst)
     print(sorted_lst)
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
     main()

From 4a5589f4fcb71fc6101132bad44981693ef65d2c Mon Sep 17 00:00:00 2001
From: vinayak <itssvinayak@gmail.com>
Date: Wed, 31 Jul 2019 16:50:32 +0530
Subject: [PATCH 154/348] project_euler/problem_10 (#1089)

* project_euler/problem_10

* update project_euler/problem_10

* update project_euler/problem_10

* Negative user tests added.
---
 project_euler/problem_10/sol3.py | 58 ++++++++++++++++++++++++++++++++
 1 file changed, 58 insertions(+)
 create mode 100644 project_euler/problem_10/sol3.py

diff --git a/project_euler/problem_10/sol3.py b/project_euler/problem_10/sol3.py
new file mode 100644
index 000000000000..e5bc0731d8ab
--- /dev/null
+++ b/project_euler/problem_10/sol3.py
@@ -0,0 +1,58 @@
+"""
+https://projecteuler.net/problem=10
+
+Problem Statement:
+The sum of the primes below 10 is 2 + 3 + 5 + 7 = 17.
+
+Find the sum of all the primes below two million using Sieve_of_Eratosthenes:
+
+The sieve of Eratosthenes is one of the most efficient ways to find all primes
+smaller than n when n is smaller than 10 million.  Only for positive numbers.
+"""
+
+
+def prime_sum(n: int) -> int:
+    """ Returns the sum of all the primes below n.
+
+    >>> prime_sum(2_000_000)
+    142913828922
+    >>> prime_sum(1_000)
+    76127
+    >>> prime_sum(5_000)
+    1548136
+    >>> prime_sum(10_000)
+    5736396
+    >>> prime_sum(7)
+    10
+    >>> prime_sum(7.1)  # doctest: +ELLIPSIS
+    Traceback (most recent call last):
+    ...
+    TypeError: 'float' object cannot be interpreted as an integer
+    >>> prime_sum(-7)  # doctest: +ELLIPSIS
+    Traceback (most recent call last):
+    ...
+    IndexError: list assignment index out of range
+    >>> prime_sum("seven")  # doctest: +ELLIPSIS
+    Traceback (most recent call last):
+    ...
+    TypeError: can only concatenate str (not "int") to str
+    """
+    list_ = [0 for i in range(n + 1)]
+    list_[0] = 1
+    list_[1] = 1
+
+    for i in range(2, int(n ** 0.5) + 1):
+        if list_[i] == 0:
+            for j in range(i * i, n + 1, i):
+                list_[j] = 1
+    s = 0
+    for i in range(n):
+        if list_[i] == 0:
+            s += i
+    return s
+
+
+if __name__ == "__main__":
+    # import doctest
+    # doctest.testmod()
+    print(prime_sum(int(input().strip())))

From 7b267e5e4f8ccb72dd58fcf0057642fd62a36bdf Mon Sep 17 00:00:00 2001
From: Christian Clauss <cclauss@me.com>
Date: Wed, 31 Jul 2019 17:14:35 +0200
Subject: [PATCH 155/348] Fix data_structures to pass our Travis CI pytests
 (#1088)

* Fix data_structures to pass pytests

* Restore data_structures/stacks/__init__.py
---
 .travis.yml                                           | 2 --
 data_structures/stacks/balanced_parentheses.py        | 3 ++-
 data_structures/stacks/infix_to_postfix_conversion.py | 2 +-
 3 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index c46d0d1d653a..eab55af63492 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -11,8 +11,6 @@ script:
   - scripts/validate_filenames.py  # no uppercase and no spaces
   - mypy --ignore-missing-imports .
   - pytest . --doctest-modules
-      --ignore=data_structures/stacks/balanced_parentheses.py
-      --ignore=data_structures/stacks/infix_to_postfix_conversion.py
       --ignore=file_transfer_protocol/ftp_send_receive.py
       --ignore=file_transfer_protocol/ftp_client_server.py
       --ignore=machine_learning/linear_regression.py
diff --git a/data_structures/stacks/balanced_parentheses.py b/data_structures/stacks/balanced_parentheses.py
index 3229d19c8621..36a4e07a97a3 100644
--- a/data_structures/stacks/balanced_parentheses.py
+++ b/data_structures/stacks/balanced_parentheses.py
@@ -1,6 +1,7 @@
 from __future__ import print_function
 from __future__ import absolute_import
-from stack import Stack
+
+from .stack import Stack
 
 __author__ = 'Omkar Pathak'
 
diff --git a/data_structures/stacks/infix_to_postfix_conversion.py b/data_structures/stacks/infix_to_postfix_conversion.py
index e71dccf1f45c..9376b55b8b23 100644
--- a/data_structures/stacks/infix_to_postfix_conversion.py
+++ b/data_structures/stacks/infix_to_postfix_conversion.py
@@ -2,7 +2,7 @@
 from __future__ import absolute_import
 import string
 
-from stack import Stack
+from .stack import Stack
 
 __author__ = 'Omkar Pathak'
 

From 9c0cbe33076a570a3c02825b7c6d9866a760e777 Mon Sep 17 00:00:00 2001
From: Sanders Lin <45224617+SandersLin@users.noreply.github.com>
Date: Thu, 1 Aug 2019 23:54:03 +0800
Subject: [PATCH 156/348] Create  collatz_sequence.py (#639)

* Create  collatz_sequence.py

* Update and rename collatz_sequence.py to maths/collatz_sequence.py

* doctest
---
 maths/collatz_sequence.py | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 maths/collatz_sequence.py

diff --git a/maths/collatz_sequence.py b/maths/collatz_sequence.py
new file mode 100644
index 000000000000..9f88453d518b
--- /dev/null
+++ b/maths/collatz_sequence.py
@@ -0,0 +1,28 @@
+def collatz_sequence(n):
+    """
+    Collatz conjecture: start with any positive integer n.Next termis obtained from the previous term as follows: 
+    if the previous term is even, the next term is one half the previous term. 
+    If the previous term is odd, the next term is 3 times the previous term plus 1. 
+    The conjecture states the sequence will always reach 1 regaardess of starting n.
+    Example:
+    >>> collatz_sequence(43)
+    [43, 130, 65, 196, 98, 49, 148, 74, 37, 112, 56, 28, 14, 7, 22, 11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1]
+    """
+    sequence = [n]
+    while n != 1:
+        if n % 2 == 0:# even
+            n //= 2 
+        else:
+            n = 3*n +1
+        sequence.append(n)
+    return sequence
+
+
+def main():
+    n = 43
+    sequence = collatz_sequence(n)
+    print(sequence)
+    print("collatz sequence from %d took %d steps."%(n,len(sequence)))
+
+if __name__ == '__main__':
+    main()

From e3131419048010d9d67441387da4e73755364cf2 Mon Sep 17 00:00:00 2001
From: Syed Waleed Hyder <syedwaleedhyder@gmail.com>
Date: Sat, 3 Aug 2019 20:00:10 +0200
Subject: [PATCH 157/348] bin(num). convert ZERO and negative decimal numbers
 to binary. (#1093)

* bin(num) can convert ZERO and negative decimal numbers to binary. Consistent with built-in python bin(x) function.

* bin(num) can convert ZERO and negative decimal numbers to binary. Consistent with built-in python bin(x) function.

* Added doctests. bin(num) can convert ZERO and negative decimal numbers to binary. Consistent with built-in python bin(x) function.

* Added doctests. bin(num) can convert ZERO and negative decimal numbers to binary. Consistent with built-in python bin(x) function.

* Added doctests. bin(num) can convert ZERO and negative decimal numbers to binary. Consistent with built-in python bin(x) function.

* doctests still failing.

* Doctests added.
---
 conversions/decimal_to_binary.py | 59 +++++++++++++++++++++++++-------
 1 file changed, 46 insertions(+), 13 deletions(-)

diff --git a/conversions/decimal_to_binary.py b/conversions/decimal_to_binary.py
index 43ceee61a388..934cf0dfb363 100644
--- a/conversions/decimal_to_binary.py
+++ b/conversions/decimal_to_binary.py
@@ -2,24 +2,57 @@
 
 
 def decimal_to_binary(num):
-    """Convert a Decimal Number to a Binary Number."""
+
+    """
+        Convert a Integer Decimal Number to a Binary Number as str.
+        >>> decimal_to_binary(0)
+        '0b0'
+        >>> decimal_to_binary(2)
+        '0b10'
+        >>> decimal_to_binary(7)
+        '0b111'
+        >>> decimal_to_binary(35)
+        '0b100011'
+        >>> # negatives work too
+        >>> decimal_to_binary(-2)
+        '-0b10'
+        >>> # other floats will error
+        >>> decimal_to_binary(16.16) # doctest: +ELLIPSIS
+        Traceback (most recent call last):
+        ...
+        TypeError: 'float' object cannot be interpreted as an integer
+        >>> # strings will error as well
+        >>> decimal_to_binary('0xfffff') # doctest: +ELLIPSIS
+        Traceback (most recent call last):
+        ...
+        TypeError: 'str' object cannot be interpreted as an integer
+    """
+
+    if type(num) == float:
+        raise TypeError("'float' object cannot be interpreted as an integer")
+    if type(num) == str:
+        raise TypeError("'str' object cannot be interpreted as an integer")
+
+    if num == 0:
+        return "0b0"
+
+    negative = False
+
+    if num < 0:
+        negative = True
+        num = -num
+
     binary = []
     while num > 0:
         binary.insert(0, num % 2)
         num >>= 1
-    return "".join(str(e) for e in binary)
 
+    if negative:
+        return "-0b" + "".join(str(e) for e in binary)
 
-def main():
-    """Print binary equivelents of decimal numbers."""
-    print("\n2 in binary is:")
-    print(decimal_to_binary(2))  # = 10
-    print("\n7 in binary is:")
-    print(decimal_to_binary(7))  # = 111
-    print("\n35 in binary is:")
-    print(decimal_to_binary(35))  # = 100011
-    print("\n")
+    return "0b" + "".join(str(e) for e in binary)
 
 
-if __name__ == '__main__':
-    main()
+if __name__ == "__main__":
+    import doctest
+    doctest.testmod()

From bdbe6825684d61131e0caee3a7361bd581c2442b Mon Sep 17 00:00:00 2001
From: "Marvin M. Michum" <mrvnmchm@gmail.com>
Date: Sun, 4 Aug 2019 23:22:28 -0400
Subject: [PATCH 158/348] Zeller's Congruence Algorithm (#1095)

* doctest updates

* remove unused math import

* cleanup (suggestions)

* cleanup - Dict fix (TravisCI error)
---
 maths/zellers_congruence.py | 157 ++++++++++++++++++++++++++++++++++++
 1 file changed, 157 insertions(+)
 create mode 100644 maths/zellers_congruence.py

diff --git a/maths/zellers_congruence.py b/maths/zellers_congruence.py
new file mode 100644
index 000000000000..e04425eec903
--- /dev/null
+++ b/maths/zellers_congruence.py
@@ -0,0 +1,157 @@
+from __future__ import annotations
+import datetime
+import argparse
+
+
+def zeller(date_input: str) -> str:
+
+    """
+    Zellers Congruence Algorithm
+    Find the day of the week for nearly any Gregorian or Julian calendar date 
+
+    >>> zeller('01-31-2010')
+    'Your date 01-31-2010, is a Sunday!'
+
+    Validate out of range month
+    >>> zeller('13-31-2010')
+    Traceback (most recent call last):
+    ...
+    ValueError: Month must be between 1 - 12
+    >>> zeller('.2-31-2010')
+    Traceback (most recent call last):
+    ...
+    ValueError: invalid literal for int() with base 10: '.2'
+
+    Validate out of range date:
+    >>> zeller('01-33-2010')
+    Traceback (most recent call last):
+        ...
+    ValueError: Date must be between 1 - 31
+    >>> zeller('01-.4-2010')
+    Traceback (most recent call last):
+        ...
+    ValueError: invalid literal for int() with base 10: '.4'
+
+    Validate second seperator:
+    >>> zeller('01-31*2010')
+    Traceback (most recent call last):
+        ...
+    ValueError: Date seperator must be '-' or '/'
+
+    Validate first seperator:
+    >>> zeller('01^31-2010')
+    Traceback (most recent call last):
+        ...
+    ValueError: Date seperator must be '-' or '/'
+
+    Validate out of range year:
+    >>> zeller('01-31-8999')
+    Traceback (most recent call last):
+        ...
+    ValueError: Year out of range. There has to be some sort of limit...right?
+
+    Test null input:
+    >>> zeller()
+    Traceback (most recent call last):
+        ...
+    TypeError: zeller() missing 1 required positional argument: 'date_input'
+
+    Test length fo date_input:
+    >>> zeller('')
+    Traceback (most recent call last):
+        ...
+    ValueError: Must be 10 characters long
+    >>> zeller('01-31-19082939')
+    Traceback (most recent call last):
+        ...
+    ValueError: Must be 10 characters long
+"""
+
+    # Days of the week for response
+    days = {
+        '0': 'Sunday',
+        '1': 'Monday',
+        '2': 'Tuesday',
+        '3': 'Wednesday',
+        '4': 'Thursday',
+        '5': 'Friday',
+        '6': 'Saturday'
+    }
+
+    convert_datetime_days = {
+        0:1,
+        1:2,
+        2:3,
+        3:4,
+        4:5,
+        5:6,
+        6:0
+    }
+
+    # Validate
+    if not 0 < len(date_input) < 11:
+        raise ValueError("Must be 10 characters long")
+
+    # Get month
+    m: int = int(date_input[0] + date_input[1])
+    # Validate
+    if not 0 < m < 13:
+        raise ValueError("Month must be between 1 - 12")
+
+    sep_1:str = date_input[2]
+    # Validate
+    if sep_1 not in ["-","/"]:
+        raise ValueError("Date seperator must be '-' or '/'")
+
+    # Get day
+    d: int = int(date_input[3] + date_input[4])
+    # Validate
+    if not 0 < d < 32:
+        raise ValueError("Date must be between 1 - 31")
+    
+    # Get second seperator
+    sep_2: str = date_input[5]
+    # Validate
+    if sep_2 not in ["-","/"]:
+        raise ValueError("Date seperator must be '-' or '/'")
+
+    # Get year
+    y: int = int(date_input[6] + date_input[7] + date_input[8] + date_input[9])
+    # Arbitrary year range
+    if not 45 < y < 8500:
+        raise ValueError("Year out of range. There has to be some sort of limit...right?")
+
+    # Get datetime obj for validation
+    dt_ck = datetime.date(int(y), int(m), int(d))
+
+    # Start math
+    if m <= 2:
+        y = y - 1
+        m = m + 12
+    # maths var
+    c: int = int(str(y)[:2])
+    k: int = int(str(y)[2:])
+    t: int = int(2.6*m - 5.39)
+    u: int = int(c / 4)
+    v: int = int(k / 4)
+    x: int = int(d + k)
+    z: int = int(t + u + v + x)
+    w: int = int(z - (2 * c))
+    f: int = round(w%7)
+    # End math
+
+    # Validate math
+    if f != convert_datetime_days[dt_ck.weekday()]:
+        raise AssertionError("The date was evaluated incorrectly. Contact developer.")
+
+    # Response
+    response: str = f"Your date {date_input}, is a {days[str(f)]}!"
+    return response
+
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod()
+    parser = argparse.ArgumentParser(description='Find out what day of the week nearly any date is or was. Enter date as a string in the mm-dd-yyyy or mm/dd/yyyy format')
+    parser.add_argument('date_input', type=str, help='Date as a string (mm-dd-yyyy or mm/dd/yyyy)')
+    args = parser.parse_args()
+    zeller(args.date_input)

From 87a789af515333c35aed1060c7a2b5c7d287123c Mon Sep 17 00:00:00 2001
From: "Marvin M. Michum" <mrvnmchm@gmail.com>
Date: Mon, 5 Aug 2019 01:05:36 -0400
Subject: [PATCH 159/348] Boolean algebra pytests (#1097)

* Added Zeller's congruence algorithm

* Update args help

* add a few doctests

* remove old file
---
 boolean_algebra/quine_mc_cluskey.py | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/boolean_algebra/quine_mc_cluskey.py b/boolean_algebra/quine_mc_cluskey.py
index db4d153cbfd7..94319ca45482 100644
--- a/boolean_algebra/quine_mc_cluskey.py
+++ b/boolean_algebra/quine_mc_cluskey.py
@@ -1,3 +1,18 @@
+"""
+	doctests
+
+	>>> decimal_to_binary(3,[1.5])
+	['0.00.01.5']
+
+	>>> check(['0.00.01.5'])
+	['0.00.01.5']
+
+	>>> prime_implicant_chart(['0.00.01.5'],['0.00.01.5'])
+	[[1]]
+
+	>>> selection([[1]],['0.00.01.5'])
+	['0.00.01.5']
+"""
 def compare_string(string1, string2):
 	l1 = list(string1); l2 = list(string2)
 	count = 0
@@ -113,4 +128,6 @@ def main():
 	print(essential_prime_implicants)
 
 if __name__ == '__main__':
+	import doctest
+	doctest.testmod()
 	main()

From 4437439363c8aa3347dfcd817afe7c69b3d7f59e Mon Sep 17 00:00:00 2001
From: Hector S <hfsam88@gmail.com>
Date: Mon, 5 Aug 2019 01:07:52 -0400
Subject: [PATCH 160/348] Added Unicode test to strings/rabin_karp.py  (#1096)

* Added print function into matrix_multiplication_addition.py and removed blank space in data_structures/binary tree directory

* Removed .vs/ folder per #893

* Rename matrix_multiplication_addition.py to matrix_operation.py

* Unicode test on strings/rabin_karp.py per #1067
---
 strings/rabin_karp.py | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/strings/rabin_karp.py b/strings/rabin_karp.py
index 7c36f7659e24..1fb145ec97fa 100644
--- a/strings/rabin_karp.py
+++ b/strings/rabin_karp.py
@@ -73,6 +73,13 @@ def test_rabin_karp():
     pattern = "abcdabcy"
     text = "abcxabcdabxabcdabcdabcy"
     assert rabin_karp(pattern, text)
+
+    # Test 5)
+    pattern = "Lü"
+    text = "Lüsai"
+    assert rabin_karp(pattern, text)
+    pattern = "Lue"
+    assert not rabin_karp(pattern, text)
     print("Success.")
 
 

From 47bc34ac268d1b0102c72d9cf5f2b7cb52db6a5e Mon Sep 17 00:00:00 2001
From: QuantumNovice <43876848+QuantumNovice@users.noreply.github.com>
Date: Tue, 6 Aug 2019 05:06:15 +0500
Subject: [PATCH 161/348] Added pytests to sha1.py (#1098)

---
 16L'           |  0
 Q'             |  0
 hashes/sha1.py | 10 ++++++++--
 3 files changed, 8 insertions(+), 2 deletions(-)
 create mode 100644 16L'
 create mode 100644 Q'

diff --git a/16L' b/16L'
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/Q' b/Q'
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/hashes/sha1.py b/hashes/sha1.py
index 4c78ad3a89e5..511ea6363733 100644
--- a/hashes/sha1.py
+++ b/hashes/sha1.py
@@ -2,7 +2,7 @@
 Demonstrates implementation of SHA1 Hash function in a Python class and gives utilities
 to find hash of string or hash of text from a file.
 Usage: python sha1.py --string "Hello World!!"
-       pyhton sha1.py --file "hello_world.txt"
+       python sha1.py --file "hello_world.txt"
        When run without any arguments, it prints the hash of the string "Hello World!! Welcome to Cryptography"
 Also contains a Test class to verify that the generated Hash is same as that
 returned by the hashlib library
@@ -32,6 +32,8 @@
 class SHA1Hash:
     """
     Class to contain the entire pipeline for SHA1 Hashing Algorithm
+    >>> SHA1Hash(bytes('Allan', 'utf-8')).final_hash()
+    '872af2d8ac3d8695387e7c804bf0e02c18df9e6e'
     """
     def __init__(self, data):
         """
@@ -47,6 +49,8 @@ def __init__(self, data):
     def rotate(n, b):
         """
         Static method to be used inside other methods. Left rotates n by b.
+        >>> SHA1Hash('').rotate(12,2)
+        48
         """
         return ((n << b) | (n >> (32 - b))) & 0xffffffff
 
@@ -68,7 +72,7 @@ def split_blocks(self):
     def expand_block(self, block):
         """
         Takes a bytestring-block of length 64, unpacks it to a list of integers and returns a
-        list of 80 integers pafter some bit operations
+        list of 80 integers after some bit operations
         """
         w = list(struct.unpack('>16L', block)) + [0] * 64
         for i in range(16, 80):
@@ -146,3 +150,5 @@ def main():
 
 if __name__ == '__main__':
     main()
+    import doctest
+    doctest.testmod()
\ No newline at end of file

From 22d2453773522b677052d074ca0b8f2315309a01 Mon Sep 17 00:00:00 2001
From: AugustofCravo <49079453+AugustofCravo@users.noreply.github.com>
Date: Mon, 5 Aug 2019 21:22:34 -0300
Subject: [PATCH 162/348] Create Quadratic Equations(Complexes Numbers) (#941)

* Create Quadratic Equations(Complexes Numbers)

Created function that solves quadratic equations treating the cases with complexes numbers. Giving an answer with the imaginary unit "i".

* Update Quadratic Equations(Complexes Numbers)

Since there was no response from the owner of this PR, I made this little change which I hope will solve the issue!
---
 maths/Quadratic Equations(Complexes Numbers) | 40 ++++++++++++++++++++
 1 file changed, 40 insertions(+)
 create mode 100644 maths/Quadratic Equations(Complexes Numbers)

diff --git a/maths/Quadratic Equations(Complexes Numbers) b/maths/Quadratic Equations(Complexes Numbers)
new file mode 100644
index 000000000000..8e8e78fec68f
--- /dev/null
+++ b/maths/Quadratic Equations(Complexes Numbers)	
@@ -0,0 +1,40 @@
+from __future__ import print_function
+import math
+
+def QuadraticEquation(a,b,c):
+    """
+    Prints the solutions for a quadratic equation, given the numerical coefficients a, b and c,
+    for a*x*x + b*x + c.
+    Ex.: a = 1, b = 3, c = -4
+    Solution1 = 1 and Solution2 = -4
+    """
+    Delta = b*b - 4*a*c
+    if a != 0:
+        if Delta >= 0:
+            Solution1 = (-b + math.sqrt(Delta))/(2*a)
+            Solution2 = (-b - math.sqrt(Delta))/(2*a)
+            print ("The equation solutions are: ", Solution1," and ", Solution2)
+        else:
+            """
+            Treats cases of Complexes Solutions(i = imaginary unit)
+            Ex.: a = 5, b = 2, c = 1
+            Solution1 = (- 2 + 4.0 *i)/2 and Solution2 = (- 2 + 4.0 *i)/ 10
+            """
+            if b > 0:
+                print("The equation solutions are: (-",b,"+",math.sqrt(-Delta),"*i)/2  and  (-",b,"+",math.sqrt(-Delta),"*i)/", 2*a)
+            if b < 0:
+                print("The equation solutions are: (",b,"+",math.sqrt(-Delta),"*i)/2  and  (",b,"+",math.sqrt(-Delta),"*i/",2*a)
+            if b == 0:
+                print("The equation solutions are: (",math.sqrt(-Delta),"*i)/2  and  ",math.sqrt(-Delta),"*i)/", 2*a)
+    else: 
+        print("Error. Please, coeficient 'a' must not be zero for quadratic equations.")
+def main():
+    a = 5
+    b = 6
+    c = 1
+
+    QuadraticEquation(a,b,c) # The equation solutions are:  -0.2  and  -1.0
+    
+    
+if __name__ == '__main__':
+    main()

From 58126406fd345c4f0dda6b7d8d5beaa1b9360810 Mon Sep 17 00:00:00 2001
From: rsun0013 <50036197+rsun0013@users.noreply.github.com>
Date: Tue, 6 Aug 2019 19:17:17 +1000
Subject: [PATCH 163/348] pytests for closest_pair_of_points.py (#1099)

added some tests to the file
---
 divide_and_conquer/closest_pair_of_points.py | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/divide_and_conquer/closest_pair_of_points.py b/divide_and_conquer/closest_pair_of_points.py
index ee06d27063df..b6f63396410c 100644
--- a/divide_and_conquer/closest_pair_of_points.py
+++ b/divide_and_conquer/closest_pair_of_points.py
@@ -19,6 +19,19 @@
 Time complexity: O(n * log n)
 """
 
+"""
+	doctests
+	>>> euclidean_distance_sqr([1,2],[2,4])
+	5
+	>>> dis_between_closest_pair([[1,2],[2,4],[5,7],[8,9],[11,0]],5)
+	5
+	>>> dis_between_closest_in_strip([[1,2],[2,4],[5,7],[8,9],[11,0]],5)
+ 85
+	>>> points = [(2, 3), (12, 30), (40, 50), (5, 1), (12, 10), (3, 4)] 
+ >>> print("Distance:", closest_pair_of_points(points, len(points)))
+	"Distance: 1.4142135623730951"
+"""
+
 
 def euclidean_distance_sqr(point1, point2):
     return (point1[0] - point2[0]) ** 2 + (point1[1] - point2[1]) ** 2

From 6654e1ec7de8c4ca6ee604799645b4b210856190 Mon Sep 17 00:00:00 2001
From: Harshil <darjiharshil2994@gmail.com>
Date: Tue, 6 Aug 2019 11:41:23 +0200
Subject: [PATCH 164/348] remove from __future__, propre filename (#1102)

---
 ...Complexes Numbers) => quadratic_equations_complex_numbers.py} | 1 -
 1 file changed, 1 deletion(-)
 rename maths/{Quadratic Equations(Complexes Numbers) => quadratic_equations_complex_numbers.py} (97%)

diff --git a/maths/Quadratic Equations(Complexes Numbers) b/maths/quadratic_equations_complex_numbers.py
similarity index 97%
rename from maths/Quadratic Equations(Complexes Numbers)
rename to maths/quadratic_equations_complex_numbers.py
index 8e8e78fec68f..f05b938fefe9 100644
--- a/maths/Quadratic Equations(Complexes Numbers)	
+++ b/maths/quadratic_equations_complex_numbers.py
@@ -1,4 +1,3 @@
-from __future__ import print_function
 import math
 
 def QuadraticEquation(a,b,c):

From 89acf5d01733754b1403df2313a0a6ef17b4b051 Mon Sep 17 00:00:00 2001
From: Christian Clauss <cclauss@me.com>
Date: Tue, 6 Aug 2019 12:14:23 +0200
Subject: [PATCH 165/348] print() is a function just like every other function
 (#1101)

* print() is a function just like every other function
---
 arithmetic_analysis/newton_raphson_method.py  | 16 ++--
 ciphers/caesar_cipher.py                      |  6 +-
 ciphers/morse_code_implementation.py          |  4 +-
 ciphers/trafid_cipher.py                      | 14 +--
 ciphers/xor_cipher.py                         | 18 ++--
 data_structures/binary_tree/fenwick_tree.py   | 12 +--
 .../binary_tree/lazy_segment_tree.py          | 18 ++--
 data_structures/binary_tree/segment_tree.py   | 20 ++--
 data_structures/queue/double_ended_queue.py   | 42 ++++-----
 data_structures/stacks/stock_span_problem.py  | 92 +++++++++----------
 machine_learning/logistic_regression.py       | 10 +-
 maths/quadratic_equations_complex_numbers.py  |  8 +-
 other/fischer_yates_shuffle.py                |  6 +-
 13 files changed, 133 insertions(+), 133 deletions(-)

diff --git a/arithmetic_analysis/newton_raphson_method.py b/arithmetic_analysis/newton_raphson_method.py
index 569f96476afc..bb6fdd2193ec 100644
--- a/arithmetic_analysis/newton_raphson_method.py
+++ b/arithmetic_analysis/newton_raphson_method.py
@@ -8,25 +8,25 @@ def NewtonRaphson(func, a):
     ''' Finds root from the point 'a' onwards by Newton-Raphson method '''
     while True:
         c = Decimal(a) - ( Decimal(eval(func)) / Decimal(eval(str(diff(func)))) )
-        
+
         a = c
 
         # This number dictates the accuracy of the answer
         if  abs(eval(func)) < 10**-15:
             return  c
-    
+
 
 # Let's Execute
 if __name__ == '__main__':
     # Find root of trigonometric function
     # Find value of pi
-    print ('sin(x) = 0', NewtonRaphson('sin(x)', 2))
-    
+    print('sin(x) = 0', NewtonRaphson('sin(x)', 2))
+
     # Find root of polynomial
-    print ('x**2 - 5*x +2 = 0', NewtonRaphson('x**2 - 5*x +2', 0.4))
-    
+    print('x**2 - 5*x +2 = 0', NewtonRaphson('x**2 - 5*x +2', 0.4))
+
     # Find Square Root of 5
-    print ('x**2 - 5 = 0', NewtonRaphson('x**2 - 5', 0.1))
+    print('x**2 - 5 = 0', NewtonRaphson('x**2 - 5', 0.1))
 
     # Exponential Roots
-    print ('exp(x) - 1 = 0', NewtonRaphson('exp(x) - 1', 0))
+    print('exp(x) - 1 = 0', NewtonRaphson('exp(x) - 1', 0))
diff --git a/ciphers/caesar_cipher.py b/ciphers/caesar_cipher.py
index 872b5d8195c1..95d65d404266 100644
--- a/ciphers/caesar_cipher.py
+++ b/ciphers/caesar_cipher.py
@@ -41,12 +41,12 @@ def main():
         print("4.Quit")
         choice = input("What would you like to do?: ")
         if choice not in ['1', '2', '3', '4']:
-            print ("Invalid choice, please enter a valid choice")
+            print("Invalid choice, please enter a valid choice")
         elif choice == '1':
             strng = input("Please enter the string to be encrypted: ")
             key = int(input("Please enter off-set between 1-94: "))
             if key in range(1, 95):
-                print (encrypt(strng.lower(), key))
+                print(encrypt(strng.lower(), key))
         elif choice == '2':
             strng = input("Please enter the string to be decrypted: ")
             key = int(input("Please enter off-set between 1-94: "))
@@ -57,7 +57,7 @@ def main():
             brute_force(strng)
             main()
         elif choice == '4':
-            print ("Goodbye.")
+            print("Goodbye.")
             break
 
 
diff --git a/ciphers/morse_code_implementation.py b/ciphers/morse_code_implementation.py
index 7b2d0a94b24b..5d0e7b2779b1 100644
--- a/ciphers/morse_code_implementation.py
+++ b/ciphers/morse_code_implementation.py
@@ -71,11 +71,11 @@ def decrypt(message):
 def main():
     message = "Morse code here"
     result = encrypt(message.upper())
-    print (result)
+    print(result)
 
     message = result
     result = decrypt(message)
-    print (result)
+    print(result)
 
 
 if __name__ == '__main__':
diff --git a/ciphers/trafid_cipher.py b/ciphers/trafid_cipher.py
index 0453272f26a0..53f4d288bfe2 100644
--- a/ciphers/trafid_cipher.py
+++ b/ciphers/trafid_cipher.py
@@ -3,7 +3,7 @@
 def __encryptPart(messagePart, character2Number):
     one, two, three = "", "", ""
     tmp = []
-    
+
     for character in messagePart:
         tmp.append(character2Number[character])
 
@@ -11,7 +11,7 @@ def __encryptPart(messagePart, character2Number):
         one += each[0]
         two += each[1]
         three += each[2]
-    
+
     return one+two+three
 
 def __decryptPart(messagePart, character2Number):
@@ -25,7 +25,7 @@ def __decryptPart(messagePart, character2Number):
         tmp += digit
         if len(tmp) == len(messagePart):
             result.append(tmp)
-            tmp = ""  
+            tmp = ""
 
     return result[0], result[1], result[2]
 
@@ -48,7 +48,7 @@ def __prepare(message, alphabet):
     for letter, number in zip(alphabet, numbers):
         character2Number[letter] = number
         number2Character[number] = letter
-    
+
     return message, alphabet, character2Number, number2Character
 
 def encryptMessage(message, alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ.", period=5):
@@ -57,7 +57,7 @@ def encryptMessage(message, alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ.", period=5):
 
     for i in range(0, len(message)+1, period):
         encrypted_numeric += __encryptPart(message[i:i+period], character2Number)
-    
+
     for i in range(0, len(encrypted_numeric), 3):
         encrypted += number2Character[encrypted_numeric[i:i+3]]
 
@@ -70,7 +70,7 @@ def decryptMessage(message, alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ.", period=5):
 
     for i in range(0, len(message)+1, period):
         a,b,c = __decryptPart(message[i:i+period], character2Number)
-    
+
         for j in range(0, len(a)):
             decrypted_numeric.append(a[j]+b[j]+c[j])
 
@@ -83,4 +83,4 @@ def decryptMessage(message, alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ.", period=5):
     msg = "DEFEND THE EAST WALL OF THE CASTLE."
     encrypted = encryptMessage(msg,"EPSDUCVWYM.ZLKXNBTFGORIJHAQ")
     decrypted = decryptMessage(encrypted, "EPSDUCVWYM.ZLKXNBTFGORIJHAQ")
-    print ("Encrypted: {}\nDecrypted: {}".format(encrypted, decrypted))
\ No newline at end of file
+    print("Encrypted: {}\nDecrypted: {}".format(encrypted, decrypted))
diff --git a/ciphers/xor_cipher.py b/ciphers/xor_cipher.py
index 727fac3b0703..8bb94212c15a 100644
--- a/ciphers/xor_cipher.py
+++ b/ciphers/xor_cipher.py
@@ -122,7 +122,7 @@ def decrypt_string(self,content,key = 0):
 
 		# This will be returned
 		ans = ""
-		
+
 		for ch in content:
 			ans += chr(ord(ch) ^ key)
 
@@ -188,22 +188,22 @@ def decrypt_file(self,file, key):
 # key = 67
 
 # # test enrcypt
-# print crypt.encrypt("hallo welt",key)
+# print(crypt.encrypt("hallo welt",key))
 # # test decrypt
-# print crypt.decrypt(crypt.encrypt("hallo welt",key), key)
+# print(crypt.decrypt(crypt.encrypt("hallo welt",key), key))
 
 # # test encrypt_string
-# print crypt.encrypt_string("hallo welt",key)
+# print(crypt.encrypt_string("hallo welt",key))
 
 # # test decrypt_string
-# print crypt.decrypt_string(crypt.encrypt_string("hallo welt",key),key)
+# print(crypt.decrypt_string(crypt.encrypt_string("hallo welt",key),key))
 
 # if (crypt.encrypt_file("test.txt",key)):
-# 	print "encrypt successful"
+# 	print("encrypt successful")
 # else:
-# 	print "encrypt unsuccessful"
+# 	print("encrypt unsuccessful")
 
 # if (crypt.decrypt_file("encrypt.out",key)):
-# 	print "decrypt successful"
+# 	print("decrypt successful")
 # else:
-# 	print "decrypt unsuccessful"
\ No newline at end of file
+# 	print("decrypt unsuccessful")
diff --git a/data_structures/binary_tree/fenwick_tree.py b/data_structures/binary_tree/fenwick_tree.py
index f429161c8c36..ef984082d9e8 100644
--- a/data_structures/binary_tree/fenwick_tree.py
+++ b/data_structures/binary_tree/fenwick_tree.py
@@ -16,14 +16,14 @@ def query(self, i): # query cumulative data from index 0 to i in O(lg N)
             ret += self.ft[i]
             i -= i & (-i)
         return ret
-            
+
 if __name__ == '__main__':
     f = FenwickTree(100)
     f.update(1,20)
     f.update(4,4)
-    print (f.query(1))
-    print (f.query(3))
-    print (f.query(4))
+    print(f.query(1))
+    print(f.query(3))
+    print(f.query(4))
     f.update(2,-5)
-    print (f.query(1))
-    print (f.query(3))
+    print(f.query(1))
+    print(f.query(3))
diff --git a/data_structures/binary_tree/lazy_segment_tree.py b/data_structures/binary_tree/lazy_segment_tree.py
index 9b14b24e81fa..215399976dd3 100644
--- a/data_structures/binary_tree/lazy_segment_tree.py
+++ b/data_structures/binary_tree/lazy_segment_tree.py
@@ -2,13 +2,13 @@
 import math
 
 class SegmentTree:
-    
+
     def __init__(self, N):
         self.N = N
         self.st = [0 for i in range(0,4*N)] # approximate the overall size of segment tree with array N
         self.lazy = [0 for i in range(0,4*N)] # create array to store lazy update
         self.flag = [0 for i in range(0,4*N)] # flag for lazy update
-        
+
     def left(self, idx):
         return idx*2
 
@@ -34,7 +34,7 @@ def update(self, idx, l, r, a, b, val): # update(1, 1, N, a, b, v) for update va
                 self.lazy[self.right(idx)] = self.lazy[idx]
                 self.flag[self.left(idx)] = True
                 self.flag[self.right(idx)] = True
-            
+
         if r < a or l > b:
             return True
         if l >= a and r <= b :
@@ -74,18 +74,18 @@ def showData(self):
         showList = []
         for i in range(1,N+1):
             showList += [self.query(1, 1, self.N, i, i)]
-        print (showList)
-            
+        print(showList)
+
 
 if __name__ == '__main__':
     A = [1,2,-4,7,3,-5,6,11,-20,9,14,15,5,2,-8]
     N = 15
     segt = SegmentTree(N)
     segt.build(1,1,N,A)
-    print (segt.query(1,1,N,4,6))
-    print (segt.query(1,1,N,7,11))
-    print (segt.query(1,1,N,7,12))
+    print(segt.query(1,1,N,4,6))
+    print(segt.query(1,1,N,7,11))
+    print(segt.query(1,1,N,7,12))
     segt.update(1,1,N,1,3,111)
-    print (segt.query(1,1,N,1,15))
+    print(segt.query(1,1,N,1,15))
     segt.update(1,1,N,7,8,235)
     segt.showData()
diff --git a/data_structures/binary_tree/segment_tree.py b/data_structures/binary_tree/segment_tree.py
index 001bf999f391..7e61198ca59c 100644
--- a/data_structures/binary_tree/segment_tree.py
+++ b/data_structures/binary_tree/segment_tree.py
@@ -2,12 +2,12 @@
 import math
 
 class SegmentTree:
-    
+
     def __init__(self, A):
         self.N = len(A)
         self.st = [0] * (4 * self.N) # approximate the overall size of segment tree with array N
         self.build(1, 0, self.N - 1)
-        
+
     def left(self, idx):
         return idx * 2
 
@@ -22,10 +22,10 @@ def build(self, idx, l, r):
             self.build(self.left(idx), l, mid)
             self.build(self.right(idx), mid + 1, r)
             self.st[idx] = max(self.st[self.left(idx)] , self.st[self.right(idx)])
-    
+
     def update(self, a, b, val):
         return self.update_recursive(1, 0, self.N - 1, a - 1, b - 1, val)
-    
+
     def update_recursive(self, idx, l, r, a, b, val): # update(1, 1, N, a, b, v) for update val v to [a,b]
         if r < a or l > b:
             return True
@@ -55,17 +55,17 @@ def showData(self):
         showList = []
         for i in range(1,N+1):
             showList += [self.query(i, i)]
-        print (showList)
-            
+        print(showList)
+
 
 if __name__ == '__main__':
     A = [1,2,-4,7,3,-5,6,11,-20,9,14,15,5,2,-8]
     N = 15
     segt = SegmentTree(A)
-    print (segt.query(4, 6))
-    print (segt.query(7, 11))
-    print (segt.query(7, 12))
+    print(segt.query(4, 6))
+    print(segt.query(7, 11))
+    print(segt.query(7, 12))
     segt.update(1,3,111)
-    print (segt.query(1, 15))
+    print(segt.query(1, 15))
     segt.update(7,8,235)
     segt.showData()
diff --git a/data_structures/queue/double_ended_queue.py b/data_structures/queue/double_ended_queue.py
index fdee64eb6ae0..838bf2f4bc36 100644
--- a/data_structures/queue/double_ended_queue.py
+++ b/data_structures/queue/double_ended_queue.py
@@ -1,40 +1,40 @@
 from __future__ import print_function
-# Python code to demonstrate working of 
+# Python code to demonstrate working of
 # extend(), extendleft(), rotate(), reverse()
- 
+
 # importing "collections" for deque operations
 import collections
- 
+
 # initializing deque
 de = collections.deque([1, 2, 3,])
- 
-# using extend() to add numbers to right end 
+
+# using extend() to add numbers to right end
 # adds 4,5,6 to right end
 de.extend([4,5,6])
- 
+
 # printing modified deque
-print ("The deque after extending deque at end is : ")
-print (de)
- 
-# using extendleft() to add numbers to left end 
+print("The deque after extending deque at end is : ")
+print(de)
+
+# using extendleft() to add numbers to left end
 # adds 7,8,9 to right end
 de.extendleft([7,8,9])
- 
+
 # printing modified deque
-print ("The deque after extending deque at beginning is : ")
-print (de)
- 
+print("The deque after extending deque at beginning is : ")
+print(de)
+
 # using rotate() to rotate the deque
 # rotates by 3 to left
 de.rotate(-3)
- 
+
 # printing modified deque
-print ("The deque after rotating deque is : ")
-print (de)
- 
+print("The deque after rotating deque is : ")
+print(de)
+
 # using reverse() to reverse the deque
 de.reverse()
- 
+
 # printing modified deque
-print ("The deque after reversing deque is : ")
-print (de)
+print("The deque after reversing deque is : ")
+print(de)
diff --git a/data_structures/stacks/stock_span_problem.py b/data_structures/stacks/stock_span_problem.py
index 9628864edd10..e9afebc193b6 100644
--- a/data_structures/stacks/stock_span_problem.py
+++ b/data_structures/stacks/stock_span_problem.py
@@ -1,52 +1,52 @@
 '''
-The stock span problem is a financial problem where we have a series of n daily 
+The stock span problem is a financial problem where we have a series of n daily
 price quotes for a stock and we need to calculate span of stock's price for all n days.
 
-The span Si of the stock's price on a given day i is defined as the maximum 
-number of consecutive days just before the given day, for which the price of the stock 
+The span Si of the stock's price on a given day i is defined as the maximum
+number of consecutive days just before the given day, for which the price of the stock
 on the current day is less than or equal to its price on the given day.
 '''
 from __future__ import print_function
-def calculateSpan(price, S): 
-      
-    n = len(price) 
-    # Create a stack and push index of fist element to it 
-    st = []  
-    st.append(0) 
-  
-    # Span value of first element is always 1 
-    S[0] = 1 
-  
-    # Calculate span values for rest of the elements 
-    for i in range(1, n): 
-          
-        # Pop elements from stack whlie stack is not 
-        # empty and top of stack is smaller than price[i] 
-        while( len(st) > 0 and price[st[0]] <= price[i]): 
-            st.pop() 
-  
-        # If stack becomes empty, then price[i] is greater 
-        # than all elements on left of it, i.e. price[0], 
-        # price[1], ..price[i-1]. Else the price[i]  is 
-        # greater than elements after top of stack 
-        S[i] = i+1 if len(st) <= 0 else (i - st[0]) 
-  
-        # Push this element to stack 
-        st.append(i) 
-  
-  
-# A utility function to print elements of array 
-def printArray(arr, n): 
-    for i in range(0,n): 
-        print (arr[i],end =" ") 
-  
-  
-# Driver program to test above function 
-price = [10, 4, 5, 90, 120, 80] 
-S = [0 for i in range(len(price)+1)] 
-  
-# Fill the span values in array S[] 
-calculateSpan(price, S) 
-  
-# Print the calculated span values 
-printArray(S, len(price)) 
+def calculateSpan(price, S):
+
+    n = len(price)
+    # Create a stack and push index of fist element to it
+    st = []
+    st.append(0)
+
+    # Span value of first element is always 1
+    S[0] = 1
+
+    # Calculate span values for rest of the elements
+    for i in range(1, n):
+
+        # Pop elements from stack whlie stack is not
+        # empty and top of stack is smaller than price[i]
+        while( len(st) > 0 and price[st[0]] <= price[i]):
+            st.pop()
+
+        # If stack becomes empty, then price[i] is greater
+        # than all elements on left of it, i.e. price[0],
+        # price[1], ..price[i-1]. Else the price[i]  is
+        # greater than elements after top of stack
+        S[i] = i+1 if len(st) <= 0 else (i - st[0])
+
+        # Push this element to stack
+        st.append(i)
+
+
+# A utility function to print elements of array
+def printArray(arr, n):
+    for i in range(0,n):
+        print(arr[i],end =" ")
+
+
+# Driver program to test above function
+price = [10, 4, 5, 90, 120, 80]
+S = [0 for i in range(len(price)+1)]
+
+# Fill the span values in array S[]
+calculateSpan(price, S)
+
+# Print the calculated span values
+printArray(S, len(price))
diff --git a/machine_learning/logistic_regression.py b/machine_learning/logistic_regression.py
index 9a60831862da..853de7896af1 100644
--- a/machine_learning/logistic_regression.py
+++ b/machine_learning/logistic_regression.py
@@ -9,7 +9,7 @@
 
 # importing all the required libraries
 
-''' Implementing logistic regression for classification problem 
+''' Implementing logistic regression for classification problem
      Helpful resources : 1.Coursera ML course    2.https://medium.com/@martinpella/logistic-regression-from-scratch-in-python-124c5636b8ac'''
 
 import numpy as np
@@ -63,10 +63,10 @@ def logistic_reg(
         if step % 10000 == 0:
             print(log_likelihood(X,y,weights))    # Print log-likelihood every so often
     return weights
-    
+
     if iterations == max_iterations:
-        print ('Maximum iterations exceeded!')
-        print ('Minimal cost function J=', J)
+        print('Maximum iterations exceeded!')
+        print('Minimal cost function J=', J)
         converged = True
     return theta
 
@@ -79,7 +79,7 @@ def logistic_reg(
 
     alpha = 0.1
     theta = logistic_reg(alpha,X,y,max_iterations=70000,num_steps=30000)
-    print (theta)
+    print(theta)
 
 
     def predict_prob(X):
diff --git a/maths/quadratic_equations_complex_numbers.py b/maths/quadratic_equations_complex_numbers.py
index f05b938fefe9..c3842fee5f96 100644
--- a/maths/quadratic_equations_complex_numbers.py
+++ b/maths/quadratic_equations_complex_numbers.py
@@ -12,7 +12,7 @@ def QuadraticEquation(a,b,c):
         if Delta >= 0:
             Solution1 = (-b + math.sqrt(Delta))/(2*a)
             Solution2 = (-b - math.sqrt(Delta))/(2*a)
-            print ("The equation solutions are: ", Solution1," and ", Solution2)
+            print("The equation solutions are: ", Solution1," and ", Solution2)
         else:
             """
             Treats cases of Complexes Solutions(i = imaginary unit)
@@ -25,7 +25,7 @@ def QuadraticEquation(a,b,c):
                 print("The equation solutions are: (",b,"+",math.sqrt(-Delta),"*i)/2  and  (",b,"+",math.sqrt(-Delta),"*i/",2*a)
             if b == 0:
                 print("The equation solutions are: (",math.sqrt(-Delta),"*i)/2  and  ",math.sqrt(-Delta),"*i)/", 2*a)
-    else: 
+    else:
         print("Error. Please, coeficient 'a' must not be zero for quadratic equations.")
 def main():
     a = 5
@@ -33,7 +33,7 @@ def main():
     c = 1
 
     QuadraticEquation(a,b,c) # The equation solutions are:  -0.2  and  -1.0
-    
-    
+
+
 if __name__ == '__main__':
     main()
diff --git a/other/fischer_yates_shuffle.py b/other/fischer_yates_shuffle.py
index d87792f45558..bc2b136344c7 100644
--- a/other/fischer_yates_shuffle.py
+++ b/other/fischer_yates_shuffle.py
@@ -17,6 +17,6 @@ def FYshuffle(LIST):
 if __name__ == '__main__':
     integers = [0,1,2,3,4,5,6,7]
     strings = ['python', 'says', 'hello', '!']
-    print ('Fisher-Yates Shuffle:')
-    print ('List',integers, strings)
-    print ('FY Shuffle',FYshuffle(integers), FYshuffle(strings))
+    print('Fisher-Yates Shuffle:')
+    print('List',integers, strings)
+    print('FY Shuffle',FYshuffle(integers), FYshuffle(strings))

From d21b4cfb4839833b2302da72a646f5a4ecd1bf3b Mon Sep 17 00:00:00 2001
From: QuantumNovice <43876848+QuantumNovice@users.noreply.github.com>
Date: Tue, 6 Aug 2019 16:16:30 +0500
Subject: [PATCH 166/348] Added pytests to hashes/md5.py (#1100)

* Added pytests to sha1.py

* tweaking md5

* Added Pytests to hashes/md5.py
---
 hashes/md5.py | 287 +++++++++++++++++++++++++++-----------------------
 1 file changed, 154 insertions(+), 133 deletions(-)

diff --git a/hashes/md5.py b/hashes/md5.py
index d3f15510874e..7891f2077986 100644
--- a/hashes/md5.py
+++ b/hashes/md5.py
@@ -1,155 +1,176 @@
 from __future__ import print_function
 import math
 
+
 def rearrange(bitString32):
-	"""[summary]
-	Regroups the given binary string.
-	
-	Arguments:
-		bitString32 {[string]} -- [32 bit binary]
-	
-	Raises:
-		ValueError -- [if the given string not are 32 bit binary string]
-	
-	Returns:
-		[string] -- [32 bit binary string]
-	"""
-
-	if len(bitString32) != 32:
-		raise ValueError("Need length 32")
-	newString = ""
-	for i in [3,2,1,0]:
-		newString += bitString32[8*i:8*i+8]
-	return newString
+    """[summary]
+    Regroups the given binary string.
+
+    Arguments:
+        bitString32 {[string]} -- [32 bit binary]
+
+    Raises:
+    ValueError -- [if the given string not are 32 bit binary string]
+
+    Returns:
+        [string] -- [32 bit binary string]
+    >>> rearrange('1234567890abcdfghijklmnopqrstuvw')
+    'pqrstuvwhijklmno90abcdfg12345678'
+    """
+
+    if len(bitString32) != 32:
+        raise ValueError("Need length 32")
+    newString = ""
+    for i in [3, 2,1,0]:
+        newString += bitString32[8*i:8*i+8]
+    return newString
+
 
 def reformatHex(i):
-	"""[summary]
-	Converts the given integer into 8-digit hex number.
+    """[summary]
+    Converts the given integer into 8-digit hex number.
 
-	Arguments:
-		i {[int]} -- [integer]
-	"""
+    Arguments:
+            i {[int]} -- [integer]
+    >>> reformatHex(666)
+    '9a020000'
+    """
+
+    hexrep = format(i, '08x')
+    thing = ""
+    for i in [3, 2,1,0]:
+        thing += hexrep[2*i:2*i+2]
+    return thing
 
-	hexrep = format(i,'08x')
-	thing = ""
-	for i in [3,2,1,0]:
-		thing += hexrep[2*i:2*i+2]
-	return thing
 
 def pad(bitString):
-	"""[summary]
-	Fills up the binary string to a 512 bit binary string
-
-	Arguments:
-		bitString {[string]} -- [binary string]
-	
-	Returns:
-		[string] -- [binary string]
-	"""
-
-	startLength = len(bitString)
-	bitString += '1'
-	while len(bitString) % 512 != 448:
-		bitString += '0'
-	lastPart = format(startLength,'064b')
-	bitString += rearrange(lastPart[32:]) + rearrange(lastPart[:32]) 
-	return bitString
+    """[summary]
+    Fills up the binary string to a 512 bit binary string
+
+    Arguments:
+            bitString {[string]} -- [binary string]
+
+    Returns:
+            [string] -- [binary string]
+    """
+    startLength = len(bitString)
+    bitString += '1'
+    while len(bitString) % 512 != 448:
+        bitString += '0'
+    lastPart = format(startLength, '064b')
+    bitString += rearrange(lastPart[32:]) + rearrange(lastPart[:32])
+    return bitString
+
 
 def getBlock(bitString):
-	"""[summary]
-	Iterator:
-		Returns by each call a list of length 16 with the 32 bit
-		integer blocks. 
-
-	Arguments:
-		bitString {[string]} -- [binary string >= 512]
-	"""
-
-	currPos = 0
-	while currPos < len(bitString):
-		currPart = bitString[currPos:currPos+512]
-		mySplits = []
-		for i in range(16):
-			mySplits.append(int(rearrange(currPart[32*i:32*i+32]),2))
-		yield mySplits
-		currPos += 512
+    """[summary]
+    Iterator:
+            Returns by each call a list of length 16 with the 32 bit
+            integer blocks. 
 
-def not32(i):
-	i_str = format(i,'032b')
-	new_str = ''
-	for c in i_str:
-		new_str += '1' if c=='0' else '0'
-	return int(new_str,2)
+    Arguments:
+            bitString {[string]} -- [binary string >= 512]
+    """
 
-def sum32(a,b):
-	return (a + b) % 2**32
+    currPos = 0
+    while currPos < len(bitString):
+        currPart = bitString[currPos:currPos+512]
+        mySplits = []
+        for i in range(16):
+            mySplits.append(int(rearrange(currPart[32*i:32*i+32]), 2))
+        yield mySplits
+        currPos += 512
+
+
+def not32(i):
+    '''
+    >>> not32(34)
+    4294967261
+    '''
+    i_str = format(i, '032b')
+    new_str = ''
+    for c in i_str:
+        new_str += '1' if c == '0' else '0'
+    return int(new_str, 2)
+
+def sum32(a, b):
+    '''
+    
+    '''
+    return (a + b) % 2**32
+
+def leftrot32(i, s):
+    return (i << s) ^ (i >> (32-s))
 
-def leftrot32(i,s):
-	return (i << s) ^ (i >> (32-s))
 
 def md5me(testString):
-	"""[summary]
-	Returns a 32-bit hash code of the string 'testString'
-
-	Arguments:
-		testString {[string]} -- [message]
-	"""
-
-	bs =''
-	for i in testString:
-		bs += format(ord(i),'08b')
-	bs = pad(bs)
-
-	tvals = [int(2**32 * abs(math.sin(i+1))) for i in range(64)]
-
-	a0 = 0x67452301
-	b0 = 0xefcdab89
-	c0 = 0x98badcfe
-	d0 = 0x10325476
-
-	s = [7, 12, 17, 22,  7, 12, 17, 22,  7, 12, 17, 22,  7, 12, 17, 22, \
-		5,  9, 14, 20,  5,  9, 14, 20,  5,  9, 14, 20,  5,  9, 14, 20, \
-		4, 11, 16, 23,  4, 11, 16, 23,  4, 11, 16, 23,  4, 11, 16, 23, \
-		6, 10, 15, 21,  6, 10, 15, 21,  6, 10, 15, 21,  6, 10, 15, 21 ]
-
-	for m in getBlock(bs):
-		A = a0 
-		B = b0
-		C = c0
-		D = d0
-		for i in range(64):
-			if i <= 15:
-				#f = (B & C) | (not32(B) & D)
-				f = D ^ (B & (C ^ D))
-				g = i
-			elif i<= 31:
-				#f = (D & B) | (not32(D) & C)
-				f = C ^ (D & (B ^ C))
-				g = (5*i+1) % 16
-			elif i <= 47:
-				f = B ^ C ^ D
-				g = (3*i+5) % 16
-			else:
-				f = C ^ (B | not32(D))
-				g = (7*i) % 16
-			dtemp = D
-			D = C
-			C = B
-			B = sum32(B,leftrot32((A + f + tvals[i] + m[g]) % 2**32, s[i]))
-			A = dtemp
-		a0 = sum32(a0, A)
-		b0 = sum32(b0, B)
-		c0 = sum32(c0, C)
-		d0 = sum32(d0, D)
-
-	digest = reformatHex(a0) + reformatHex(b0) + reformatHex(c0) + reformatHex(d0)
-	return digest
+    """[summary]
+    Returns a 32-bit hash code of the string 'testString'
+
+    Arguments:
+            testString {[string]} -- [message]
+    """
+
+    bs = ''
+    for i in testString:
+        bs += format(ord(i), '08b')
+    bs = pad(bs)
+
+    tvals = [int(2**32 * abs(math.sin(i+1))) for i in range(64)]
+
+    a0 = 0x67452301
+    b0 = 0xefcdab89
+    c0 = 0x98badcfe
+    d0 = 0x10325476
+
+    s = [7, 12, 17, 22,  7, 12, 17, 22,  7, 12, 17, 22,  7, 12, 17, 22,
+         5,  9, 14, 20,  5,  9, 14, 20,  5,  9, 14, 20,  5,  9, 14, 20, \
+         4, 11, 16, 23,  4, 11, 16, 23,  4, 11, 16, 23,  4, 11, 16, 23, \
+         6, 10, 15, 21,  6, 10, 15, 21,  6, 10, 15, 21,  6, 10, 15, 21 ]
+
+    for m in getBlock(bs):
+        A = a0
+        B = b0
+        C = c0
+        D = d0
+        for i in range(64):
+            if i <= 15:
+                #f = (B & C) | (not32(B) & D)
+                f = D ^ (B & (C ^ D))
+                g = i
+            elif i <= 31:
+                #f = (D & B) | (not32(D) & C)
+                f = C ^ (D & (B ^ C))
+                g = (5*i+1) % 16
+            elif i <= 47:
+                f = B ^ C ^ D
+                g = (3*i+5) % 16
+            else:
+                f = C ^ (B | not32(D))
+                g = (7*i) % 16
+            dtemp = D
+            D = C
+            C = B
+            B = sum32(B, leftrot32((A + f + tvals[i] + m[g]) % 2**32, s[i]))
+            A = dtemp
+        a0 = sum32(a0, A)
+        b0 = sum32(b0, B)
+        c0 = sum32(c0, C)
+        d0 = sum32(d0, D)
+
+    digest = reformatHex(a0) + reformatHex(b0) + \
+                         reformatHex(c0) + reformatHex(d0)
+    return digest
+
 
 def test():
-	assert md5me("") == "d41d8cd98f00b204e9800998ecf8427e"	
-	assert md5me("The quick brown fox jumps over the lazy dog") == "9e107d9d372bb6826bd81d3542a419d6"
-	print("Success.")
+    assert md5me("") == "d41d8cd98f00b204e9800998ecf8427e"
+    assert md5me(
+        "The quick brown fox jumps over the lazy dog") == "9e107d9d372bb6826bd81d3542a419d6"
+    print("Success.")
 
 
 if __name__ == "__main__":
-	test()
+    test()
+    import doctest
+    doctest.testmod()

From 762482dc40bdd067e2ab01d94fd2c35857e7de9b Mon Sep 17 00:00:00 2001
From: Harshil <darjiharshil2994@gmail.com>
Date: Tue, 6 Aug 2019 21:31:03 +0200
Subject: [PATCH 167/348] Update closest_pair_of_points.py (#1109)

---
 divide_and_conquer/closest_pair_of_points.py | 107 ++++++++++---------
 1 file changed, 57 insertions(+), 50 deletions(-)

diff --git a/divide_and_conquer/closest_pair_of_points.py b/divide_and_conquer/closest_pair_of_points.py
index b6f63396410c..11dac7e0ab2a 100644
--- a/divide_and_conquer/closest_pair_of_points.py
+++ b/divide_and_conquer/closest_pair_of_points.py
@@ -1,55 +1,54 @@
 """
-The algorithm finds distance between closest pair of points 
+The algorithm finds distance between closest pair of points
 in the given n points.
-Approach used -> Divide and conquer 
-The points are sorted based on Xco-ords and 
+Approach used -> Divide and conquer
+The points are sorted based on Xco-ords and
 then based on Yco-ords separately.
-And by applying divide and conquer approach, 
+And by applying divide and conquer approach,
 minimum distance is obtained recursively.
 
 >> Closest points can lie on different sides of partition.
-This case handled by forming a strip of points 
+This case handled by forming a strip of points
 whose Xco-ords distance is less than closest_pair_dis
-from mid-point's Xco-ords. Points sorted based on Yco-ords 
+from mid-point's Xco-ords. Points sorted based on Yco-ords
 are used in this step to reduce sorting time.
 Closest pair distance is found in the strip of points. (closest_in_strip)
 
 min(closest_pair_dis, closest_in_strip) would be the final answer.
- 
-Time complexity: O(n * log n)
-"""
 
-"""
-	doctests
-	>>> euclidean_distance_sqr([1,2],[2,4])
-	5
-	>>> dis_between_closest_pair([[1,2],[2,4],[5,7],[8,9],[11,0]],5)
-	5
-	>>> dis_between_closest_in_strip([[1,2],[2,4],[5,7],[8,9],[11,0]],5)
- 85
-	>>> points = [(2, 3), (12, 30), (40, 50), (5, 1), (12, 10), (3, 4)] 
- >>> print("Distance:", closest_pair_of_points(points, len(points)))
-	"Distance: 1.4142135623730951"
+Time complexity: O(n * log n)
 """
 
 
 def euclidean_distance_sqr(point1, point2):
+    """
+    >>> euclidean_distance_sqr([1,2],[2,4])
+    5
+    """
     return (point1[0] - point2[0]) ** 2 + (point1[1] - point2[1]) ** 2
 
 
 def column_based_sort(array, column = 0):
+    """
+    >>> column_based_sort([(5, 1), (4, 2), (3, 0)], 1)
+    [(3, 0), (5, 1), (4, 2)]
+    """
     return sorted(array, key = lambda x: x[column])
-    
+
 
 def dis_between_closest_pair(points, points_counts, min_dis = float("inf")):
-    """ brute force approach to find distance between closest pair points
+    """
+    brute force approach to find distance between closest pair points
+
+    Parameters :
+    points, points_count, min_dis (list(tuple(int, int)), int, int)
 
-    Parameters : 
-    points, points_count, min_dis (list(tuple(int, int)), int, int) 
-    
-    Returns : 
+    Returns :
     min_dis (float):  distance between closest pair of points
 
+    >>> dis_between_closest_pair([[1,2],[2,4],[5,7],[8,9],[11,0]],5)
+    5
+
     """
 
     for i in range(points_counts - 1):
@@ -61,14 +60,17 @@ def dis_between_closest_pair(points, points_counts, min_dis = float("inf")):
 
 
 def dis_between_closest_in_strip(points, points_counts, min_dis = float("inf")):
-    """ closest pair of points in strip
+    """
+    closest pair of points in strip
+
+    Parameters :
+    points, points_count, min_dis (list(tuple(int, int)), int, int)
 
-    Parameters : 
-    points, points_count, min_dis (list(tuple(int, int)), int, int) 
-    
-    Returns : 
+    Returns :
     min_dis (float):  distance btw closest pair of points in the strip (< min_dis)
 
+    >>> dis_between_closest_in_strip([[1,2],[2,4],[5,7],[8,9],[11,0]],5)
+    85
     """
 
     for i in range(min(6, points_counts - 1), points_counts):
@@ -82,29 +84,32 @@ def dis_between_closest_in_strip(points, points_counts, min_dis = float("inf")):
 def closest_pair_of_points_sqr(points_sorted_on_x, points_sorted_on_y, points_counts):
     """ divide and conquer approach
 
-    Parameters : 
-    points, points_count (list(tuple(int, int)), int) 
-    
-    Returns : 
-    (float):  distance btw closest pair of points 
+    Parameters :
+    points, points_count (list(tuple(int, int)), int)
+
+    Returns :
+    (float):  distance btw closest pair of points
 
+    >>> closest_pair_of_points_sqr([(1, 2), (3, 4)], [(5, 6), (7, 8)], 2)
+    8
     """
 
     # base case
     if points_counts <= 3:
         return dis_between_closest_pair(points_sorted_on_x, points_counts)
-    
+
     # recursion
     mid = points_counts//2
-    closest_in_left = closest_pair_of_points_sqr(points_sorted_on_x, 
-                                                 points_sorted_on_y[:mid], 
+    closest_in_left = closest_pair_of_points_sqr(points_sorted_on_x,
+                                                 points_sorted_on_y[:mid],
                                                  mid)
-    closest_in_right = closest_pair_of_points_sqr(points_sorted_on_y, 
-                                                  points_sorted_on_y[mid:], 
+    closest_in_right = closest_pair_of_points_sqr(points_sorted_on_y,
+                                                  points_sorted_on_y[mid:],
                                                   points_counts - mid)
     closest_pair_dis = min(closest_in_left, closest_in_right)
-    
-    """ cross_strip contains the points, whose Xcoords are at a 
+
+    """
+    cross_strip contains the points, whose Xcoords are at a
     distance(< closest_pair_dis) from mid's Xcoord
     """
 
@@ -113,21 +118,23 @@ def closest_pair_of_points_sqr(points_sorted_on_x, points_sorted_on_y, points_co
         if abs(point[0] - points_sorted_on_x[mid][0]) < closest_pair_dis:
             cross_strip.append(point)
 
-    closest_in_strip = dis_between_closest_in_strip(cross_strip, 
+    closest_in_strip = dis_between_closest_in_strip(cross_strip,
                      len(cross_strip), closest_pair_dis)
     return min(closest_pair_dis, closest_in_strip)
 
-    
+
 def closest_pair_of_points(points, points_counts):
+    """
+    >>> closest_pair_of_points([(2, 3), (12, 30)], len([(2, 3), (12, 30)]))
+    28.792360097775937
+    """
     points_sorted_on_x = column_based_sort(points, column = 0)
     points_sorted_on_y = column_based_sort(points, column = 1)
-    return (closest_pair_of_points_sqr(points_sorted_on_x, 
-                                       points_sorted_on_y, 
+    return (closest_pair_of_points_sqr(points_sorted_on_x,
+                                       points_sorted_on_y,
                                        points_counts)) ** 0.5
 
 
 if __name__ == "__main__":
-    points = [(2, 3), (12, 30), (40, 50), (5, 1), (12, 10), (3, 4)] 
+    points = [(2, 3), (12, 30), (40, 50), (5, 1), (12, 10), (3, 4)]
     print("Distance:", closest_pair_of_points(points, len(points)))
-
-

From 7b5a18453b0abe64350930d675cdfe9bef19c57a Mon Sep 17 00:00:00 2001
From: Christian Clauss <cclauss@me.com>
Date: Tue, 6 Aug 2019 21:31:45 +0200
Subject: [PATCH 168/348] print() is a function just like every other function
 (#1104)


From 7cf3db184320a454e545882408b8c2f561ef0cdb Mon Sep 17 00:00:00 2001
From: Christian Clauss <cclauss@me.com>
Date: Tue, 6 Aug 2019 21:32:27 +0200
Subject: [PATCH 169/348] Add test for QuadraticEquation() (#1107)

---
 maths/quadratic_equations_complex_numbers.py | 64 ++++++++++----------
 1 file changed, 32 insertions(+), 32 deletions(-)

diff --git a/maths/quadratic_equations_complex_numbers.py b/maths/quadratic_equations_complex_numbers.py
index c3842fee5f96..8f97508609bf 100644
--- a/maths/quadratic_equations_complex_numbers.py
+++ b/maths/quadratic_equations_complex_numbers.py
@@ -1,39 +1,39 @@
-import math
+from math import sqrt
+from typing import Tuple
 
-def QuadraticEquation(a,b,c):
+
+def QuadraticEquation(a: int, b: int, c: int) -> Tuple[str, str]:
+    """
+    Given the numerical coefficients a, b and c,
+    prints the solutions for a quadratic equation, for a*x*x + b*x + c.
+
+    >>> QuadraticEquation(a=1, b=3, c=-4)
+    ('1.0', '-4.0')
+    >>> QuadraticEquation(5, 6, 1)
+    ('-0.2', '-1.0')
     """
-    Prints the solutions for a quadratic equation, given the numerical coefficients a, b and c,
-    for a*x*x + b*x + c.
-    Ex.: a = 1, b = 3, c = -4
-    Solution1 = 1 and Solution2 = -4
+    if a == 0:
+        raise ValueError("Coefficient 'a' must not be zero for quadratic equations.")
+    delta = b * b - 4 * a * c
+    if delta >= 0:
+        return str((-b + sqrt(delta)) / (2 * a)), str((-b - sqrt(delta)) / (2 * a))
     """
-    Delta = b*b - 4*a*c
-    if a != 0:
-        if Delta >= 0:
-            Solution1 = (-b + math.sqrt(Delta))/(2*a)
-            Solution2 = (-b - math.sqrt(Delta))/(2*a)
-            print("The equation solutions are: ", Solution1," and ", Solution2)
-        else:
-            """
-            Treats cases of Complexes Solutions(i = imaginary unit)
-            Ex.: a = 5, b = 2, c = 1
-            Solution1 = (- 2 + 4.0 *i)/2 and Solution2 = (- 2 + 4.0 *i)/ 10
-            """
-            if b > 0:
-                print("The equation solutions are: (-",b,"+",math.sqrt(-Delta),"*i)/2  and  (-",b,"+",math.sqrt(-Delta),"*i)/", 2*a)
-            if b < 0:
-                print("The equation solutions are: (",b,"+",math.sqrt(-Delta),"*i)/2  and  (",b,"+",math.sqrt(-Delta),"*i/",2*a)
-            if b == 0:
-                print("The equation solutions are: (",math.sqrt(-Delta),"*i)/2  and  ",math.sqrt(-Delta),"*i)/", 2*a)
-    else:
-        print("Error. Please, coeficient 'a' must not be zero for quadratic equations.")
-def main():
-    a = 5
-    b = 6
-    c = 1
+    Treats cases of Complexes Solutions(i = imaginary unit)
+    Ex.: a = 5, b = 2, c = 1
+    Solution1 = (- 2 + 4.0 *i)/2 and Solution2 = (- 2 + 4.0 *i)/ 10
+    """
+    snd = sqrt(-delta)
+    if b == 0:
+        return f"({snd} * i) / 2", f"({snd} * i) / {2 * a}"
+    b = -abs(b)
+    return f"({b}+{snd} * i) / 2", f"({b}+{snd} * i) / {2 * a}"
+
 
-    QuadraticEquation(a,b,c) # The equation solutions are:  -0.2  and  -1.0
+def main():
+    solutions = QuadraticEquation(a=5, b=6, c=1)
+    print("The equation solutions are: {} and {}".format(*solutions))
+    # The equation solutions are: -0.2 and -1.0
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()

From 561a41464f6dca6c15656ac2257370410b1e9efa Mon Sep 17 00:00:00 2001
From: Christian Clauss <cclauss@me.com>
Date: Tue, 6 Aug 2019 21:53:12 +0200
Subject: [PATCH 170/348] Travis CI: Run each failing pytest in allow_failures
 mode (#1087)

* Travis CI: Run failing pytest in allow_failures mode

* Sync with master

* Sync with master
---
 .travis.yml | 28 +++++++++++++++++++++++++++-
 1 file changed, 27 insertions(+), 1 deletion(-)

diff --git a/.travis.yml b/.travis.yml
index eab55af63492..9abbb0365bc6 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -4,11 +4,37 @@ python: 3.7
 cache: pip
 before_install: pip install --upgrade pip setuptools
 install: pip install -r requirements.txt
+matrix:
+  include:
+    - name: "Main tests"
+    # The following files currently fail pytests.  See issues: #1016, #1044, #1080
+    # Here they are run allow_failures mode and when each passes pytest, it can be
+    # removed BOTH lists below.  Complex now but simple once all files pass pytest.
+    # - env: FILE=pytest file_transfer_protocol/ftp_client_server.py
+    #   before_script: true
+    #   script: pytest ${FILE} --doctest-modules
+    - env: FILE=pytest file_transfer_protocol/ftp_send_receive.py
+      before_script: true
+      script: pytest ${FILE} --doctest-modules
+    - env: FILE=pytest machine_learning/linear_regression.py
+      before_script: true
+      script: pytest ${FILE} --doctest-modules
+    - env: FILE=pytest machine_learning/perceptron.py
+      before_script: true
+      script: pytest ${FILE} --doctest-modules
+    - env: FILE=pytest machine_learning/random_forest_classification/random_forest_classification.py
+      before_script: true
+      script: pytest ${FILE} --doctest-modules
+    - env: FILE=pytest machine_learning/random_forest_regression/random_forest_regression.py
+      before_script: true
+      script: pytest ${FILE} --doctest-modules
+  allow_failures:
+    - before_script: true
 before_script:
   - black --check . || true
   - flake8 . --count --select=E9,F401,F63,F7,F82 --show-source --statistics
 script:
-  - scripts/validate_filenames.py  # no uppercase and no spaces
+  - scripts/validate_filenames.py  # no uppercase, no spaces, in a directory
   - mypy --ignore-missing-imports .
   - pytest . --doctest-modules
       --ignore=file_transfer_protocol/ftp_send_receive.py

From 9456e81437bbab7b1781750fed07121c6cd6e301 Mon Sep 17 00:00:00 2001
From: AlexDvorak <opti.jawsome@gmail.com>
Date: Wed, 7 Aug 2019 09:44:48 -0400
Subject: [PATCH 171/348] Seperate client and server of FTP (#1106)

* added sample file to transfer

* split client and server into separate files

* client and server now work in python2

* server works on python3

* client works on python3

* allow configurable ONE_CONNECTION_ONLY for testing server

* allow testing of ftp server + client

* use f-strings

* removed single letter vars

* fixed bad quote marks

* clearer file handler names

* 'with open() as' syntax

* unicode and emojis in the test data

* s -> sock

* consistent comment spacing

* remove closing formalities

* swap in and out_file

* f-string

* if __name__ == '__main__':
---
 .travis.yml                                 |  1 -
 file_transfer_protocol/client.py            | 23 +++++++++
 file_transfer_protocol/ftp_client_server.py | 57 ---------------------
 file_transfer_protocol/mytext.txt           |  6 +++
 file_transfer_protocol/server.py            | 34 ++++++++++++
 5 files changed, 63 insertions(+), 58 deletions(-)
 create mode 100644 file_transfer_protocol/client.py
 delete mode 100644 file_transfer_protocol/ftp_client_server.py
 create mode 100644 file_transfer_protocol/mytext.txt
 create mode 100644 file_transfer_protocol/server.py

diff --git a/.travis.yml b/.travis.yml
index 9abbb0365bc6..2536e72fadff 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -38,7 +38,6 @@ script:
   - mypy --ignore-missing-imports .
   - pytest . --doctest-modules
       --ignore=file_transfer_protocol/ftp_send_receive.py
-      --ignore=file_transfer_protocol/ftp_client_server.py
       --ignore=machine_learning/linear_regression.py
       --ignore=machine_learning/perceptron.py
       --ignore=machine_learning/random_forest_classification/random_forest_classification.py
diff --git a/file_transfer_protocol/client.py b/file_transfer_protocol/client.py
new file mode 100644
index 000000000000..f404546d7765
--- /dev/null
+++ b/file_transfer_protocol/client.py
@@ -0,0 +1,23 @@
+if __name__ == '__main__':
+    import socket  # Import socket module
+
+    sock = socket.socket()  # Create a socket object
+    host = socket.gethostname()  # Get local machine name
+    port = 12312
+
+    sock.connect((host, port))
+    sock.send(b'Hello server!')
+
+    with open('Received_file', 'wb') as out_file:
+        print('File opened')
+        print('Receiving data...')
+        while True:
+            data = sock.recv(1024)
+            print(f"data={data}")
+            if not data:
+                break
+            out_file.write(data)  # Write data to a file
+
+    print('Successfully got the file')
+    sock.close()
+    print('Connection closed')
diff --git a/file_transfer_protocol/ftp_client_server.py b/file_transfer_protocol/ftp_client_server.py
deleted file mode 100644
index 414c336dee9f..000000000000
--- a/file_transfer_protocol/ftp_client_server.py
+++ /dev/null
@@ -1,57 +0,0 @@
-# server
-
-import socket                   # Import socket module
-
-port = 60000                    # Reserve a port for your service.
-s = socket.socket()             # Create a socket object
-host = socket.gethostname()     # Get local machine name
-s.bind((host, port))            # Bind to the port
-s.listen(5)                     # Now wait for client connection.
-
-print('Server listening....')
-
-while True:
-    conn, addr = s.accept()     # Establish connection with client.
-    print('Got connection from', addr)
-    data = conn.recv(1024)
-    print('Server received', repr(data))
-
-    filename = 'mytext.txt'
-    with open(filename, 'rb') as f:
-        in_data = f.read(1024)
-        while in_data:
-            conn.send(in_data)
-            print('Sent ', repr(in_data))
-            in_data = f.read(1024)
-
-    print('Done sending')
-    conn.send('Thank you for connecting')
-    conn.close()
-
-
-# client side server
-
-import socket                   # Import socket module
-
-s = socket.socket()             # Create a socket object
-host = socket.gethostname()     # Get local machine name
-port = 60000                    # Reserve a port for your service.
-
-s.connect((host, port))
-s.send("Hello server!")
-
-with open('received_file', 'wb') as f:
-    print('file opened')
-    while True:
-        print('receiving data...')
-        data = s.recv(1024)
-        print('data=%s', (data))
-        if not data:
-            break
-        # write data to a file
-        f.write(data)
-
-f.close()
-print('Successfully get the file')
-s.close()
-print('connection closed')
diff --git a/file_transfer_protocol/mytext.txt b/file_transfer_protocol/mytext.txt
new file mode 100644
index 000000000000..54cfa7f766c7
--- /dev/null
+++ b/file_transfer_protocol/mytext.txt
@@ -0,0 +1,6 @@
+Hello
+This is sample data
+«küßî»
+“ЌύБЇ”
+😀😉
+😋
diff --git a/file_transfer_protocol/server.py b/file_transfer_protocol/server.py
new file mode 100644
index 000000000000..92fab206c1a1
--- /dev/null
+++ b/file_transfer_protocol/server.py
@@ -0,0 +1,34 @@
+if __name__ == '__main__':
+    import socket  # Import socket module
+
+    ONE_CONNECTION_ONLY = True  # Set this to False if you wish to continuously accept connections
+
+    filename='mytext.txt'
+    port = 12312  # Reserve a port for your service.
+    sock = socket.socket()  # Create a socket object
+    host = socket.gethostname()  # Get local machine name
+    sock.bind((host, port))  # Bind to the port
+    sock.listen(5)  # Now wait for client connection.
+
+    print('Server listening....')
+
+    while True:
+        conn, addr = sock.accept()  # Establish connection with client.
+        print(f"Got connection from {addr}")
+        data = conn.recv(1024)
+        print(f"Server received {data}")
+
+        with open(filename,'rb') as in_file:
+            data = in_file.read(1024)
+            while (data):
+               conn.send(data)
+               print(f"Sent {data!r}")
+               data = in_file.read(1024)
+
+        print('Done sending')
+        conn.close()
+        if ONE_CONNECTION_ONLY:  # This is to make sure that the program doesn't hang while testing
+            break
+
+    sock.shutdown(1)
+    sock.close()

From c92d06bf1f82f21ecb74650b63fd72f07b0a1a70 Mon Sep 17 00:00:00 2001
From: John Law <johnlaw.po@gmail.com>
Date: Thu, 8 Aug 2019 01:35:36 +0800
Subject: [PATCH 172/348] Delete redundant files (#1115)

* Delete 16L'

* Delete Q'
---
 16L' | 0
 Q'   | 0
 2 files changed, 0 insertions(+), 0 deletions(-)
 delete mode 100644 16L'
 delete mode 100644 Q'

diff --git a/16L' b/16L'
deleted file mode 100644
index e69de29bb2d1..000000000000
diff --git a/Q' b/Q'
deleted file mode 100644
index e69de29bb2d1..000000000000

From 32c0418f635824a14665c58c71bc7c220c509a78 Mon Sep 17 00:00:00 2001
From: Amrit Khera <31596604+AmritK10@users.noreply.github.com>
Date: Thu, 8 Aug 2019 01:09:44 +0530
Subject: [PATCH 173/348] Infinite loop was fixed. (#1105)

* Infinite loop was fixed.
Removed issue of unused variables.

* Update logistic_regression.py

* Update logistic_regression.py

* correct spacing according to PEP8
---
 machine_learning/logistic_regression.py | 27 +++++++------------------
 1 file changed, 7 insertions(+), 20 deletions(-)

diff --git a/machine_learning/logistic_regression.py b/machine_learning/logistic_regression.py
index 853de7896af1..b2749f1be260 100644
--- a/machine_learning/logistic_regression.py
+++ b/machine_learning/logistic_regression.py
@@ -40,34 +40,20 @@ def logistic_reg(
     alpha,
     X,
     y,
-    num_steps,
     max_iterations=70000,
     ):
-    converged = False
-    iterations = 0
     theta = np.zeros(X.shape[1])
 
-    while not converged:
+    for iterations in range(max_iterations):
         z = np.dot(X, theta)
         h = sigmoid_function(z)
         gradient = np.dot(X.T, h - y) / y.size
-        theta = theta - alpha * gradient
+        theta = theta - alpha * gradient  # updating the weights
         z = np.dot(X, theta)
         h = sigmoid_function(z)
         J = cost_function(h, y)
-        iterations += 1  # update iterations
-        weights = np.zeros(X.shape[1])
-    for step in range(num_steps):
-        scores = np.dot(X, weights)
-        predictions = sigmoid_function(scores)
-        if step % 10000 == 0:
-            print(log_likelihood(X,y,weights))    # Print log-likelihood every so often
-    return weights
-
-    if iterations == max_iterations:
-        print('Maximum iterations exceeded!')
-        print('Minimal cost function J=', J)
-        converged = True
+        if iterations % 100 == 0:
+            print(f'loss: {J} \t')  # printing the loss after every 100 iterations
     return theta
 
 # In[68]:
@@ -78,8 +64,8 @@ def logistic_reg(
     y = (iris.target != 0) * 1
 
     alpha = 0.1
-    theta = logistic_reg(alpha,X,y,max_iterations=70000,num_steps=30000)
-    print(theta)
+    theta = logistic_reg(alpha,X,y,max_iterations=70000)
+    print("theta: ",theta)  # printing the theta i.e our weights vector
 
 
     def predict_prob(X):
@@ -105,3 +91,4 @@ def predict_prob(X):
         )
 
     plt.legend()
+    plt.show()

From 3ba67c7d2d72b166d7fd0a8a549de46951002f4f Mon Sep 17 00:00:00 2001
From: AlexDvorak <opti.jawsome@gmail.com>
Date: Wed, 7 Aug 2019 16:02:31 -0400
Subject: [PATCH 174/348] rename non-ftp files (#1116)

---
 file_transfer_protocol/{client.py => recieve_file.py} | 0
 file_transfer_protocol/{server.py => send_file.py}    | 0
 2 files changed, 0 insertions(+), 0 deletions(-)
 rename file_transfer_protocol/{client.py => recieve_file.py} (100%)
 rename file_transfer_protocol/{server.py => send_file.py} (100%)

diff --git a/file_transfer_protocol/client.py b/file_transfer_protocol/recieve_file.py
similarity index 100%
rename from file_transfer_protocol/client.py
rename to file_transfer_protocol/recieve_file.py
diff --git a/file_transfer_protocol/server.py b/file_transfer_protocol/send_file.py
similarity index 100%
rename from file_transfer_protocol/server.py
rename to file_transfer_protocol/send_file.py

From c686cc5863c2ac2530ed1f34bd9ce758bb17945a Mon Sep 17 00:00:00 2001
From: "Marvin M. Michum" <mrvnmchm@gmail.com>
Date: Thu, 8 Aug 2019 11:59:15 -0400
Subject: [PATCH 175/348] fix outdated fork error (#1117)

---
 .../filters/median_filter.py                  |  2 +-
 .../test_digital_image_processing.py          | 62 +++++++++++++++++++
 2 files changed, 63 insertions(+), 1 deletion(-)
 create mode 100644 digital_image_processing/test_digital_image_processing.py

diff --git a/digital_image_processing/filters/median_filter.py b/digital_image_processing/filters/median_filter.py
index ed20b1ab7f78..4b21b96b080b 100644
--- a/digital_image_processing/filters/median_filter.py
+++ b/digital_image_processing/filters/median_filter.py
@@ -15,7 +15,7 @@ def median_filter(gray_img, mask=3):
     # set image borders
     bd = int(mask / 2)
     # copy image size
-    median_img = zeros_like(gray)
+    median_img = zeros_like(gray_img)
     for i in range(bd, gray_img.shape[0] - bd):
         for j in range(bd, gray_img.shape[1] - bd):
             # get mask according with mask
diff --git a/digital_image_processing/test_digital_image_processing.py b/digital_image_processing/test_digital_image_processing.py
new file mode 100644
index 000000000000..0ff9e3333ca8
--- /dev/null
+++ b/digital_image_processing/test_digital_image_processing.py
@@ -0,0 +1,62 @@
+"""
+PyTest's for Digital Image Processing
+"""
+
+import digital_image_processing.edge_detection.canny as canny
+import digital_image_processing.filters.gaussian_filter as gg
+import digital_image_processing.filters.median_filter as med
+import digital_image_processing.filters.sobel_filter as sob
+import digital_image_processing.filters.convolve as conv
+import digital_image_processing.change_contrast as cc
+from cv2 import imread, cvtColor, COLOR_BGR2GRAY
+from numpy import array, uint8
+from PIL import Image
+
+img = imread(r"digital_image_processing/image_data/lena.jpg")
+gray = cvtColor(img, COLOR_BGR2GRAY)
+
+# Test: change_contrast()
+def test_change_contrast():
+    with Image.open("digital_image_processing/image_data/lena.jpg") as img:
+        # Work around assertion for response
+        assert str(cc.change_contrast(img, 110)).startswith(
+            "<PIL.Image.Image image mode=RGB size=512x512 at"
+        )
+
+
+# canny.gen_gaussian_kernel()
+def test_gen_gaussian_kernel():
+    resp = canny.gen_gaussian_kernel(9, sigma=1.4)
+    # Assert ambiguous array
+    assert resp.all()
+
+
+# canny.py
+def test_canny():
+    canny_img = imread("digital_image_processing/image_data/lena.jpg", 0)
+    # assert ambiguos array for all == True
+    assert canny_img.all()
+    canny_array = canny.canny(canny_img)
+    # assert canny array for at least one True
+    assert canny_array.any()
+
+
+# filters/gaussian_filter.py
+def test_gen_gaussian_kernel_filter():
+    assert gg.gaussian_filter(gray, 5, sigma=0.9).all()
+
+
+def test_convolve_filter():
+    # laplace diagonals
+    Laplace = array([[0.25, 0.5, 0.25], [0.5, -3, 0.5], [0.25, 0.5, 0.25]])
+    res = conv.img_convolve(gray, Laplace).astype(uint8)
+    assert res.any()
+
+
+def test_median_filter():
+    assert med.median_filter(gray, 3).any()
+
+
+def test_sobel_filter():
+    grad, theta = sob.sobel_filter(gray)
+    assert grad.any() and theta.any()

From 91c3c98d2be159da836693b6d5ccdab6a3c87466 Mon Sep 17 00:00:00 2001
From: Christian Clauss <cclauss@me.com>
Date: Fri, 9 Aug 2019 21:37:16 +0200
Subject: [PATCH 176/348] Rename file_transfer and linear_algebra (#1118)

* Rename file_transfer and linear_algebra

* Rename file_transfer and linear_algebra
---
 .travis.yml                                                   | 4 ++--
 {file_transfer_protocol => file_transfer}/ftp_send_receive.py | 0
 {file_transfer_protocol => file_transfer}/mytext.txt          | 0
 {file_transfer_protocol => file_transfer}/recieve_file.py     | 0
 {file_transfer_protocol => file_transfer}/send_file.py        | 0
 {linear_algebra_python => linear_algebra}/README.md           | 0
 {linear_algebra_python => linear_algebra}/src/lib.py          | 0
 {linear_algebra_python => linear_algebra}/src/tests.py        | 0
 8 files changed, 2 insertions(+), 2 deletions(-)
 rename {file_transfer_protocol => file_transfer}/ftp_send_receive.py (100%)
 rename {file_transfer_protocol => file_transfer}/mytext.txt (100%)
 rename {file_transfer_protocol => file_transfer}/recieve_file.py (100%)
 rename {file_transfer_protocol => file_transfer}/send_file.py (100%)
 rename {linear_algebra_python => linear_algebra}/README.md (100%)
 rename {linear_algebra_python => linear_algebra}/src/lib.py (100%)
 rename {linear_algebra_python => linear_algebra}/src/tests.py (100%)

diff --git a/.travis.yml b/.travis.yml
index 2536e72fadff..532f73f5e895 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -13,7 +13,7 @@ matrix:
     # - env: FILE=pytest file_transfer_protocol/ftp_client_server.py
     #   before_script: true
     #   script: pytest ${FILE} --doctest-modules
-    - env: FILE=pytest file_transfer_protocol/ftp_send_receive.py
+    - env: FILE=pytest file_transfer/ftp_send_receive.py
       before_script: true
       script: pytest ${FILE} --doctest-modules
     - env: FILE=pytest machine_learning/linear_regression.py
@@ -37,7 +37,7 @@ script:
   - scripts/validate_filenames.py  # no uppercase, no spaces, in a directory
   - mypy --ignore-missing-imports .
   - pytest . --doctest-modules
-      --ignore=file_transfer_protocol/ftp_send_receive.py
+      --ignore=file_transfer/ftp_send_receive.py
       --ignore=machine_learning/linear_regression.py
       --ignore=machine_learning/perceptron.py
       --ignore=machine_learning/random_forest_classification/random_forest_classification.py
diff --git a/file_transfer_protocol/ftp_send_receive.py b/file_transfer/ftp_send_receive.py
similarity index 100%
rename from file_transfer_protocol/ftp_send_receive.py
rename to file_transfer/ftp_send_receive.py
diff --git a/file_transfer_protocol/mytext.txt b/file_transfer/mytext.txt
similarity index 100%
rename from file_transfer_protocol/mytext.txt
rename to file_transfer/mytext.txt
diff --git a/file_transfer_protocol/recieve_file.py b/file_transfer/recieve_file.py
similarity index 100%
rename from file_transfer_protocol/recieve_file.py
rename to file_transfer/recieve_file.py
diff --git a/file_transfer_protocol/send_file.py b/file_transfer/send_file.py
similarity index 100%
rename from file_transfer_protocol/send_file.py
rename to file_transfer/send_file.py
diff --git a/linear_algebra_python/README.md b/linear_algebra/README.md
similarity index 100%
rename from linear_algebra_python/README.md
rename to linear_algebra/README.md
diff --git a/linear_algebra_python/src/lib.py b/linear_algebra/src/lib.py
similarity index 100%
rename from linear_algebra_python/src/lib.py
rename to linear_algebra/src/lib.py
diff --git a/linear_algebra_python/src/tests.py b/linear_algebra/src/tests.py
similarity index 100%
rename from linear_algebra_python/src/tests.py
rename to linear_algebra/src/tests.py

From 36684db2780d695add9bd0a4523d73496cb35664 Mon Sep 17 00:00:00 2001
From: Christian Clauss <cclauss@me.com>
Date: Sat, 10 Aug 2019 22:48:00 +0200
Subject: [PATCH 177/348] Travis CI: Add pytest --doctest-modules
 machine_learning (#1016)

* Travis CI: Add pytest --doctest-modules neural_network

Fixes #987
```
neural_network/perceptron.py:123: in <module>
    sample.insert(i, float(input('value: ')))
../lib/python3.7/site-packages/_pytest/capture.py:693: in read
    raise IOError("reading from stdin while output is captured")
E   OSError: reading from stdin while output is captured
-------------------------------------------------------------------------------- Captured stdout --------------------------------------------------------------------------------
('\nEpoch:\n', 399)
------------------------

value:
```

* Adding fix from #1056 -- thanks @QuantumNovice

* if __name__ == '__main__':

* pytest --ignore=virtualenv  # do not test our dependencies
---
 machine_learning/perceptron.py                | 124 ------------------
 .../random_forest_classification.py           |   8 +-
 .../random_forest_regression.py               |   8 +-
 neural_network/perceptron.py                  |   8 +-
 requirements.txt                              |   1 +
 5 files changed, 15 insertions(+), 134 deletions(-)
 delete mode 100644 machine_learning/perceptron.py

diff --git a/machine_learning/perceptron.py b/machine_learning/perceptron.py
deleted file mode 100644
index fe1032aff4af..000000000000
--- a/machine_learning/perceptron.py
+++ /dev/null
@@ -1,124 +0,0 @@
-'''
-
-	Perceptron
-	w = w + N * (d(k) - y) * x(k)
-
-	Using perceptron network for oil analysis,
-	with Measuring of 3 parameters that represent chemical characteristics we can classify the oil, in p1 or p2
-	p1 = -1
-	p2 = 1
-
-'''
-from __future__ import print_function
-
-import random
-
-
-class Perceptron:
-    def __init__(self, sample, exit, learn_rate=0.01, epoch_number=1000, bias=-1):
-        self.sample = sample
-        self.exit = exit
-        self.learn_rate = learn_rate
-        self.epoch_number = epoch_number
-        self.bias = bias
-        self.number_sample = len(sample)
-        self.col_sample = len(sample[0])
-        self.weight = []
-
-    def trannig(self):
-        for sample in self.sample:
-            sample.insert(0, self.bias)
-
-        for i in range(self.col_sample):
-           self.weight.append(random.random())
-
-        self.weight.insert(0, self.bias)
-
-        epoch_count = 0
-
-        while True:
-            erro = False
-            for i in range(self.number_sample):
-                u = 0
-                for j in range(self.col_sample + 1):
-                    u = u + self.weight[j] * self.sample[i][j]
-                y = self.sign(u)
-                if y != self.exit[i]:
-
-                    for j in range(self.col_sample + 1):
-
-                        self.weight[j] = self.weight[j] + self.learn_rate * (self.exit[i] - y) * self.sample[i][j]
-                    erro = True
-            #print('Epoch: \n',epoch_count)
-            epoch_count = epoch_count + 1
-            # if you want controle the epoch or just by erro
-            if erro == False:
-                print(('\nEpoch:\n',epoch_count))
-                print('------------------------\n')
-            #if epoch_count > self.epoch_number or not erro:
-                break
-
-    def sort(self, sample):
-        sample.insert(0, self.bias)
-        u = 0
-        for i in range(self.col_sample + 1):
-            u = u + self.weight[i] * sample[i]
-
-        y = self.sign(u)
-
-        if  y == -1:
-            print(('Sample: ', sample))
-            print('classification: P1')
-        else:
-            print(('Sample: ', sample))
-            print('classification: P2')
-
-    def sign(self, u):
-        return 1 if u >= 0 else -1
-
-
-samples = [
-    [-0.6508, 0.1097, 4.0009],
-    [-1.4492, 0.8896, 4.4005],
-    [2.0850, 0.6876, 12.0710],
-    [0.2626, 1.1476, 7.7985],
-    [0.6418, 1.0234, 7.0427],
-    [0.2569, 0.6730, 8.3265],
-    [1.1155, 0.6043, 7.4446],
-    [0.0914, 0.3399, 7.0677],
-    [0.0121, 0.5256, 4.6316],
-    [-0.0429, 0.4660, 5.4323],
-    [0.4340, 0.6870, 8.2287],
-    [0.2735, 1.0287, 7.1934],
-    [0.4839, 0.4851, 7.4850],
-    [0.4089, -0.1267, 5.5019],
-    [1.4391, 0.1614, 8.5843],
-    [-0.9115, -0.1973, 2.1962],
-    [0.3654, 1.0475, 7.4858],
-    [0.2144, 0.7515, 7.1699],
-    [0.2013, 1.0014, 6.5489],
-    [0.6483, 0.2183, 5.8991],
-    [-0.1147, 0.2242, 7.2435],
-    [-0.7970, 0.8795, 3.8762],
-    [-1.0625, 0.6366, 2.4707],
-    [0.5307, 0.1285, 5.6883],
-    [-1.2200, 0.7777, 1.7252],
-    [0.3957, 0.1076, 5.6623],
-    [-0.1013, 0.5989, 7.1812],
-    [2.4482, 0.9455, 11.2095],
-    [2.0149, 0.6192, 10.9263],
-    [0.2012, 0.2611, 5.4631]
-
-]
-
-exit = [-1, -1, -1, 1, 1, -1, 1, -1, 1, 1, -1, 1, -1, -1, -1, -1, 1, 1, 1, 1, -1, 1, 1, 1, 1, -1, -1, 1, -1, 1]
-
-network = Perceptron(sample=samples, exit = exit, learn_rate=0.01, epoch_number=1000, bias=-1)
-
-network.trannig()
-
-while True:
-    sample = []
-    for i in range(3):
-        sample.insert(i, float(input('value: ')))
-    network.sort(sample)
diff --git a/machine_learning/random_forest_classification/random_forest_classification.py b/machine_learning/random_forest_classification/random_forest_classification.py
index d5dde4b13822..81016387ecc7 100644
--- a/machine_learning/random_forest_classification/random_forest_classification.py
+++ b/machine_learning/random_forest_classification/random_forest_classification.py
@@ -1,17 +1,19 @@
 # Random Forest Classification
 
 # Importing the libraries
+import os
 import numpy as np
 import matplotlib.pyplot as plt
 import pandas as pd
 
 # Importing the dataset
-dataset = pd.read_csv('Social_Network_Ads.csv')
+script_dir = os.path.dirname(os.path.realpath(__file__))
+dataset = pd.read_csv(os.path.join(script_dir, 'Social_Network_Ads.csv'))
 X = dataset.iloc[:, [2, 3]].values
 y = dataset.iloc[:, 4].values
 
 # Splitting the dataset into the Training set and Test set
-from sklearn.cross_validation import train_test_split
+from sklearn.model_selection import train_test_split
 X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25, random_state = 0)
 
 # Feature Scaling
@@ -66,4 +68,4 @@
 plt.xlabel('Age')
 plt.ylabel('Estimated Salary')
 plt.legend()
-plt.show()
\ No newline at end of file
+plt.show()
diff --git a/machine_learning/random_forest_regression/random_forest_regression.py b/machine_learning/random_forest_regression/random_forest_regression.py
index fce58b1fe283..85ce0676b598 100644
--- a/machine_learning/random_forest_regression/random_forest_regression.py
+++ b/machine_learning/random_forest_regression/random_forest_regression.py
@@ -1,12 +1,14 @@
 # Random Forest Regression
 
 # Importing the libraries
+import os
 import numpy as np
 import matplotlib.pyplot as plt
 import pandas as pd
 
 # Importing the dataset
-dataset = pd.read_csv('Position_Salaries.csv')
+script_dir = os.path.dirname(os.path.realpath(__file__))
+dataset = pd.read_csv(os.path.join(script_dir, 'Position_Salaries.csv'))
 X = dataset.iloc[:, 1:2].values
 y = dataset.iloc[:, 2].values
 
@@ -28,7 +30,7 @@
 regressor.fit(X, y)
 
 # Predicting a new result
-y_pred = regressor.predict(6.5)
+y_pred = regressor.predict([[6.5]])
 
 # Visualising the Random Forest Regression results (higher resolution)
 X_grid = np.arange(min(X), max(X), 0.01)
@@ -38,4 +40,4 @@
 plt.title('Truth or Bluff (Random Forest Regression)')
 plt.xlabel('Position level')
 plt.ylabel('Salary')
-plt.show()
\ No newline at end of file
+plt.show()
diff --git a/neural_network/perceptron.py b/neural_network/perceptron.py
index 787ea8f73bf1..871eca20273b 100644
--- a/neural_network/perceptron.py
+++ b/neural_network/perceptron.py
@@ -113,13 +113,13 @@ def sign(self, u):
 
 exit = [-1, -1, -1, 1, 1, -1, 1, -1, 1, 1, -1, 1, -1, -1, -1, -1, 1, 1, 1, 1, -1, 1, 1, 1, 1, -1, -1, 1, -1, 1]
 
-if __name__ == '__main__':
-    network = Perceptron(sample=samples, exit = exit, learn_rate=0.01, epoch_number=1000, bias=-1)
+network = Perceptron(sample=samples, exit = exit, learn_rate=0.01, epoch_number=1000, bias=-1)
 
-    network.training()
+network.training()
 
+if __name__ == '__main__':
     while True:
         sample = []
         for i in range(3):
-            sample.insert(i, float(input('value: ').strip()))
+            sample.insert(i, float(input('value: ')))
         network.sort(sample)
diff --git a/requirements.txt b/requirements.txt
index a3e62cf968f7..f5790ad53c30 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -7,6 +7,7 @@ opencv-python
 pandas
 pillow
 pytest
+requests
 sklearn
 sympy
 tensorflow

From 55cea57ffa45ad4ef062363c8ec214e81f8c2448 Mon Sep 17 00:00:00 2001
From: Christian Clauss <cclauss@me.com>
Date: Sun, 11 Aug 2019 13:00:58 +0200
Subject: [PATCH 178/348] Fix tests for file_transfer and perceptron.py (#1121)

---
 .travis.yml                       | 31 --------------------------
 file_transfer/ftp_send_receive.py | 36 -------------------------------
 2 files changed, 67 deletions(-)
 delete mode 100644 file_transfer/ftp_send_receive.py

diff --git a/.travis.yml b/.travis.yml
index 532f73f5e895..f7a9264803f8 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -4,32 +4,6 @@ python: 3.7
 cache: pip
 before_install: pip install --upgrade pip setuptools
 install: pip install -r requirements.txt
-matrix:
-  include:
-    - name: "Main tests"
-    # The following files currently fail pytests.  See issues: #1016, #1044, #1080
-    # Here they are run allow_failures mode and when each passes pytest, it can be
-    # removed BOTH lists below.  Complex now but simple once all files pass pytest.
-    # - env: FILE=pytest file_transfer_protocol/ftp_client_server.py
-    #   before_script: true
-    #   script: pytest ${FILE} --doctest-modules
-    - env: FILE=pytest file_transfer/ftp_send_receive.py
-      before_script: true
-      script: pytest ${FILE} --doctest-modules
-    - env: FILE=pytest machine_learning/linear_regression.py
-      before_script: true
-      script: pytest ${FILE} --doctest-modules
-    - env: FILE=pytest machine_learning/perceptron.py
-      before_script: true
-      script: pytest ${FILE} --doctest-modules
-    - env: FILE=pytest machine_learning/random_forest_classification/random_forest_classification.py
-      before_script: true
-      script: pytest ${FILE} --doctest-modules
-    - env: FILE=pytest machine_learning/random_forest_regression/random_forest_regression.py
-      before_script: true
-      script: pytest ${FILE} --doctest-modules
-  allow_failures:
-    - before_script: true
 before_script:
   - black --check . || true
   - flake8 . --count --select=E9,F401,F63,F7,F82 --show-source --statistics
@@ -37,11 +11,6 @@ script:
   - scripts/validate_filenames.py  # no uppercase, no spaces, in a directory
   - mypy --ignore-missing-imports .
   - pytest . --doctest-modules
-      --ignore=file_transfer/ftp_send_receive.py
-      --ignore=machine_learning/linear_regression.py
-      --ignore=machine_learning/perceptron.py
-      --ignore=machine_learning/random_forest_classification/random_forest_classification.py
-      --ignore=machine_learning/random_forest_regression/random_forest_regression.py
 after_success:
   - scripts/build_directory_md.py > DIRECTORY.md
   - cat DIRECTORY.md
diff --git a/file_transfer/ftp_send_receive.py b/file_transfer/ftp_send_receive.py
deleted file mode 100644
index 6a9819ef3f21..000000000000
--- a/file_transfer/ftp_send_receive.py
+++ /dev/null
@@ -1,36 +0,0 @@
-"""
-File transfer protocol used to send and receive files using FTP server.
-Use credentials to provide access to the FTP client
-
-Note: Do not use root username & password for security reasons
-Create a seperate user and provide access to a home directory of the user
-Use login id and password of the user created 
-cwd here stands for current working directory
-"""
-
-from ftplib import FTP
-ftp = FTP('xxx.xxx.x.x')  # Enter the ip address or the domain name here
-ftp.login(user='username', passwd='password')
-ftp.cwd('/Enter the directory here/')
-
-"""
-The file which will be received via the FTP server
-Enter the location of the file where the file is received
-"""
-
-def ReceiveFile():
-	FileName = 'example.txt'   """ Enter the location of the file """
-	with open(FileName, 'wb') as LocalFile:
-		ftp.retrbinary('RETR ' + FileName, LocalFile.write, 1024)
-	ftp.quit()
-
-"""
-The file which will be sent via the FTP server
-The file send will be send to the current working directory
-"""
-
-def SendFile():
-	FileName = 'example.txt'   """ Enter the name of the file """
-	with open(FileName, 'rb') as LocalFile:
-		ftp.storbinary('STOR ' + FileName, LocalFile)
-	ftp.quit()

From 158b319d22e6ffa5399ce42bcfe1a7c968ebaa66 Mon Sep 17 00:00:00 2001
From: Niclas Dern <52120196+nic-dern@users.noreply.github.com>
Date: Mon, 12 Aug 2019 09:13:57 +0200
Subject: [PATCH 179/348] New linear algebra algorithm (#1122)

* Added new algorithm which takes points as an input and outputs a polynom connecting them

* Rename Python-Polynom-for-points.py to python-polynom-for-points.py

* Update python-polynom-for-points.py

* Update python-polynom-for-points.py

* Update python-polynom-for-points.py

* Update python-polynom-for-points.py

* Update python-polynom-for-points.py

* Update python-polynom-for-points.py

* Update python-polynom-for-points.py

* Add doctests and run thru psf/black
---
 .../src/python-polynom-for-points.py          | 130 ++++++++++++++++++
 1 file changed, 130 insertions(+)
 create mode 100644 linear_algebra/src/python-polynom-for-points.py

diff --git a/linear_algebra/src/python-polynom-for-points.py b/linear_algebra/src/python-polynom-for-points.py
new file mode 100644
index 000000000000..c884416b6dad
--- /dev/null
+++ b/linear_algebra/src/python-polynom-for-points.py
@@ -0,0 +1,130 @@
+def points_to_polynomial(coordinates):
+    """
+    coordinates is a two dimensional matrix: [[x, y], [x, y], ...]
+    number of points you want to use
+
+    >>> print(points_to_polynomial([]))
+    The program cannot work out a fitting polynomial.
+    >>> print(points_to_polynomial([[]]))
+    The program cannot work out a fitting polynomial.
+    >>> print(points_to_polynomial([[1, 0], [2, 0], [3, 0]]))
+    f(x)=x^2*0.0+x^1*-0.0+x^0*0.0
+    >>> print(points_to_polynomial([[1, 1], [2, 1], [3, 1]]))
+    f(x)=x^2*0.0+x^1*-0.0+x^0*1.0
+    >>> print(points_to_polynomial([[1, 3], [2, 3], [3, 3]]))
+    f(x)=x^2*0.0+x^1*-0.0+x^0*3.0
+    >>> print(points_to_polynomial([[1, 1], [2, 2], [3, 3]]))
+    f(x)=x^2*0.0+x^1*1.0+x^0*0.0
+    >>> print(points_to_polynomial([[1, 1], [2, 4], [3, 9]]))
+    f(x)=x^2*1.0+x^1*-0.0+x^0*0.0
+    >>> print(points_to_polynomial([[1, 3], [2, 6], [3, 11]]))
+    f(x)=x^2*1.0+x^1*-0.0+x^0*2.0
+    >>> print(points_to_polynomial([[1, -3], [2, -6], [3, -11]]))
+    f(x)=x^2*-1.0+x^1*-0.0+x^0*-2.0
+    >>> print(points_to_polynomial([[1, 5], [2, 2], [3, 9]]))
+    f(x)=x^2*5.0+x^1*-18.0+x^0*18.0
+    """
+    try:
+        check = 1
+        more_check = 0
+        d = coordinates[0][0]
+        for j in range(len(coordinates)):
+            if j == 0:
+                continue
+            if d == coordinates[j][0]:
+                more_check += 1
+                solved = "x=" + str(coordinates[j][0])
+                if more_check == len(coordinates) - 1:
+                    check = 2
+                    break
+                elif more_check > 0 and more_check != len(coordinates) - 1:
+                    check = 3
+                else:
+                    check = 1
+
+        if len(coordinates) == 1 and coordinates[0][0] == 0:
+            check = 2
+            solved = "x=0"
+    except Exception:
+        check = 3
+
+    x = len(coordinates)
+
+    if check == 1:
+        count_of_line = 0
+        matrix = []
+        # put the x and x to the power values in a matrix
+        while count_of_line < x:
+            count_in_line = 0
+            a = coordinates[count_of_line][0]
+            count_line = []
+            while count_in_line < x:
+                count_line.append(a ** (x - (count_in_line + 1)))
+                count_in_line += 1
+            matrix.append(count_line)
+            count_of_line += 1
+
+        count_of_line = 0
+        # put the y values into a vector
+        vector = []
+        while count_of_line < x:
+            count_in_line = 0
+            vector.append(coordinates[count_of_line][1])
+            count_of_line += 1
+
+        count = 0
+
+        while count < x:
+            zahlen = 0
+            while zahlen < x:
+                if count == zahlen:
+                    zahlen += 1
+                if zahlen == x:
+                    break
+                bruch = (matrix[zahlen][count]) / (matrix[count][count])
+                for counting_columns, item in enumerate(matrix[count]):
+                    # manipulating all the values in the matrix
+                    matrix[zahlen][counting_columns] -= item * bruch
+                # manipulating the values in the vector
+                vector[zahlen] -= vector[count] * bruch
+                zahlen += 1
+            count += 1
+
+        count = 0
+        # make solutions
+        solution = []
+        while count < x:
+            solution.append(vector[count] / matrix[count][count])
+            count += 1
+
+        count = 0
+        solved = "f(x)="
+
+        while count < x:
+            remove_e = str(solution[count]).split("E")
+            if len(remove_e) > 1:
+                solution[count] = remove_e[0] + "*10^" + remove_e[1]
+            solved += "x^" + str(x - (count + 1)) + "*" + str(solution[count])
+            if count + 1 != x:
+                solved += "+"
+            count += 1
+
+        return solved
+
+    elif check == 2:
+        return solved
+    else:
+        return "The program cannot work out a fitting polynomial."
+
+
+if __name__ == "__main__":
+    print(points_to_polynomial([]))
+    print(points_to_polynomial([[]]))
+    print(points_to_polynomial([[1, 0], [2, 0], [3, 0]]))
+    print(points_to_polynomial([[1, 1], [2, 1], [3, 1]]))
+    print(points_to_polynomial([[1, 3], [2, 3], [3, 3]]))
+    print(points_to_polynomial([[1, 1], [2, 2], [3, 3]]))
+    print(points_to_polynomial([[1, 1], [2, 4], [3, 9]]))
+    print(points_to_polynomial([[1, 3], [2, 6], [3, 11]]))
+    print(points_to_polynomial([[1, -3], [2, -6], [3, -11]]))
+    print(points_to_polynomial([[1, 5], [2, 2], [3, 9]]))

From 4fea48072ae88c19f5133a2303e6707eddf96700 Mon Sep 17 00:00:00 2001
From: Christian Clauss <cclauss@me.com>
Date: Mon, 12 Aug 2019 17:59:59 +0200
Subject: [PATCH 180/348] Add type hints to binary_tree_traversals.py (#1123)

---
 traversals/binary_tree_traversals.py | 103 +++++++++++++--------------
 1 file changed, 50 insertions(+), 53 deletions(-)

diff --git a/traversals/binary_tree_traversals.py b/traversals/binary_tree_traversals.py
index 393664579146..7fd9f7111844 100644
--- a/traversals/binary_tree_traversals.py
+++ b/traversals/binary_tree_traversals.py
@@ -1,14 +1,8 @@
 """
 This is pure python implementation of tree traversal algorithms
 """
-from __future__ import print_function
-
 import queue
-
-try:
-    raw_input  # Python 2
-except NameError:
-    raw_input = input  # Python 3
+from typing import List
 
 
 class TreeNode:
@@ -20,35 +14,31 @@ def __init__(self, data):
 
 def build_tree():
     print("\n********Press N to stop entering at any point of time********\n")
-    print("Enter the value of the root node: ", end="")
-    check = raw_input().strip().lower()
-    if check == 'n':
+    check = input("Enter the value of the root node: ").strip().lower() or "n"
+    if check == "n":
         return None
-    data = int(check)
-    q = queue.Queue()
-    tree_node = TreeNode(data)
+    q: queue.Queue = queue.Queue()
+    tree_node = TreeNode(int(check))
     q.put(tree_node)
     while not q.empty():
         node_found = q.get()
-        print("Enter the left node of %s: " % node_found.data, end="")
-        check = raw_input().strip().lower()
-        if check == 'n':
+        msg = "Enter the left node of %s: " % node_found.data
+        check = input(msg).strip().lower() or "n"
+        if check == "n":
             return tree_node
-        left_data = int(check)
-        left_node = TreeNode(left_data)
+        left_node = TreeNode(int(check))
         node_found.left = left_node
         q.put(left_node)
-        print("Enter the right node of %s: " % node_found.data, end="")
-        check = raw_input().strip().lower()
-        if check == 'n':
+        msg = "Enter the right node of %s: " % node_found.data
+        check = input(msg).strip().lower() or "n"
+        if check == "n":
             return tree_node
-        right_data = int(check)
-        right_node = TreeNode(right_data)
+        right_node = TreeNode(int(check))
         node_found.right = right_node
         q.put(right_node)
 
 
-def pre_order(node):
+def pre_order(node: TreeNode) -> None:
     if not isinstance(node, TreeNode) or not node:
         return
     print(node.data, end=" ")
@@ -56,7 +46,7 @@ def pre_order(node):
     pre_order(node.right)
 
 
-def in_order(node):
+def in_order(node: TreeNode) -> None:
     if not isinstance(node, TreeNode) or not node:
         return
     in_order(node.left)
@@ -64,7 +54,7 @@ def in_order(node):
     in_order(node.right)
 
 
-def post_order(node):
+def post_order(node: TreeNode) -> None:
     if not isinstance(node, TreeNode) or not node:
         return
     post_order(node.left)
@@ -72,10 +62,10 @@ def post_order(node):
     print(node.data, end=" ")
 
 
-def level_order(node):
+def level_order(node: TreeNode) -> None:
     if not isinstance(node, TreeNode) or not node:
         return
-    q = queue.Queue()
+    q: queue.Queue = queue.Queue()
     q.put(node)
     while not q.empty():
         node_dequeued = q.get()
@@ -86,10 +76,10 @@ def level_order(node):
             q.put(node_dequeued.right)
 
 
-def level_order_actual(node):
+def level_order_actual(node: TreeNode) -> None:
     if not isinstance(node, TreeNode) or not node:
         return
-    q = queue.Queue()
+    q: queue.Queue = queue.Queue()
     q.put(node)
     while not q.empty():
         list = []
@@ -106,10 +96,10 @@ def level_order_actual(node):
 
 
 # iteration version
-def pre_order_iter(node):
+def pre_order_iter(node: TreeNode) -> None:
     if not isinstance(node, TreeNode) or not node:
         return
-    stack = []
+    stack: List[TreeNode] = []
     n = node
     while n or stack:
         while n:  # start from root node, find its left child
@@ -122,10 +112,10 @@ def pre_order_iter(node):
         n = n.right
 
 
-def in_order_iter(node):
+def in_order_iter(node: TreeNode) -> None:
     if not isinstance(node, TreeNode) or not node:
         return
-    stack = []
+    stack: List[TreeNode] = []
     n = node
     while n or stack:
         while n:
@@ -136,7 +126,7 @@ def in_order_iter(node):
         n = n.right
 
 
-def post_order_iter(node):
+def post_order_iter(node: TreeNode) -> None:
     if not isinstance(node, TreeNode) or not node:
         return
     stack1, stack2 = [], []
@@ -153,38 +143,45 @@ def post_order_iter(node):
         print(stack2.pop().data, end=" ")
 
 
-if __name__ == '__main__':
-    print("\n********* Binary Tree Traversals ************\n")
+def prompt(s: str = "", width=50, char="*") -> str:
+    if not s:
+        return "\n" + width * char
+    left, extra = divmod(width - len(s) - 2, 2)
+    return f"{left * char} {s} {(left + extra) * char}"
+
+
+if __name__ == "__main__":
+    print(prompt("Binary Tree Traversals"))
 
     node = build_tree()
-    print("\n********* Pre Order Traversal ************")
+    print(prompt("Pre Order Traversal"))
     pre_order(node)
-    print("\n******************************************\n")
+    print(prompt() + "\n")
 
-    print("\n********* In Order Traversal ************")
+    print(prompt("In Order Traversal"))
     in_order(node)
-    print("\n******************************************\n")
+    print(prompt() + "\n")
 
-    print("\n********* Post Order Traversal ************")
+    print(prompt("Post Order Traversal"))
     post_order(node)
-    print("\n******************************************\n")
+    print(prompt() + "\n")
 
-    print("\n********* Level Order Traversal ************")
+    print(prompt("Level Order Traversal"))
     level_order(node)
-    print("\n******************************************\n")
+    print(prompt() + "\n")
 
-    print("\n********* Actual Level Order Traversal ************")
+    print(prompt("Actual Level Order Traversal"))
     level_order_actual(node)
-    print("\n******************************************\n")
+    print("*" * 50 + "\n")
 
-    print("\n********* Pre Order Traversal - Iteration Version ************")
+    print(prompt("Pre Order Traversal - Iteration Version"))
     pre_order_iter(node)
-    print("\n******************************************\n")
+    print(prompt() + "\n")
 
-    print("\n********* In Order Traversal - Iteration Version ************")
+    print(prompt("In Order Traversal - Iteration Version"))
     in_order_iter(node)
-    print("\n******************************************\n")
+    print(prompt() + "\n")
 
-    print("\n********* Post Order Traversal - Iteration Version ************")
+    print(prompt("Post Order Traversal - Iteration Version"))
     post_order_iter(node)
-    print("\n******************************************\n")
+    print(prompt())

From c74fd0c9bf984613d9087a793f832d25d19e855f Mon Sep 17 00:00:00 2001
From: Christian Clauss <cclauss@me.com>
Date: Tue, 13 Aug 2019 11:50:13 +0200
Subject: [PATCH 181/348] Add maths/test_prime_check.py (#1125)

* Add maths/test_prime_check.py

* Add comments on why this file is required
---
 maths/test_prime_check.py | 8 ++++++++
 1 file changed, 8 insertions(+)
 create mode 100644 maths/test_prime_check.py

diff --git a/maths/test_prime_check.py b/maths/test_prime_check.py
new file mode 100644
index 000000000000..b6389684af9e
--- /dev/null
+++ b/maths/test_prime_check.py
@@ -0,0 +1,8 @@
+"""
+Minimalist file that allows pytest to find and run the Test unittest.  For details, see:
+http://doc.pytest.org/en/latest/goodpractices.html#conventions-for-python-test-discovery
+"""
+
+from .prime_check import Test
+
+Test()

From dc2b575274ad4920a0e3f2303a80796daafce84f Mon Sep 17 00:00:00 2001
From: Christian Clauss <cclauss@me.com>
Date: Tue, 13 Aug 2019 11:59:49 +0200
Subject: [PATCH 182/348] Add doctests to networking_flow/minimum_cut.py
 (#1126)

---
 networking_flow/minimum_cut.py | 57 +++++++++++++++++++---------------
 1 file changed, 32 insertions(+), 25 deletions(-)

diff --git a/networking_flow/minimum_cut.py b/networking_flow/minimum_cut.py
index 8ad6e03b00c6..7773df72f8f0 100644
--- a/networking_flow/minimum_cut.py
+++ b/networking_flow/minimum_cut.py
@@ -1,12 +1,21 @@
 # Minimum cut on Ford_Fulkerson algorithm.
-    
+
+test_graph = [
+    [0, 16, 13, 0, 0, 0],
+    [0, 0, 10, 12, 0, 0],
+    [0, 4, 0, 0, 14, 0],
+    [0, 0, 9, 0, 0, 20],
+    [0, 0, 0, 7, 0, 4],
+    [0, 0, 0, 0, 0, 0],
+]
+
+
 def BFS(graph, s, t, parent):
     # Return True if there is node that has not iterated.
-    visited = [False]*len(graph)
-    queue=[]
-    queue.append(s)
+    visited = [False] * len(graph)
+    queue = [s]
     visited[s] = True
-    
+
     while queue:
         u = queue.pop(0)
         for ind in range(len(graph[u])):
@@ -16,26 +25,30 @@ def BFS(graph, s, t, parent):
                 parent[ind] = u
 
     return True if visited[t] else False
- 
+
+
 def mincut(graph, source, sink):
-    # This array is filled by BFS and to store path
-    parent = [-1]*(len(graph))
-    max_flow = 0 
+    """This array is filled by BFS and to store path
+    >>> mincut(test_graph, source=0, sink=5)
+    [(1, 3), (4, 3), (4, 5)]
+    """
+    parent = [-1] * (len(graph))
+    max_flow = 0
     res = []
-    temp = [i[:] for i in graph]   # Record orignial cut, copy.
-    while BFS(graph, source, sink, parent) :
+    temp = [i[:] for i in graph]  # Record orignial cut, copy.
+    while BFS(graph, source, sink, parent):
         path_flow = float("Inf")
         s = sink
 
-        while(s !=  source):
+        while s != source:
             # Find the minimum value in select path
-            path_flow = min (path_flow, graph[parent[s]][s])
+            path_flow = min(path_flow, graph[parent[s]][s])
             s = parent[s]
 
-        max_flow +=  path_flow
+        max_flow += path_flow
         v = sink
-        
-        while(v !=  source):
+
+        while v != source:
             u = parent[v]
             graph[u][v] -= path_flow
             graph[v][u] += path_flow
@@ -44,16 +57,10 @@ def mincut(graph, source, sink):
     for i in range(len(graph)):
         for j in range(len(graph[0])):
             if graph[i][j] == 0 and temp[i][j] > 0:
-                res.append((i,j))
+                res.append((i, j))
 
     return res
 
-graph = [[0, 16, 13, 0, 0, 0],
-         [0, 0, 10 ,12, 0, 0],
-         [0, 4, 0, 0, 14, 0],
-         [0, 0, 9, 0, 0, 20],
-         [0, 0, 0, 7, 0, 4],
-         [0, 0, 0, 0, 0, 0]]
 
-source, sink = 0, 5
-print(mincut(graph, source, sink))
\ No newline at end of file
+if __name__ == "__main__":
+    print(mincut(test_graph, source=0, sink=5))

From f3c0b132bcfcf2773734e9418153af01f37475a2 Mon Sep 17 00:00:00 2001
From: adith bharadwaj <adithbharadwaj@gmail.com>
Date: Tue, 13 Aug 2019 19:21:06 +0530
Subject: [PATCH 183/348] Added sudoku solving program in backtracking
 algorithms (#1128)

* Added sudoku solver in backtracking

* Added sudoku solver program

* Added sudoku solver

* Added sudoku solver

* Format with black, add doctests, cleanup main
---
 backtracking/sudoku.py | 151 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 151 insertions(+)
 create mode 100644 backtracking/sudoku.py

diff --git a/backtracking/sudoku.py b/backtracking/sudoku.py
new file mode 100644
index 000000000000..b33351fd4911
--- /dev/null
+++ b/backtracking/sudoku.py
@@ -0,0 +1,151 @@
+"""
+
+    Given a partially filled 9×9 2D array, the objective is to fill a 9×9
+    square grid with digits numbered 1 to 9, so that every row, column, and
+    and each of the nine 3×3 sub-grids contains all of the digits.
+
+    This can be solved using Backtracking and is similar to n-queens.
+    We check to see if a cell is safe or not and recursively call the
+    function on the next column to see if it returns True. if yes, we
+    have solved the puzzle. else, we backtrack and place another number
+    in that cell and repeat this process.
+
+"""
+
+# assigning initial values to the grid
+initial_grid = [
+    [3, 0, 6, 5, 0, 8, 4, 0, 0],
+    [5, 2, 0, 0, 0, 0, 0, 0, 0],
+    [0, 8, 7, 0, 0, 0, 0, 3, 1],
+    [0, 0, 3, 0, 1, 0, 0, 8, 0],
+    [9, 0, 0, 8, 6, 3, 0, 0, 5],
+    [0, 5, 0, 0, 9, 0, 6, 0, 0],
+    [1, 3, 0, 0, 0, 0, 2, 5, 0],
+    [0, 0, 0, 0, 0, 0, 0, 7, 4],
+    [0, 0, 5, 2, 0, 6, 3, 0, 0],
+]
+# a grid with no solution
+no_solution = [
+    [5, 0, 6, 5, 0, 8, 4, 0, 3],
+    [5, 2, 0, 0, 0, 0, 0, 0, 2],
+    [1, 8, 7, 0, 0, 0, 0, 3, 1],
+    [0, 0, 3, 0, 1, 0, 0, 8, 0],
+    [9, 0, 0, 8, 6, 3, 0, 0, 5],
+    [0, 5, 0, 0, 9, 0, 6, 0, 0],
+    [1, 3, 0, 0, 0, 0, 2, 5, 0],
+    [0, 0, 0, 0, 0, 0, 0, 7, 4],
+    [0, 0, 5, 2, 0, 6, 3, 0, 0],
+]
+
+
+def is_safe(grid, row, column, n):
+    """
+    This function checks the grid to see if each row,
+    column, and the 3x3 subgrids contain the digit 'n'.
+    It returns False if it is not 'safe' (a duplicate digit
+    is found) else returns True if it is 'safe'
+
+    """
+
+    for i in range(9):
+        if grid[row][i] == n or grid[i][column] == n:
+            return False
+
+    for i in range(3):
+        for j in range(3):
+            if grid[(row - row % 3) + i][(column - column % 3) + j] == n:
+                return False
+
+    return True
+
+
+def is_completed(grid):
+    """
+    This function checks if the puzzle is completed or not.
+    it is completed when all the cells are assigned with a number(not zero)
+    and There is no repeating number in any column, row or 3x3 subgrid.
+
+    """
+
+    for row in grid:
+        for cell in row:
+            if cell == 0:
+                return False
+
+    return True
+
+
+def find_empty_location(grid):
+    """
+    This function finds an empty location so that we can assign a number
+    for that particular row and column.
+
+    """
+
+    for i in range(9):
+        for j in range(9):
+            if grid[i][j] == 0:
+                return i, j
+
+
+def sudoku(grid):
+    """
+    Takes a partially filled-in grid and attempts to assign values to
+    all unassigned locations in such a way to meet the requirements
+    for Sudoku solution (non-duplication across rows, columns, and boxes)
+
+    >>> sudoku(initial_grid)  # doctest: +NORMALIZE_WHITESPACE
+    [[3, 1, 6, 5, 7, 8, 4, 9, 2],
+     [5, 2, 9, 1, 3, 4, 7, 6, 8],
+     [4, 8, 7, 6, 2, 9, 5, 3, 1],
+     [2, 6, 3, 4, 1, 5, 9, 8, 7],
+     [9, 7, 4, 8, 6, 3, 1, 2, 5],
+     [8, 5, 1, 7, 9, 2, 6, 4, 3],
+     [1, 3, 8, 9, 4, 7, 2, 5, 6],
+     [6, 9, 2, 3, 5, 1, 8, 7, 4],
+     [7, 4, 5, 2, 8, 6, 3, 1, 9]]
+     >>> sudoku(no_solution)
+     False
+     """
+
+    if is_completed(grid):
+        return grid
+
+    row, column = find_empty_location(grid)
+
+    for digit in range(1, 10):
+        if is_safe(grid, row, column, digit):
+            grid[row][column] = digit
+
+            if sudoku(grid):
+                return grid
+
+            grid[row][column] = 0
+
+    return False
+
+
+def print_solution(grid):
+    """
+    A function to print the solution in the form
+    of a 9x9 grid
+
+    """
+
+    for row in grid:
+        for cell in row:
+            print(cell, end=" ")
+        print()
+
+
+if __name__ == "__main__":
+
+    # make a copy of grid so that you can compare with the unmodified grid
+    for grid in (initial_grid, no_solution):
+        grid = list(map(list, grid))
+        solution = sudoku(grid)
+        if solution:
+            print("grid after solving:")
+            print_solution(solution)
+        else:
+            print("Cannot find a solution.")

From 8eab2f17f4e3378995b8ccdc8f547784e046fc31 Mon Sep 17 00:00:00 2001
From: Alok Shukla <alok.linuxmail@gmail.com>
Date: Tue, 13 Aug 2019 22:46:11 +0530
Subject: [PATCH 184/348] Solution for Problem Euler 56 (#1131)

* Solution for Euler 56

* Adding Type and Doctest as per guideline

* removing unused import

* correcting the way type check works
---
 project_euler/problem_56/__init__.py |  0
 project_euler/problem_56/sol1.py     | 26 ++++++++++++++++++++++++++
 2 files changed, 26 insertions(+)
 create mode 100644 project_euler/problem_56/__init__.py
 create mode 100644 project_euler/problem_56/sol1.py

diff --git a/project_euler/problem_56/__init__.py b/project_euler/problem_56/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/project_euler/problem_56/sol1.py b/project_euler/problem_56/sol1.py
new file mode 100644
index 000000000000..194a7a37af43
--- /dev/null
+++ b/project_euler/problem_56/sol1.py
@@ -0,0 +1,26 @@
+
+
+def maximum_digital_sum(a: int, b: int) -> int:
+    """
+        Considering natural numbers of the form, a**b, where a, b < 100,
+        what is the maximum digital sum?
+        :param a:
+        :param b:
+        :return:
+        >>> maximum_digital_sum(10,10)
+        45
+
+        >>> maximum_digital_sum(100,100)
+        972
+
+        >>> maximum_digital_sum(100,200)
+        1872
+    """
+
+    # RETURN the MAXIMUM from the list of SUMs of the list of INT converted from STR of BASE raised to the POWER
+    return max([sum([int(x) for x in str(base**power)]) for base in range(a) for power in range(b)])
+
+#Tests
+if __name__ == "__main__":
+    import doctest
+    doctest.testmod()

From 27205d454877e76fc753feb3dfd528d5d29b93f2 Mon Sep 17 00:00:00 2001
From: Christian Clauss <cclauss@me.com>
Date: Wed, 14 Aug 2019 23:24:58 +0200
Subject: [PATCH 185/348] Update DIRECTORY.md (#1129)

---
 DIRECTORY.md | 430 +++++++++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 420 insertions(+), 10 deletions(-)

diff --git a/DIRECTORY.md b/DIRECTORY.md
index d97791bb5dd3..80bf64ef4c30 100644
--- a/DIRECTORY.md
+++ b/DIRECTORY.md
@@ -1,395 +1,805 @@
 ## Arithmetic Analysis
+
   * [bisection](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/bisection.py)
+
   * [in static equilibrium](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/in_static_equilibrium.py)
+
   * [intersection](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/intersection.py)
+
   * [lu decomposition](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/lu_decomposition.py)
+
   * [newton method](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/newton_method.py)
+
   * [newton raphson method](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/newton_raphson_method.py)
+
 ## Backtracking
+
   * [all combinations](https://github.com/TheAlgorithms/Python/blob/master/backtracking/all_combinations.py)
+
   * [all permutations](https://github.com/TheAlgorithms/Python/blob/master/backtracking/all_permutations.py)
+
   * [all subsequences](https://github.com/TheAlgorithms/Python/blob/master/backtracking/all_subsequences.py)
+
   * [minimax](https://github.com/TheAlgorithms/Python/blob/master/backtracking/minimax.py)
+
   * [n queens](https://github.com/TheAlgorithms/Python/blob/master/backtracking/n_queens.py)
+
+  * [sudoku](https://github.com/TheAlgorithms/Python/blob/master/backtracking/sudoku.py)
+
   * [sum of subsets](https://github.com/TheAlgorithms/Python/blob/master/backtracking/sum_of_subsets.py)
+
 ## Boolean Algebra
+
   * [quine mc cluskey](https://github.com/TheAlgorithms/Python/blob/master/boolean_algebra/quine_mc_cluskey.py)
+
 ## Ciphers
+
   * [affine cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/affine_cipher.py)
+
   * [atbash](https://github.com/TheAlgorithms/Python/blob/master/ciphers/atbash.py)
+
   * [base16](https://github.com/TheAlgorithms/Python/blob/master/ciphers/base16.py)
+
   * [base32](https://github.com/TheAlgorithms/Python/blob/master/ciphers/base32.py)
+
   * [base64 cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/base64_cipher.py)
+
   * [base85](https://github.com/TheAlgorithms/Python/blob/master/ciphers/base85.py)
+
   * [brute force caesar cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/brute_force_caesar_cipher.py)
+
   * [caesar cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/caesar_cipher.py)
+
   * [cryptomath module](https://github.com/TheAlgorithms/Python/blob/master/ciphers/cryptomath_module.py)
+
   * [elgamal key generator](https://github.com/TheAlgorithms/Python/blob/master/ciphers/elgamal_key_generator.py)
+
   * [hill cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/hill_cipher.py)
+
   * [morse code implementation](https://github.com/TheAlgorithms/Python/blob/master/ciphers/morse_code_implementation.py)
+
   * [onepad cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/onepad_cipher.py)
+
   * [playfair cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/playfair_cipher.py)
+
   * [rabin miller](https://github.com/TheAlgorithms/Python/blob/master/ciphers/rabin_miller.py)
+
   * [rot13](https://github.com/TheAlgorithms/Python/blob/master/ciphers/rot13.py)
+
   * [rsa cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/rsa_cipher.py)
+
   * [rsa key generator](https://github.com/TheAlgorithms/Python/blob/master/ciphers/rsa_key_generator.py)
+
   * [simple substitution cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/simple_substitution_cipher.py)
+
   * [trafid cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/trafid_cipher.py)
+
   * [transposition cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/transposition_cipher.py)
+
   * [transposition cipher encrypt decrypt file](https://github.com/TheAlgorithms/Python/blob/master/ciphers/transposition_cipher_encrypt_decrypt_file.py)
+
   * [vigenere cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/vigenere_cipher.py)
+
   * [xor cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/xor_cipher.py)
+
 ## Compression
+
   * [burrows wheeler](https://github.com/TheAlgorithms/Python/blob/master/compression/burrows_wheeler.py)
+
   * [huffman](https://github.com/TheAlgorithms/Python/blob/master/compression/huffman.py)
+
   * [peak signal to noise ratio](https://github.com/TheAlgorithms/Python/blob/master/compression/peak_signal_to_noise_ratio.py)
+
 ## Conversions
+
   * [decimal to binary](https://github.com/TheAlgorithms/Python/blob/master/conversions/decimal_to_binary.py)
+
   * [decimal to hexadecimal](https://github.com/TheAlgorithms/Python/blob/master/conversions/decimal_to_hexadecimal.py)
+
   * [decimal to octal](https://github.com/TheAlgorithms/Python/blob/master/conversions/decimal_to_octal.py)
+
 ## Data Structures
+
   * Binary Tree
+
     * [avl tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/avl_tree.py)
+
     * [basic binary tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/basic_binary_tree.py)
+
     * [binary search tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/binary_search_tree.py)
+
     * [fenwick tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/fenwick_tree.py)
+
     * [lazy segment tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/lazy_segment_tree.py)
+
     * [lca](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/lca.py)
+
     * [red black tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/red_black_tree.py)
+
     * [segment tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/segment_tree.py)
+
     * [treap](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/treap.py)
+
   * Hashing
+
     * [double hash](https://github.com/TheAlgorithms/Python/blob/master/data_structures/hashing/double_hash.py)
+
     * [hash table](https://github.com/TheAlgorithms/Python/blob/master/data_structures/hashing/hash_table.py)
+
     * [hash table with linked list](https://github.com/TheAlgorithms/Python/blob/master/data_structures/hashing/hash_table_with_linked_list.py)
+
     * Number Theory
+
       * [prime numbers](https://github.com/TheAlgorithms/Python/blob/master/data_structures/hashing/number_theory/prime_numbers.py)
+
     * [quadratic probing](https://github.com/TheAlgorithms/Python/blob/master/data_structures/hashing/quadratic_probing.py)
+
   * Heap
+
     * [heap](https://github.com/TheAlgorithms/Python/blob/master/data_structures/heap/heap.py)
+
   * Linked List
+
     * [doubly linked list](https://github.com/TheAlgorithms/Python/blob/master/data_structures/linked_list/doubly_linked_list.py)
+
     * [is palindrome](https://github.com/TheAlgorithms/Python/blob/master/data_structures/linked_list/is_palindrome.py)
+
     * [singly linked list](https://github.com/TheAlgorithms/Python/blob/master/data_structures/linked_list/singly_linked_list.py)
+
     * [swap nodes](https://github.com/TheAlgorithms/Python/blob/master/data_structures/linked_list/swap_nodes.py)
+
   * Queue
+
     * [double ended queue](https://github.com/TheAlgorithms/Python/blob/master/data_structures/queue/double_ended_queue.py)
+
     * [queue on list](https://github.com/TheAlgorithms/Python/blob/master/data_structures/queue/queue_on_list.py)
+
     * [queue on pseudo stack](https://github.com/TheAlgorithms/Python/blob/master/data_structures/queue/queue_on_pseudo_stack.py)
+
   * Stacks
+
     * [balanced parentheses](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stacks/balanced_parentheses.py)
+
     * [infix to postfix conversion](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stacks/infix_to_postfix_conversion.py)
+
     * [infix to prefix conversion](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stacks/infix_to_prefix_conversion.py)
+
     * [next greater element](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stacks/next_greater_element.py)
+
     * [postfix evaluation](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stacks/postfix_evaluation.py)
+
     * [stack](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stacks/stack.py)
+
     * [stock span problem](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stacks/stock_span_problem.py)
+
   * Trie
+
     * [trie](https://github.com/TheAlgorithms/Python/blob/master/data_structures/trie/trie.py)
+
 ## Digital Image Processing
+
   * [change contrast](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/change_contrast.py)
+
   * Edge Detection
+
     * [canny](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/edge_detection/canny.py)
+
   * Filters
+
     * [convolve](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/filters/convolve.py)
+
     * [gaussian filter](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/filters/gaussian_filter.py)
+
     * [median filter](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/filters/median_filter.py)
+
     * [sobel filter](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/filters/sobel_filter.py)
+
+  * [test digital image processing](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/test_digital_image_processing.py)
+
 ## Divide And Conquer
+
   * [closest pair of points](https://github.com/TheAlgorithms/Python/blob/master/divide_and_conquer/closest_pair_of_points.py)
+
   * [max subarray sum](https://github.com/TheAlgorithms/Python/blob/master/divide_and_conquer/max_subarray_sum.py)
+
 ## Dynamic Programming
+
   * [abbreviation](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/abbreviation.py)
+
   * [bitmask](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/bitmask.py)
+
   * [climbing stairs](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/climbing_stairs.py)
+
   * [coin change](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/coin_change.py)
+
   * [edit distance](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/edit_distance.py)
+
   * [factorial](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/factorial.py)
+
   * [fast fibonacci](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/fast_fibonacci.py)
+
   * [fibonacci](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/fibonacci.py)
+
   * [floyd warshall](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/floyd_warshall.py)
+
   * [fractional knapsack](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/fractional_knapsack.py)
+
   * [integer partition](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/integer_partition.py)
+
   * [k means clustering tensorflow](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/k_means_clustering_tensorflow.py)
+
   * [knapsack](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/knapsack.py)
+
   * [longest common subsequence](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/longest_common_subsequence.py)
+
   * [longest increasing subsequence](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/longest_increasing_subsequence.py)
+
   * [longest increasing subsequence o(nlogn)](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/longest_increasing_subsequence_o(nlogn).py)
+
   * [longest sub array](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/longest_sub_array.py)
+
   * [matrix chain order](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/matrix_chain_order.py)
+
   * [max sub array](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/max_sub_array.py)
+
   * [minimum partition](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/minimum_partition.py)
+
   * [rod cutting](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/rod_cutting.py)
+
   * [subset generation](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/subset_generation.py)
+
   * [sum of subset](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/sum_of_subset.py)
-## File Transfer Protocol
-  * [ftp client server](https://github.com/TheAlgorithms/Python/blob/master/file_transfer_protocol/ftp_client_server.py)
-  * [ftp send receive](https://github.com/TheAlgorithms/Python/blob/master/file_transfer_protocol/ftp_send_receive.py)
+
+## File Transfer
+
+  * [recieve file](https://github.com/TheAlgorithms/Python/blob/master/file_transfer/recieve_file.py)
+
+  * [send file](https://github.com/TheAlgorithms/Python/blob/master/file_transfer/send_file.py)
+
 ## Graphs
+
   * [a star](https://github.com/TheAlgorithms/Python/blob/master/graphs/a_star.py)
+
   * [articulation points](https://github.com/TheAlgorithms/Python/blob/master/graphs/articulation_points.py)
+
   * [basic graphs](https://github.com/TheAlgorithms/Python/blob/master/graphs/basic_graphs.py)
+
   * [bellman ford](https://github.com/TheAlgorithms/Python/blob/master/graphs/bellman_ford.py)
+
   * [bfs](https://github.com/TheAlgorithms/Python/blob/master/graphs/bfs.py)
+
   * [bfs shortest path](https://github.com/TheAlgorithms/Python/blob/master/graphs/bfs_shortest_path.py)
+
   * [breadth first search](https://github.com/TheAlgorithms/Python/blob/master/graphs/breadth_first_search.py)
+
   * [check bipartite graph bfs](https://github.com/TheAlgorithms/Python/blob/master/graphs/check_bipartite_graph_bfs.py)
+
   * [check bipartite graph dfs](https://github.com/TheAlgorithms/Python/blob/master/graphs/check_bipartite_graph_dfs.py)
+
   * [depth first search](https://github.com/TheAlgorithms/Python/blob/master/graphs/depth_first_search.py)
+
   * [dfs](https://github.com/TheAlgorithms/Python/blob/master/graphs/dfs.py)
+
   * [dijkstra](https://github.com/TheAlgorithms/Python/blob/master/graphs/dijkstra.py)
+
   * [dijkstra 2](https://github.com/TheAlgorithms/Python/blob/master/graphs/dijkstra_2.py)
+
   * [dijkstra algorithm](https://github.com/TheAlgorithms/Python/blob/master/graphs/dijkstra_algorithm.py)
+
   * [directed and undirected (weighted) graph](https://github.com/TheAlgorithms/Python/blob/master/graphs/directed_and_undirected_(weighted)_graph.py)
+
   * [edmonds karp multiple source and sink](https://github.com/TheAlgorithms/Python/blob/master/graphs/edmonds_karp_multiple_source_and_sink.py)
+
   * [eulerian path and circuit for undirected graph](https://github.com/TheAlgorithms/Python/blob/master/graphs/eulerian_path_and_circuit_for_undirected_graph.py)
+
   * [even tree](https://github.com/TheAlgorithms/Python/blob/master/graphs/even_tree.py)
+
   * [finding bridges](https://github.com/TheAlgorithms/Python/blob/master/graphs/finding_bridges.py)
+
   * [graph list](https://github.com/TheAlgorithms/Python/blob/master/graphs/graph_list.py)
+
   * [graph matrix](https://github.com/TheAlgorithms/Python/blob/master/graphs/graph_matrix.py)
+
   * [graphs floyd warshall](https://github.com/TheAlgorithms/Python/blob/master/graphs/graphs_floyd_warshall.py)
+
   * [kahns algorithm long](https://github.com/TheAlgorithms/Python/blob/master/graphs/kahns_algorithm_long.py)
+
   * [kahns algorithm topo](https://github.com/TheAlgorithms/Python/blob/master/graphs/kahns_algorithm_topo.py)
+
   * [minimum spanning tree kruskal](https://github.com/TheAlgorithms/Python/blob/master/graphs/minimum_spanning_tree_kruskal.py)
+
   * [minimum spanning tree prims](https://github.com/TheAlgorithms/Python/blob/master/graphs/minimum_spanning_tree_prims.py)
+
   * [multi hueristic astar](https://github.com/TheAlgorithms/Python/blob/master/graphs/multi_hueristic_astar.py)
+
   * [page rank](https://github.com/TheAlgorithms/Python/blob/master/graphs/page_rank.py)
+
   * [prim](https://github.com/TheAlgorithms/Python/blob/master/graphs/prim.py)
+
   * [scc kosaraju](https://github.com/TheAlgorithms/Python/blob/master/graphs/scc_kosaraju.py)
+
   * [tarjans scc](https://github.com/TheAlgorithms/Python/blob/master/graphs/tarjans_scc.py)
+
 ## Hashes
+
   * [chaos machine](https://github.com/TheAlgorithms/Python/blob/master/hashes/chaos_machine.py)
+
   * [enigma machine](https://github.com/TheAlgorithms/Python/blob/master/hashes/enigma_machine.py)
+
   * [md5](https://github.com/TheAlgorithms/Python/blob/master/hashes/md5.py)
+
   * [sha1](https://github.com/TheAlgorithms/Python/blob/master/hashes/sha1.py)
-## Linear Algebra Python
+
+## Linear Algebra
+
   * Src
-    * [lib](https://github.com/TheAlgorithms/Python/blob/master/linear_algebra_python/src/lib.py)
-    * [tests](https://github.com/TheAlgorithms/Python/blob/master/linear_algebra_python/src/tests.py)
+
+    * [lib](https://github.com/TheAlgorithms/Python/blob/master/linear_algebra/src/lib.py)
+
+    * [python-polynom-for-points](https://github.com/TheAlgorithms/Python/blob/master/linear_algebra/src/python-polynom-for-points.py)
+
+    * [tests](https://github.com/TheAlgorithms/Python/blob/master/linear_algebra/src/tests.py)
+
 ## Machine Learning
-  * [NaiveBayes](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/NaiveBayes.ipynb)
+
   * [decision tree](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/decision_tree.py)
+
   * [gradient descent](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/gradient_descent.py)
+
   * [k means clust](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/k_means_clust.py)
+
   * [knn sklearn](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/knn_sklearn.py)
+
   * [linear regression](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/linear_regression.py)
+
   * [logistic regression](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/logistic_regression.py)
-  * [perceptron](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/perceptron.py)
+
+  * [naive bayes](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/naive_bayes.ipynb)
+
   * Random Forest Classification
+
     * [random forest classification](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/random_forest_classification/random_forest_classification.py)
+
     * [random forest classifier](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/random_forest_classification/random_forest_classifier.ipynb)
+
   * Random Forest Regression
+
     * [random forest regression](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/random_forest_regression/random_forest_regression.ipynb)
+
     * [random forest regression](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/random_forest_regression/random_forest_regression.py)
+
   * [reuters one vs rest classifier](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/reuters_one_vs_rest_classifier.ipynb)
+
   * [scoring functions](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/scoring_functions.py)
+
 ## Maths
+
   * [3n+1](https://github.com/TheAlgorithms/Python/blob/master/maths/3n+1.py)
+
   * [abs](https://github.com/TheAlgorithms/Python/blob/master/maths/abs.py)
+
   * [abs max](https://github.com/TheAlgorithms/Python/blob/master/maths/abs_max.py)
+
   * [abs min](https://github.com/TheAlgorithms/Python/blob/master/maths/abs_min.py)
+
   * [average mean](https://github.com/TheAlgorithms/Python/blob/master/maths/average_mean.py)
+
   * [average median](https://github.com/TheAlgorithms/Python/blob/master/maths/average_median.py)
+
   * [basic maths](https://github.com/TheAlgorithms/Python/blob/master/maths/basic_maths.py)
+
   * [binary exponentiation](https://github.com/TheAlgorithms/Python/blob/master/maths/binary_exponentiation.py)
+
+  * [collatz sequence](https://github.com/TheAlgorithms/Python/blob/master/maths/collatz_sequence.py)
+
   * [extended euclidean algorithm](https://github.com/TheAlgorithms/Python/blob/master/maths/extended_euclidean_algorithm.py)
+
   * [factorial python](https://github.com/TheAlgorithms/Python/blob/master/maths/factorial_python.py)
+
   * [factorial recursive](https://github.com/TheAlgorithms/Python/blob/master/maths/factorial_recursive.py)
+
   * [fermat little theorem](https://github.com/TheAlgorithms/Python/blob/master/maths/fermat_little_theorem.py)
+
   * [fibonacci](https://github.com/TheAlgorithms/Python/blob/master/maths/fibonacci.py)
+
   * [fibonacci sequence recursion](https://github.com/TheAlgorithms/Python/blob/master/maths/fibonacci_sequence_recursion.py)
+
   * [find lcm](https://github.com/TheAlgorithms/Python/blob/master/maths/find_lcm.py)
+
   * [find max](https://github.com/TheAlgorithms/Python/blob/master/maths/find_max.py)
+
   * [find min](https://github.com/TheAlgorithms/Python/blob/master/maths/find_min.py)
+
   * [gaussian](https://github.com/TheAlgorithms/Python/blob/master/maths/gaussian.py)
+
   * [greater common divisor](https://github.com/TheAlgorithms/Python/blob/master/maths/greater_common_divisor.py)
+
   * [is square free](https://github.com/TheAlgorithms/Python/blob/master/maths/is_square_free.py)
+
+  * [largest of very large numbers](https://github.com/TheAlgorithms/Python/blob/master/maths/largest_of_very_large_numbers.py)
+
+  * [lucas lehmer primality test](https://github.com/TheAlgorithms/Python/blob/master/maths/lucas_lehmer_primality_test.py)
+
   * [lucas series](https://github.com/TheAlgorithms/Python/blob/master/maths/lucas_series.py)
+
   * [mobius function](https://github.com/TheAlgorithms/Python/blob/master/maths/mobius_function.py)
+
   * [modular exponential](https://github.com/TheAlgorithms/Python/blob/master/maths/modular_exponential.py)
+
   * [newton raphson](https://github.com/TheAlgorithms/Python/blob/master/maths/newton_raphson.py)
+
   * [prime check](https://github.com/TheAlgorithms/Python/blob/master/maths/prime_check.py)
+
   * [prime factors](https://github.com/TheAlgorithms/Python/blob/master/maths/prime_factors.py)
+
+  * [quadratic equations complex numbers](https://github.com/TheAlgorithms/Python/blob/master/maths/quadratic_equations_complex_numbers.py)
+
   * [segmented sieve](https://github.com/TheAlgorithms/Python/blob/master/maths/segmented_sieve.py)
+
   * [sieve of eratosthenes](https://github.com/TheAlgorithms/Python/blob/master/maths/sieve_of_eratosthenes.py)
+
   * [simpson rule](https://github.com/TheAlgorithms/Python/blob/master/maths/simpson_rule.py)
+
+  * [test prime check](https://github.com/TheAlgorithms/Python/blob/master/maths/test_prime_check.py)
+
   * [trapezoidal rule](https://github.com/TheAlgorithms/Python/blob/master/maths/trapezoidal_rule.py)
+
   * [volume](https://github.com/TheAlgorithms/Python/blob/master/maths/volume.py)
+
+  * [zellers congruence](https://github.com/TheAlgorithms/Python/blob/master/maths/zellers_congruence.py)
+
 ## Matrix
+
   * [matrix operation](https://github.com/TheAlgorithms/Python/blob/master/matrix/matrix_operation.py)
+
   * [nth fibonacci using matrix exponentiation](https://github.com/TheAlgorithms/Python/blob/master/matrix/nth_fibonacci_using_matrix_exponentiation.py)
+
   * [rotate matrix](https://github.com/TheAlgorithms/Python/blob/master/matrix/rotate_matrix.py)
+
   * [searching in sorted matrix](https://github.com/TheAlgorithms/Python/blob/master/matrix/searching_in_sorted_matrix.py)
+
   * [spiral print](https://github.com/TheAlgorithms/Python/blob/master/matrix/spiral_print.py)
+
   * Tests
+
     * [test matrix operation](https://github.com/TheAlgorithms/Python/blob/master/matrix/tests/test_matrix_operation.py)
+
 ## Networking Flow
+
   * [ford fulkerson](https://github.com/TheAlgorithms/Python/blob/master/networking_flow/ford_fulkerson.py)
+
   * [minimum cut](https://github.com/TheAlgorithms/Python/blob/master/networking_flow/minimum_cut.py)
+
 ## Neural Network
+
   * [back propagation neural network](https://github.com/TheAlgorithms/Python/blob/master/neural_network/back_propagation_neural_network.py)
+
   * [convolution neural network](https://github.com/TheAlgorithms/Python/blob/master/neural_network/convolution_neural_network.py)
+
   * [fully connected neural network](https://github.com/TheAlgorithms/Python/blob/master/neural_network/fully_connected_neural_network.ipynb)
+
   * [perceptron](https://github.com/TheAlgorithms/Python/blob/master/neural_network/perceptron.py)
+
 ## Other
-  * [Food wastage analysis from 1961-2013 (FAO)](https://github.com/TheAlgorithms/Python/blob/master/other/Food%20wastage%20analysis%20from%201961-2013%20(FAO).ipynb)
+
   * [anagrams](https://github.com/TheAlgorithms/Python/blob/master/other/anagrams.py)
+
   * [binary exponentiation](https://github.com/TheAlgorithms/Python/blob/master/other/binary_exponentiation.py)
+
   * [binary exponentiation 2](https://github.com/TheAlgorithms/Python/blob/master/other/binary_exponentiation_2.py)
+
   * [detecting english programmatically](https://github.com/TheAlgorithms/Python/blob/master/other/detecting_english_programmatically.py)
+
   * [euclidean gcd](https://github.com/TheAlgorithms/Python/blob/master/other/euclidean_gcd.py)
-  * [finding primes](https://github.com/TheAlgorithms/Python/blob/master/other/finding_primes.py)
+
   * [fischer yates shuffle](https://github.com/TheAlgorithms/Python/blob/master/other/fischer_yates_shuffle.py)
+
+  * [food wastage analysis from 1961-2013 fao](https://github.com/TheAlgorithms/Python/blob/master/other/food_wastage_analysis_from_1961-2013_fao.ipynb)
+
   * [frequency finder](https://github.com/TheAlgorithms/Python/blob/master/other/frequency_finder.py)
+
   * [game of life](https://github.com/TheAlgorithms/Python/blob/master/other/game_of_life.py)
+
   * [linear congruential generator](https://github.com/TheAlgorithms/Python/blob/master/other/linear_congruential_generator.py)
+
   * [nested brackets](https://github.com/TheAlgorithms/Python/blob/master/other/nested_brackets.py)
+
   * [palindrome](https://github.com/TheAlgorithms/Python/blob/master/other/palindrome.py)
+
   * [password generator](https://github.com/TheAlgorithms/Python/blob/master/other/password_generator.py)
+
   * [primelib](https://github.com/TheAlgorithms/Python/blob/master/other/primelib.py)
+
   * [sierpinski triangle](https://github.com/TheAlgorithms/Python/blob/master/other/sierpinski_triangle.py)
+
   * [tower of hanoi](https://github.com/TheAlgorithms/Python/blob/master/other/tower_of_hanoi.py)
+
   * [two sum](https://github.com/TheAlgorithms/Python/blob/master/other/two_sum.py)
+
   * [word patterns](https://github.com/TheAlgorithms/Python/blob/master/other/word_patterns.py)
+
 ## Project Euler
+
   * Problem 01
+
     * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_01/sol1.py)
+
     * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_01/sol2.py)
+
     * [sol3](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_01/sol3.py)
+
     * [sol4](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_01/sol4.py)
+
     * [sol5](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_01/sol5.py)
+
     * [sol6](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_01/sol6.py)
+
   * Problem 02
+
     * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_02/sol1.py)
+
     * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_02/sol2.py)
+
     * [sol3](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_02/sol3.py)
+
     * [sol4](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_02/sol4.py)
+
   * Problem 03
+
     * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_03/sol1.py)
+
     * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_03/sol2.py)
+
   * Problem 04
+
     * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_04/sol1.py)
+
     * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_04/sol2.py)
+
   * Problem 05
+
     * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_05/sol1.py)
+
     * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_05/sol2.py)
+
   * Problem 06
+
     * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_06/sol1.py)
+
     * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_06/sol2.py)
+
     * [sol3](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_06/sol3.py)
+
   * Problem 07
+
     * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_07/sol1.py)
+
     * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_07/sol2.py)
+
     * [sol3](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_07/sol3.py)
+
   * Problem 08
+
     * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_08/sol1.py)
+
     * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_08/sol2.py)
+
   * Problem 09
+
     * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_09/sol1.py)
+
     * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_09/sol2.py)
+
     * [sol3](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_09/sol3.py)
+
   * Problem 10
+
     * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_10/sol1.py)
+
     * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_10/sol2.py)
+
+    * [sol3](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_10/sol3.py)
+
   * Problem 11
+
     * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_11/sol1.py)
+
     * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_11/sol2.py)
+
   * Problem 12
+
     * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_12/sol1.py)
+
     * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_12/sol2.py)
+
   * Problem 13
+
     * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_13/sol1.py)
+
   * Problem 14
+
     * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_14/sol1.py)
+
     * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_14/sol2.py)
+
   * Problem 15
+
     * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_15/sol1.py)
+
   * Problem 16
+
     * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_16/sol1.py)
+
     * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_16/sol2.py)
+
   * Problem 17
+
     * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_17/sol1.py)
+
   * Problem 19
+
     * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_19/sol1.py)
+
   * Problem 20
+
     * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_20/sol1.py)
+
     * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_20/sol2.py)
+
   * Problem 21
+
     * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_21/sol1.py)
+
   * Problem 22
+
     * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_22/sol1.py)
+
     * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_22/sol2.py)
+
   * Problem 234
+
     * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_234/sol1.py)
+
   * Problem 24
+
     * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_24/sol1.py)
+
   * Problem 25
+
     * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_25/sol1.py)
+
     * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_25/sol2.py)
+
   * Problem 28
+
     * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_28/sol1.py)
+
   * Problem 29
+
     * [solution](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_29/solution.py)
+
   * Problem 31
+
     * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_31/sol1.py)
+
   * Problem 36
+
     * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_36/sol1.py)
+
   * Problem 40
+
     * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_40/sol1.py)
+
   * Problem 48
+
     * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_48/sol1.py)
+
   * Problem 52
+
     * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_52/sol1.py)
+
   * Problem 53
+
     * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_53/sol1.py)
+
   * Problem 76
+
     * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_76/sol1.py)
+
 ## Searches
+
   * [binary search](https://github.com/TheAlgorithms/Python/blob/master/searches/binary_search.py)
+
   * [interpolation search](https://github.com/TheAlgorithms/Python/blob/master/searches/interpolation_search.py)
+
   * [jump search](https://github.com/TheAlgorithms/Python/blob/master/searches/jump_search.py)
+
   * [linear search](https://github.com/TheAlgorithms/Python/blob/master/searches/linear_search.py)
+
   * [quick select](https://github.com/TheAlgorithms/Python/blob/master/searches/quick_select.py)
+
   * [sentinel linear search](https://github.com/TheAlgorithms/Python/blob/master/searches/sentinel_linear_search.py)
+
   * [tabu search](https://github.com/TheAlgorithms/Python/blob/master/searches/tabu_search.py)
+
   * [ternary search](https://github.com/TheAlgorithms/Python/blob/master/searches/ternary_search.py)
+
 ## Sorts
+
   * [bitonic sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/bitonic_sort.py)
+
   * [bogo sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/bogo_sort.py)
+
   * [bubble sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/bubble_sort.py)
+
   * [bucket sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/bucket_sort.py)
+
   * [cocktail shaker sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/cocktail_shaker_sort.py)
+
   * [comb sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/comb_sort.py)
+
   * [counting sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/counting_sort.py)
+
   * [cycle sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/cycle_sort.py)
+
   * [external sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/external_sort.py)
+
   * [gnome sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/gnome_sort.py)
+
   * [heap sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/heap_sort.py)
+
   * [insertion sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/insertion_sort.py)
+
   * [merge sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/merge_sort.py)
+
   * [merge sort fastest](https://github.com/TheAlgorithms/Python/blob/master/sorts/merge_sort_fastest.py)
+
   * [odd even transposition parallel](https://github.com/TheAlgorithms/Python/blob/master/sorts/odd_even_transposition_parallel.py)
+
   * [odd even transposition single threaded](https://github.com/TheAlgorithms/Python/blob/master/sorts/odd_even_transposition_single_threaded.py)
+
   * [pancake sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/pancake_sort.py)
+
   * [pigeon sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/pigeon_sort.py)
+
   * [quick sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/quick_sort.py)
+
   * [quick sort 3 partition](https://github.com/TheAlgorithms/Python/blob/master/sorts/quick_sort_3_partition.py)
+
   * [radix sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/radix_sort.py)
+
   * [random normal distribution quicksort](https://github.com/TheAlgorithms/Python/blob/master/sorts/random_normal_distribution_quicksort.py)
+
   * [random pivot quick sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/random_pivot_quick_sort.py)
+
   * [selection sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/selection_sort.py)
+
   * [shell sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/shell_sort.py)
+
   * [tim sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/tim_sort.py)
+
   * [topological sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/topological_sort.py)
+
   * [tree sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/tree_sort.py)
+
   * [wiggle sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/wiggle_sort.py)
+
 ## Strings
+
   * [boyer moore search](https://github.com/TheAlgorithms/Python/blob/master/strings/boyer_moore_search.py)
+
   * [knuth morris pratt](https://github.com/TheAlgorithms/Python/blob/master/strings/knuth_morris_pratt.py)
+
   * [levenshtein distance](https://github.com/TheAlgorithms/Python/blob/master/strings/levenshtein_distance.py)
+
   * [manacher](https://github.com/TheAlgorithms/Python/blob/master/strings/manacher.py)
+
   * [min cost string conversion](https://github.com/TheAlgorithms/Python/blob/master/strings/min_cost_string_conversion.py)
+
   * [naive string search](https://github.com/TheAlgorithms/Python/blob/master/strings/naive_string_search.py)
+
   * [rabin karp](https://github.com/TheAlgorithms/Python/blob/master/strings/rabin_karp.py)
+
 ## Traversals
+
   * [binary tree traversals](https://github.com/TheAlgorithms/Python/blob/master/traversals/binary_tree_traversals.py)

From 3e69733e44d2789647b434a1a6d112062b143e00 Mon Sep 17 00:00:00 2001
From: Christian Clauss <cclauss@me.com>
Date: Thu, 15 Aug 2019 13:19:38 +0200
Subject: [PATCH 186/348] Remove 'python' from the filename (#1130)

---
 .../src/{python-polynom-for-points.py => polynom-for-points.py}   | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename linear_algebra/src/{python-polynom-for-points.py => polynom-for-points.py} (100%)

diff --git a/linear_algebra/src/python-polynom-for-points.py b/linear_algebra/src/polynom-for-points.py
similarity index 100%
rename from linear_algebra/src/python-polynom-for-points.py
rename to linear_algebra/src/polynom-for-points.py

From 5bdcd4836c1a47fb14f7bf89339b3c99bf67fe51 Mon Sep 17 00:00:00 2001
From: Maxwell Aladago <maxwell.aladago@gmail.com>
Date: Thu, 15 Aug 2019 14:07:43 -0400
Subject: [PATCH 187/348] =?UTF-8?q?EHN:=20A=20divide-and-conquer,=20and=20?=
 =?UTF-8?q?brute-force=20algorithms=20for=20array=20inversions=20co?=
 =?UTF-8?q?=E2=80=A6=20(#1133)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* divide and conquer and brute force algorithms for array-inversions counting

* divide and conquer and brute force algorithms for array-inversions counting

* divide and conquer and brute force algorithms for array-inversions counting
---
 divide_and_conquer/inversions.py | 173 +++++++++++++++++++++++++++++++
 1 file changed, 173 insertions(+)
 create mode 100644 divide_and_conquer/inversions.py

diff --git a/divide_and_conquer/inversions.py b/divide_and_conquer/inversions.py
new file mode 100644
index 000000000000..527741cad3b7
--- /dev/null
+++ b/divide_and_conquer/inversions.py
@@ -0,0 +1,173 @@
+from __future__ import print_function, absolute_import, division
+
+"""
+Given an array-like data structure A[1..n], how many pairs
+(i, j) for all 1 <= i < j <= n such that A[i] > A[j]? These pairs are 
+called inversions. Counting the number of such inversions in an array-like 
+object is the important. Among other things, counting inversions  can help 
+us determine how close a given array is to being sorted
+ 
+In this implementation, I provide two algorithms, a divide-and-conquer
+algorithm which runs in nlogn and the brute-force n^2 algorithm. 
+ 
+"""
+
+
+def count_inversions_bf(arr):
+    """
+    Counts the number of inversions using a a naive brute-force algorithm
+
+    Parameters
+    ----------
+    arr: arr: array-like, the list containing the items for which the number
+    of inversions is desired. The elements of `arr` must be comparable.
+
+    Returns
+    -------
+    num_inversions: The total number of inversions in `arr`
+
+    Examples
+    ---------
+
+     >>> count_inversions_bf([1, 4, 2, 4, 1])
+     4
+     >>> count_inversions_bf([1, 1, 2, 4, 4])
+     0
+     >>> count_inversions_bf([])
+     0
+    """
+
+    num_inversions = 0
+    n = len(arr)
+
+    for i in range(n-1):
+        for j in range(i + 1, n):
+            if arr[i] > arr[j]:
+                num_inversions += 1
+
+    return num_inversions
+
+
+def count_inversions_recursive(arr):
+    """
+    Counts the number of inversions using a divide-and-conquer algorithm
+
+    Parameters
+    -----------
+    arr: array-like, the list containing the items for which the number
+    of inversions is desired. The elements of `arr` must be comparable.
+
+    Returns
+    -------
+    C: a sorted copy of `arr`.
+    num_inversions: int, the total number of inversions in 'arr'
+
+    Examples
+    --------
+
+    >>> count_inversions_recursive([1, 4, 2, 4, 1])
+    ([1, 1, 2, 4, 4], 4)
+    >>> count_inversions_recursive([1, 1, 2, 4, 4])
+    ([1, 1, 2, 4, 4], 0)
+    >>> count_inversions_recursive([])
+    ([], 0)
+    """
+    if len(arr) <= 1:
+        return arr, 0
+    else:
+        mid = len(arr)//2
+        P = arr[0:mid]
+        Q = arr[mid:]
+
+        A, inversion_p = count_inversions_recursive(P)
+        B, inversions_q = count_inversions_recursive(Q)
+        C, cross_inversions = _count_cross_inversions(A, B)
+
+        num_inversions = inversion_p + inversions_q + cross_inversions
+        return C, num_inversions
+
+
+def _count_cross_inversions(P, Q):
+    """
+    Counts the inversions across two sorted arrays.
+    And combine the two arrays into one sorted array
+
+    For all 1<= i<=len(P) and for all 1 <= j <= len(Q),
+    if P[i] > Q[j], then (i, j) is a cross inversion
+
+    Parameters
+    ----------
+    P: array-like, sorted in non-decreasing order
+    Q: array-like, sorted in non-decreasing order
+
+    Returns
+    ------
+    R: array-like, a sorted array of the elements of `P` and `Q`
+    num_inversion: int, the number of inversions across `P` and `Q`
+
+    Examples
+    --------
+
+    >>> _count_cross_inversions([1, 2, 3], [0, 2, 5])
+    ([0, 1, 2, 2, 3, 5], 4)
+    >>> _count_cross_inversions([1, 2, 3], [3, 4, 5])
+    ([1, 2, 3, 3, 4, 5], 0)
+    """
+
+    R = []
+    i = j = num_inversion = 0
+    while i < len(P) and j < len(Q):
+        if P[i] > Q[j]:
+            # if P[1] > Q[j], then P[k] > Q[k] for all  i < k <= len(P)
+            # These are all inversions. The claim emerges from the
+            # property that P is sorted.
+            num_inversion += (len(P) - i)
+            R.append(Q[j])
+            j += 1
+        else:
+            R.append(P[i])
+            i += 1
+
+    if i < len(P):
+       R.extend(P[i:])
+    else:
+       R.extend(Q[j:])
+
+    return R, num_inversion
+
+
+def main():
+    arr_1 = [10, 2, 1, 5, 5, 2, 11]
+
+    # this arr has 8 inversions:
+    # (10, 2), (10, 1), (10, 5), (10, 5), (10, 2), (2, 1), (5, 2), (5, 2)
+
+    num_inversions_bf = count_inversions_bf(arr_1)
+    _, num_inversions_recursive = count_inversions_recursive(arr_1)
+
+    assert num_inversions_bf == num_inversions_recursive == 8
+
+    print("number of inversions = ", num_inversions_bf)
+
+    # testing an array with zero inversion (a sorted arr_1)
+
+    arr_1.sort()
+    num_inversions_bf = count_inversions_bf(arr_1)
+    _, num_inversions_recursive = count_inversions_recursive(arr_1)
+
+    assert num_inversions_bf == num_inversions_recursive == 0
+    print("number of inversions = ", num_inversions_bf)
+
+    # an empty list should also have zero inversions
+    arr_1 = []
+    num_inversions_bf = count_inversions_bf(arr_1)
+    _, num_inversions_recursive = count_inversions_recursive(arr_1)
+
+    assert num_inversions_bf == num_inversions_recursive == 0
+    print("number of inversions = ", num_inversions_bf)
+
+
+if __name__ == "__main__":
+   main()
+
+

From a18a8fe2b9e8cfa659d59e14b9a2077f37d86719 Mon Sep 17 00:00:00 2001
From: Christian Clauss <cclauss@me.com>
Date: Sat, 17 Aug 2019 00:46:33 +0200
Subject: [PATCH 188/348] Update .gitignore to remove __pycache__/ (#1127)

---
 .gitignore | 34 +++++++++++++++++++++++++---------
 1 file changed, 25 insertions(+), 9 deletions(-)

diff --git a/.gitignore b/.gitignore
index 0c3f33058614..b840d4ed0490 100644
--- a/.gitignore
+++ b/.gitignore
@@ -7,9 +7,7 @@ __pycache__/
 *.so
 
 # Distribution / packaging
-.vscode/
 .Python
-env/
 build/
 develop-eggs/
 dist/
@@ -21,9 +19,11 @@ lib64/
 parts/
 sdist/
 var/
+wheels/
 *.egg-info/
 .installed.cfg
 *.egg
+MANIFEST
 
 # PyInstaller
 #  Usually these files are written by a python script from a template
@@ -43,8 +43,9 @@ htmlcov/
 .cache
 nosetests.xml
 coverage.xml
-*,cover
+*.cover
 .hypothesis/
+.pytest_cache/
 
 # Translations
 *.mo
@@ -53,6 +54,7 @@ coverage.xml
 # Django stuff:
 *.log
 local_settings.py
+db.sqlite3
 
 # Flask stuff:
 instance/
@@ -67,7 +69,7 @@ docs/_build/
 # PyBuilder
 target/
 
-# IPython Notebook
+# Jupyter Notebook
 .ipynb_checkpoints
 
 # pyenv
@@ -76,18 +78,32 @@ target/
 # celery beat schedule file
 celerybeat-schedule
 
-# dotenv
-.env
+# SageMath parsed files
+*.sage.py
 
-# virtualenv
+# Environments
+.env
+.venv
+env/
 venv/
 ENV/
+env.bak/
+venv.bak/
 
 # Spyder project settings
 .spyderproject
+.spyproject
 
 # Rope project settings
 .ropeproject
-.idea
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+
 .DS_Store
-.try
\ No newline at end of file
+.idea
+.try
+.vscode/

From 05c9a05f3663df7a93c0e50f9035c8b2c5f2754b Mon Sep 17 00:00:00 2001
From: Maxwell Aladago <maxwell.aladago@gmail.com>
Date: Sat, 17 Aug 2019 11:36:31 -0400
Subject: [PATCH 189/348] ENH: two algorithms for the convex hull problem of a
 set of 2d points on a plain (#1135)

* divide and conquer and brute force algorithms for array-inversions counting

* divide and conquer and brute force algorithms for array-inversions counting

* divide and conquer and brute force algorithms for array-inversions counting

* a naive and divide-and-conquer algorithms for the convex-hull problem

* two convex-hull algorithms, a divide-and-conquer and a naive algorithm

* two convex-hull algorithms, a divide-and-conquer and a naive algorithm

* two convex-hull algorithms, a divide-and-conquer and a naive algorithm
---
 divide_and_conquer/convex_hull.py | 431 ++++++++++++++++++++++++++++++
 1 file changed, 431 insertions(+)
 create mode 100644 divide_and_conquer/convex_hull.py

diff --git a/divide_and_conquer/convex_hull.py b/divide_and_conquer/convex_hull.py
new file mode 100644
index 000000000000..f15d74ddea68
--- /dev/null
+++ b/divide_and_conquer/convex_hull.py
@@ -0,0 +1,431 @@
+from __future__ import print_function, absolute_import, division
+
+from numbers import Number
+"""
+The convex hull problem is problem of finding all the vertices of convex polygon, P of 
+a set of points in a plane such that all the points are either on the vertices of P or
+inside P. TH convex hull problem has several applications in geometrical problems, 
+computer graphics and game development. 
+
+Two algorithms have been implemented for the convex hull problem here. 
+1. A brute-force algorithm which runs in O(n^3)
+2. A divide-and-conquer algorithm which runs in O(n^3)
+
+There are other several other algorithms for the convex hull problem
+which have not been implemented here, yet. 
+
+"""
+
+
+class Point:
+    """
+    Defines a 2-d point for use by all convex-hull algorithms.
+
+    Parameters
+    ----------
+    x: an int or a float, the x-coordinate of the 2-d point
+    y: an int or a float, the y-coordinate of the 2-d point
+
+    Examples
+    --------
+    >>> Point(1, 2)
+    (1, 2)
+    >>> Point("1", "2")
+    (1.0, 2.0)
+    >>> Point(1, 2) > Point(0, 1)
+    True
+    >>> Point(1, 1) == Point(1, 1)
+    True
+    >>> Point(-0.5, 1) == Point(0.5, 1)
+    False
+    >>> Point("pi", "e")
+    Traceback (most recent call last):
+        ...
+    ValueError: x and y must be both numeric types but got <class 'str'>, <class 'str'> instead
+     """
+
+    def __init__(self, x, y):
+        if not (isinstance(x, Number) and isinstance(y, Number)):
+            try:
+                x, y = float(x), float(y)
+            except ValueError as e:
+                e.args = ("x and y must be both numeric types "
+                          "but got {}, {} instead".format(type(x), type(y)), )
+                raise
+
+        self.x = x
+        self.y = y
+
+    def __eq__(self, other):
+        return self.x == other.x and self.y == other.y
+
+    def __ne__(self, other):
+        return not self == other
+
+    def __gt__(self, other):
+        if self.x > other.x:
+            return True
+        elif self.x == other.x:
+            return self.y > other.y
+        return False
+
+    def __lt__(self, other):
+        return not self > other
+
+    def __ge__(self, other):
+        if self.x > other.x:
+            return True
+        elif self.x == other.x:
+            return self.y >= other.y
+        return False
+
+    def __le__(self, other):
+        if self.x < other.x:
+            return True
+        elif self.x == other.x:
+            return self.y <= other.y
+        return False
+
+    def __repr__(self):
+        return "({}, {})".format(self.x,  self.y)
+
+    def __hash__(self):
+        return hash(self.x)
+
+
+def _construct_points(list_of_tuples):
+    """
+    constructs a list of points from an array-like object of numbers
+
+    Arguments
+    ---------
+
+    list_of_tuples: array-like object of type numbers. Acceptable types so far
+    are lists, tuples and sets.
+
+    Returns
+    --------
+    points: a list where each item is of type Point. This contains only objects
+    which can be converted into a Point.
+
+    Examples
+    -------
+    >>> _construct_points([[1, 1], [2, -1], [0.3, 4]])
+    [(1, 1), (2, -1), (0.3, 4)]
+    >>> _construct_points(([1, 1], [2, -1], [0.3, 4]))
+    [(1, 1), (2, -1), (0.3, 4)]
+    >>> _construct_points([(1, 1), (2, -1), (0.3, 4)])
+    [(1, 1), (2, -1), (0.3, 4)]
+    >>> _construct_points([[1, 1], (2, -1), [0.3, 4]])
+    [(1, 1), (2, -1), (0.3, 4)]
+    >>> _construct_points([1, 2])
+    Ignoring deformed point 1. All points must have at least 2 coordinates.
+    Ignoring deformed point 2. All points must have at least 2 coordinates.
+    []
+    >>> _construct_points([])
+    []
+    >>> _construct_points(None)
+    []
+    """
+
+    points = []
+    if list_of_tuples:
+        for p in list_of_tuples:
+            try:
+                points.append(Point(p[0], p[1]))
+            except (IndexError, TypeError):
+                print("Ignoring deformed point {}. All points"
+                      " must have at least 2 coordinates.".format(p))
+    return points
+
+
+def _validate_input(points):
+    """
+    validates an input instance before a convex-hull algorithms uses it
+
+    Parameters
+    ---------
+    points: array-like, the 2d points to validate before using with
+    a convex-hull algorithm. The elements of points must be either lists, tuples or
+    Points.
+
+    Returns
+    -------
+    points: array_like, an iterable of all well-defined Points constructed passed in.
+
+
+    Exception
+    ---------
+    ValueError: if points is empty or None, or if a wrong data structure like a scalar is passed
+
+    TypeError: if an iterable but non-indexable object (eg. dictionary) is passed.
+                The exception to this a set which we'll convert to a list before using
+
+
+    Examples
+    -------
+    >>> _validate_input([[1, 2]])
+    [(1, 2)]
+    >>> _validate_input([(1, 2)])
+    [(1, 2)]
+    >>> _validate_input([Point(2, 1), Point(-1, 2)])
+    [(2, 1), (-1, 2)]
+    >>> _validate_input([])
+    Traceback (most recent call last):
+        ...
+    ValueError: Expecting a list of points but got []
+    >>> _validate_input(1)
+    Traceback (most recent call last):
+        ...
+    ValueError: Expecting an iterable object but got an non-iterable type 1
+    """
+
+    if not points:
+        raise ValueError("Expecting a list of points but got {}".format(points))
+
+    if isinstance(points, set):
+        points = list(points)
+
+    try:
+        if hasattr(points, "__iter__") and not isinstance(points[0], Point):
+            if isinstance(points[0], (list, tuple)):
+                points = _construct_points(points)
+            else:
+                raise ValueError("Expecting an iterable of type Point, list or tuple. "
+                                 "Found objects of type {} instead"
+                                 .format(["point", "list", "tuple"], type(points[0])))
+        elif not hasattr(points, "__iter__"):
+            raise ValueError("Expecting an iterable object "
+                             "but got an non-iterable type {}".format(points))
+    except TypeError as e:
+        print("Expecting an iterable of type Point, list or tuple.")
+        raise
+
+    return points
+
+
+def _det(a, b, c):
+    """
+    Computes the sign perpendicular distance of a 2d point c from a line segment
+    ab. The sign indicates the direction of c relative to ab.
+    A Positive value means c is above ab (to the left), while a negative value
+    means c is below ab (to the right). 0 means all three points are on a straight line.
+
+    As a side note, 0.5 * abs|det| is the area of triangle abc
+
+    Parameters
+    ----------
+    a: point, the point on the left end of line segment ab
+    b: point, the point on the right end of line segment ab
+    c: point, the point for which the direction and location is desired.
+
+    Returns
+    --------
+    det: float, abs(det) is the distance of c from ab. The sign
+    indicates which side of line segment ab c is. det is computed as
+    (a_xb_y + c_xa_y + b_xc_y) - (a_yb_x + c_ya_x + b_yc_x)
+
+    Examples
+    ----------
+    >>> _det(Point(1, 1), Point(1, 2), Point(1, 5))
+    0
+    >>> _det(Point(0, 0), Point(10, 0), Point(0, 10))
+    100
+    >>> _det(Point(0, 0), Point(10, 0), Point(0, -10))
+    -100
+    """
+
+    det = (a.x * b.y + b.x * c.y + c.x * a.y) - (a.y * b.x + b.y * c.x + c.y * a.x)
+    return det
+
+
+def convex_hull_bf(points):
+    """
+    Constructs the convex hull of a set of 2D points using a brute force algorithm.
+    The algorithm basically considers all combinations of points (i, j) and uses the
+    definition of convexity to determine whether (i, j) is part of the convex hull or not.
+    (i, j) is part of the convex hull if and only iff there are no points on both sides
+    of the line segment connecting the ij, and there is no point k such that k is on either end
+    of the ij.
+
+    Runtime: O(n^3) - definitely horrible
+
+    Parameters
+    ---------
+    points: array-like of object of Points, lists or tuples.
+    The set of  2d points for which the convex-hull is needed
+
+    Returns
+    ------
+    convex_set: list, the convex-hull of points sorted in non-decreasing order.
+
+    See Also
+    --------
+    convex_hull_recursive,
+
+     Examples
+     ---------
+     >>> convex_hull_bf([[0, 0], [1, 0], [10, 1]])
+     [(0, 0), (1, 0), (10, 1)]
+     >>> convex_hull_bf([[0, 0], [1, 0], [10, 0]])
+     [(0, 0), (10, 0)]
+     >>> convex_hull_bf([[-1, 1],[-1, -1], [0, 0], [0.5, 0.5], [1, -1], [1, 1], [-0.75, 1]])
+     [(-1, -1), (-1, 1), (1, -1), (1, 1)]
+     >>> convex_hull_bf([(0, 3), (2, 2), (1, 1), (2, 1), (3, 0), (0, 0), (3, 3), (2, -1), (2, -4), (1, -3)])
+     [(0, 0), (0, 3), (1, -3), (2, -4), (3, 0), (3, 3)]
+    """
+
+    points = sorted(_validate_input(points))
+    n = len(points)
+    convex_set = set()
+
+    for i in range(n-1):
+        for j in range(i + 1, n):
+            points_left_of_ij = points_right_of_ij = False
+            ij_part_of_convex_hull = True
+            for k in range(n):
+                if k != i and k != j:
+                    det_k = _det(points[i], points[j], points[k])
+
+                    if det_k > 0:
+                        points_left_of_ij = True
+                    elif det_k < 0:
+                        points_right_of_ij = True
+                    else:
+                        # point[i], point[j], point[k] all lie on a straight line
+                        # if point[k] is to the left of point[i] or it's to the
+                        # right of point[j], then point[i], point[j] cannot be
+                        # part of the convex hull of A
+                        if points[k] < points[i] or points[k] > points[j]:
+                            ij_part_of_convex_hull = False
+                            break
+
+                if points_left_of_ij and points_right_of_ij:
+                    ij_part_of_convex_hull = False
+                    break
+
+            if ij_part_of_convex_hull:
+                convex_set.update([points[i], points[j]])
+
+    return sorted(convex_set)
+
+
+def convex_hull_recursive(points):
+    """
+    Constructs the convex hull of a set of 2D points using a divide-and-conquer strategy
+    The algorithm exploits the geometric properties of the problem by repeatedly partitioning
+    the set of points into smaller hulls, and finding the convex hull of these smaller hulls.
+    The union of the convex hull from smaller hulls is the solution to the convex hull of the larger problem.
+
+    Parameter
+    ---------
+    points: array-like of object of Points, lists or tuples.
+    The set of  2d points for which the convex-hull is needed
+
+    Runtime: O(n log n)
+
+    Returns
+    -------
+    convex_set: list, the convex-hull of points sorted in non-decreasing order.
+
+    Examples
+    ---------
+    >>> convex_hull_recursive([[0, 0], [1, 0], [10, 1]])
+    [(0, 0), (1, 0), (10, 1)]
+    >>> convex_hull_recursive([[0, 0], [1, 0], [10, 0]])
+    [(0, 0), (10, 0)]
+    >>> convex_hull_recursive([[-1, 1],[-1, -1], [0, 0], [0.5, 0.5], [1, -1], [1, 1], [-0.75, 1]])
+    [(-1, -1), (-1, 1), (1, -1), (1, 1)]
+    >>> convex_hull_recursive([(0, 3), (2, 2), (1, 1), (2, 1), (3, 0), (0, 0), (3, 3), (2, -1), (2, -4), (1, -3)])
+    [(0, 0), (0, 3), (1, -3), (2, -4), (3, 0), (3, 3)]
+
+    """
+    points = sorted(_validate_input(points))
+    n = len(points)
+
+    # divide all the points into an upper hull and a lower hull
+    # the left most point and the right most point are definitely
+    # members of the convex hull by definition.
+    # use these two anchors to divide all the points into two hulls,
+    # an upper hull and a lower hull.
+
+    # all points to the left (above) the line joining the extreme points belong to the upper hull
+    # all points to the right (below) the line joining the extreme points below to the lower hull
+    # ignore all points on the line joining the extreme points since they cannot be part of the
+    # convex hull
+
+    left_most_point = points[0]
+    right_most_point = points[n-1]
+
+    convex_set = {left_most_point, right_most_point}
+    upperhull = []
+    lowerhull = []
+
+    for i in range(1, n-1):
+        det = _det(left_most_point, right_most_point, points[i])
+
+        if det > 0:
+            upperhull.append(points[i])
+        elif det < 0:
+            lowerhull.append(points[i])
+
+    _construct_hull(upperhull, left_most_point, right_most_point, convex_set)
+    _construct_hull(lowerhull, right_most_point, left_most_point, convex_set)
+
+    return sorted(convex_set)
+
+
+def _construct_hull(points, left, right, convex_set):
+    """
+
+    Parameters
+    ---------
+    points: list or None, the hull of points from which to choose the next convex-hull point
+    left: Point, the point to the left  of line segment joining left and right
+    right: The point to the right of the line segment joining left and right
+    convex_set: set, the current convex-hull. The state of convex-set gets updated by this function
+
+    Note
+    ----
+    For the line segment 'ab', 'a' is on the left and 'b' on the right.
+    but the reverse is true for the line segment 'ba'.
+
+    Returns
+    -------
+    Nothing, only updates the state of convex-set
+    """
+    if points:
+        extreme_point = None
+        extreme_point_distance = float('-inf')
+        candidate_points = []
+
+        for p in points:
+            det = _det(left, right, p)
+
+            if det > 0:
+                candidate_points.append(p)
+
+                if det > extreme_point_distance:
+                    extreme_point_distance = det
+                    extreme_point = p
+
+        if extreme_point:
+            _construct_hull(candidate_points, left, extreme_point, convex_set)
+            convex_set.add(extreme_point)
+            _construct_hull(candidate_points, extreme_point, right, convex_set)
+
+
+def main():
+    points = [(0, 3), (2, 2), (1, 1), (2, 1), (3, 0),
+              (0, 0), (3, 3), (2, -1), (2, -4), (1, -3)]
+    # the convex set of points is
+    # [(0, 0), (0, 3), (1, -3), (2, -4), (3, 0), (3, 3)]
+    results_recursive = convex_hull_recursive(points)
+    results_bf = convex_hull_bf(points)
+    assert results_bf == results_recursive
+
+    print(results_bf)
+
+
+if __name__ == '__main__':
+    main()

From 5d46a4dd7beeeeb27f393b972effe785feab7306 Mon Sep 17 00:00:00 2001
From: Maxwell Aladago <maxwell.aladago@gmail.com>
Date: Mon, 19 Aug 2019 01:39:39 -0400
Subject: [PATCH 190/348] ENH: Added a functionality to make it possible to
 reconstruct an optimal subset for the dynamic programming problem (#1139)

* function for the knapsack problem which returns one of the optimal subsets

* function for the knapsack problem which returns one of the optimal subsets

* function for the knapsack problem which returns one of the optimal subsets

* function for the knapsack problem which returns one of the optimal subsets

* function for the knapsack problem which returns one of the optimal subsets

* some pep8 cleanup too
---
 dynamic_programming/knapsack.py | 131 ++++++++++++++++++++++++++++----
 1 file changed, 116 insertions(+), 15 deletions(-)

diff --git a/dynamic_programming/knapsack.py b/dynamic_programming/knapsack.py
index 27d1cfed799b..488059d6244d 100644
--- a/dynamic_programming/knapsack.py
+++ b/dynamic_programming/knapsack.py
@@ -1,7 +1,13 @@
 """
-Given weights and values of n items, put these items in a knapsack of capacity W to get the maximum total value in the knapsack.
+Given weights and values of n items, put these items in a knapsack of
+ capacity W to get the maximum total value in the knapsack.
+
+Note that only the integer weights 0-1 knapsack problem is solvable
+ using dynamic programming.
 """
-def MF_knapsack(i,wt,val,j):
+
+
+def MF_knapsack(i, wt, val, j):
     '''
     This code involves the concept of memory functions. Here we solve the subproblems which are needed
     unlike the below example
@@ -9,34 +15,129 @@ def MF_knapsack(i,wt,val,j):
     '''
     global F  # a global dp table for knapsack
     if F[i][j] < 0:
-        if j < wt[i - 1]:
-            val = MF_knapsack(i - 1,wt,val,j)
+        if j < wt[i-1]:
+            val = MF_knapsack(i-1, wt, val, j)
         else:
-            val = max(MF_knapsack(i - 1,wt,val,j),MF_knapsack(i - 1,wt,val,j - wt[i - 1]) + val[i - 1])
+            val = max(MF_knapsack(i-1, wt, val, j),
+                      MF_knapsack(i-1, wt, val, j - wt[i-1]) + val[i-1])
         F[i][j] = val
     return F[i][j]
 
+
 def knapsack(W, wt, val, n):
     dp = [[0 for i in range(W+1)]for j in range(n+1)]
 
     for i in range(1,n+1):
-        for w in range(1,W+1):
-            if(wt[i-1]<=w):
-                dp[i][w] = max(val[i-1]+dp[i-1][w-wt[i-1]],dp[i-1][w])
+        for w in range(1, W+1):
+            if wt[i-1] <= w:
+                dp[i][w] = max(val[i-1] + dp[i-1][w-wt[i-1]], dp[i-1][w])
             else:
                 dp[i][w] = dp[i-1][w]
 
-    return dp[n][w]
+    return dp[n][W], dp
+
+
+def knapsack_with_example_solution(W: int, wt: list, val:list):
+    """
+    Solves the integer weights knapsack problem returns one of
+    the several possible optimal subsets.
+
+    Parameters
+    ---------
+
+    W: int, the total maximum weight for the given knapsack problem.
+    wt: list, the vector of weights for all items where wt[i] is the weight
+    of the ith item.
+    val: list, the vector of values for all items where val[i] is the value
+    of te ith item
+
+    Returns
+    -------
+    optimal_val: float, the optimal value for the given knapsack problem
+    example_optional_set: set, the indices of one of the optimal subsets
+    which gave rise to the optimal value.
+
+    Examples
+    -------
+    >>> knapsack_with_example_solution(10, [1, 3, 5, 2], [10, 20, 100, 22])
+    (142, {2, 3, 4})
+    >>> knapsack_with_example_solution(6, [4, 3, 2, 3], [3, 2, 4, 4])
+    (8, {3, 4})
+    >>> knapsack_with_example_solution(6, [4, 3, 2, 3], [3, 2, 4])
+    Traceback (most recent call last):
+        ...
+    ValueError: The number of weights must be the same as the number of values.
+    But got 4 weights and 3 values
+    """
+    if not (isinstance(wt, (list, tuple)) and isinstance(val, (list, tuple))):
+        raise ValueError("Both the weights and values vectors must be either lists or tuples")
+
+    num_items = len(wt)
+    if num_items != len(val):
+        raise ValueError("The number of weights must be the "
+                         "same as the number of values.\nBut "
+                         "got {} weights and {} values".format(num_items, len(val)))
+    for i in range(num_items):
+        if not isinstance(wt[i], int):
+            raise TypeError("All weights must be integers but "
+                            "got weight of type {} at index {}".format(type(wt[i]), i))
+
+    optimal_val, dp_table = knapsack(W, wt, val, num_items)
+    example_optional_set = set()
+    _construct_solution(dp_table, wt, num_items, W, example_optional_set)
+
+    return optimal_val, example_optional_set
+
+
+def _construct_solution(dp:list, wt:list, i:int, j:int, optimal_set:set):
+    """
+    Recursively reconstructs one of the optimal subsets given
+    a filled DP table and the vector of weights
+
+    Parameters
+    ---------
+
+    dp: list of list, the table of a solved integer weight dynamic programming problem
+
+    wt: list or tuple, the vector of weights of the items
+    i: int, the index of the  item under consideration
+    j: int, the current possible maximum weight
+    optimal_set: set, the optimal subset so far. This gets modified by the function.
+
+    Returns
+    -------
+    None
+
+    """
+    # for the current item i at a maximum weight j to be part of an optimal subset,
+    # the optimal value at (i, j) must be greater than the optimal value at (i-1, j).
+    # where i - 1 means considering only the previous items at the given maximum weight
+    if i > 0 and j > 0:
+        if dp[i - 1][j] == dp[i][j]:
+            _construct_solution(dp, wt, i - 1, j, optimal_set)
+        else:
+            optimal_set.add(i)
+            _construct_solution(dp, wt, i - 1, j - wt[i-1], optimal_set)
+
 
 if __name__ == '__main__':
     '''
     Adding test case for knapsack
     '''
-    val = [3,2,4,4]
-    wt = [4,3,2,3]
+    val = [3, 2, 4, 4]
+    wt = [4, 3, 2, 3]
     n = 4
     w = 6
-    F = [[0]*(w + 1)] + [[0] + [-1 for i in range(w + 1)] for j in range(n + 1)]
-    print(knapsack(w,wt,val,n))
-    print(MF_knapsack(n,wt,val,w))  # switched the n and w 
-    
+    F = [[0] * (w + 1)] + [[0] + [-1 for i in range(w + 1)] for j in range(n + 1)]
+    optimal_solution, _ = knapsack(w,wt,val, n)
+    print(optimal_solution)
+    print(MF_knapsack(n,wt,val,w))  # switched the n and w
+
+    # testing the dynamic programming problem with example
+    # the optimal subset for the above example are items 3 and 4
+    optimal_solution, optimal_subset = knapsack_with_example_solution(w, wt, val)
+    assert optimal_solution == 8
+    assert optimal_subset == {3, 4}
+    print("optimal_value = ", optimal_solution)
+    print("An optimal subset corresponding to the optimal value", optimal_subset)
+

From 32aa7ff0819dba3d2166b8a66317999a7790e510 Mon Sep 17 00:00:00 2001
From: Maxwell Aladago <maxwell.aladago@gmail.com>
Date: Mon, 19 Aug 2019 03:40:36 -0400
Subject: [PATCH 191/348] ENH: refactored longest common subsequence, also
 fixed a bug with the sequence returned (#1142)

* function for the knapsack problem which returns one of the optimal subsets

* function for the knapsack problem which returns one of the optimal subsets

* function for the knapsack problem which returns one of the optimal subsets

* function for the knapsack problem which returns one of the optimal subsets

* function for the knapsack problem which returns one of the optimal subsets

* some pep8 cleanup too

* ENH: refactored longest common subsequence, also fixed a bug with the sequence returned

* renamed function
---
 .../longest_common_subsequence.py             | 90 ++++++++++++++-----
 1 file changed, 68 insertions(+), 22 deletions(-)

diff --git a/dynamic_programming/longest_common_subsequence.py b/dynamic_programming/longest_common_subsequence.py
index 0a4771cb2efd..7836fe303688 100644
--- a/dynamic_programming/longest_common_subsequence.py
+++ b/dynamic_programming/longest_common_subsequence.py
@@ -1,37 +1,83 @@
 """
 LCS Problem Statement: Given two sequences, find the length of longest subsequence present in both of them.
-A subsequence is a sequence that appears in the same relative order, but not necessarily continious.
+A subsequence is a sequence that appears in the same relative order, but not necessarily continuous.
 Example:"abc", "abg" are subsequences of "abcdefgh".
 """
 from __future__ import print_function
 
-try:
-    xrange          # Python 2
-except NameError:
-    xrange = range  # Python 3
 
-def lcs_dp(x, y):
+def longest_common_subsequence(x: str, y: str):
+    """
+    Finds the longest common subsequence between two strings. Also returns the
+    The subsequence found
+
+    Parameters
+    ----------
+
+    x: str, one of the strings
+    y: str, the other string
+
+    Returns
+    -------
+    L[m][n]: int, the length of the longest subsequence. Also equal to len(seq)
+    Seq: str, the subsequence found
+
+    >>> longest_common_subsequence("programming", "gaming")
+    (6, 'gaming')
+    >>> longest_common_subsequence("physics", "smartphone")
+    (2, 'ph')
+    >>> longest_common_subsequence("computer", "food")
+    (1, 'o')
+    """
     # find the length of strings
+
+    assert x is not None
+    assert y is not None
+
     m = len(x)
     n = len(y)
 
     # declaring the array for storing the dp values
-    L = [[None] * (n + 1) for i in xrange(m + 1)]
-    seq = []
-
-    for i in range(m + 1):
-        for j in range(n + 1):
-            if i == 0 or j == 0:
-                L[i][j] = 0
-            elif x[i - 1] == y[ j - 1]:
-                L[i][j] = L[i - 1][j - 1] + 1
-                seq.append(x[i -1])
+    L = [[0] * (n + 1) for _ in range(m + 1)]
+
+    for i in range(1, m + 1):
+        for j in range(1, n + 1):
+            if x[i-1] == y[j-1]:
+                match = 1
             else:
-                L[i][j] = max(L[i - 1][j], L[i][j - 1])
-    # L[m][n] contains the length of LCS of X[0..n-1] & Y[0..m-1]
+                match = 0
+
+            L[i][j] = max(L[i-1][j], L[i][j-1], L[i-1][j-1] + match)
+
+    seq = ""
+    i, j = m, n
+    while i > 0 and i > 0:
+        if x[i - 1] == y[j - 1]:
+            match = 1
+        else:
+            match = 0
+
+        if L[i][j] == L[i - 1][j - 1] + match:
+            if match == 1:
+                seq = x[i - 1] + seq
+            i -= 1
+            j -= 1
+        elif L[i][j] == L[i - 1][j]:
+            i -= 1
+        else:
+            j -= 1
+
     return L[m][n], seq
 
-if __name__=='__main__':
-    x = 'AGGTAB'
-    y = 'GXTXAYB'
-    print(lcs_dp(x, y))
+
+if __name__ == '__main__':
+    a = 'AGGTAB'
+    b = 'GXTXAYB'
+    expected_ln = 4
+    expected_subseq = "GTAB"
+
+    ln, subseq = longest_common_subsequence(a, b)
+    assert expected_ln == ln
+    assert expected_subseq == subseq
+    print("len =", ln, ", sub-sequence =", subseq)
+

From 47a9ea2b0b4eaef3e748d4d61763a77abc3e48cb Mon Sep 17 00:00:00 2001
From: Christian Clauss <cclauss@me.com>
Date: Mon, 19 Aug 2019 15:37:49 +0200
Subject: [PATCH 192/348] Simplify code by dropping support for legacy Python
 (#1143)

* Simplify code by dropping support for legacy Python

* sort() --> sorted()
---
 CONTRIBUTING.md                               | 20 +++---
 ciphers/affine_cipher.py                      |  1 -
 ciphers/atbash.py                             | 20 ++----
 ciphers/brute_force_caesar_cipher.py          |  1 -
 ciphers/onepad_cipher.py                      |  4 +-
 ciphers/rabin_miller.py                       |  1 -
 ciphers/rot13.py                              |  1 -
 ciphers/rsa_cipher.py                         |  3 +-
 ciphers/rsa_key_generator.py                  |  1 -
 ciphers/simple_substitution_cipher.py         |  5 +-
 ciphers/transposition_cipher.py               |  1 -
 ...ansposition_cipher_encrypt_decrypt_file.py |  7 +-
 ciphers/vigenere_cipher.py                    |  1 -
 .../binary_tree/binary_search_tree.py         | 15 ++--
 data_structures/binary_tree/fenwick_tree.py   |  1 -
 .../binary_tree/lazy_segment_tree.py          |  1 -
 data_structures/binary_tree/segment_tree.py   |  1 -
 data_structures/heap/heap.py                  | 13 +---
 .../linked_list/doubly_linked_list.py         | 27 ++++---
 .../linked_list/singly_linked_list.py         | 13 ++--
 data_structures/queue/double_ended_queue.py   |  1 -
 .../stacks/balanced_parentheses.py            |  3 -
 .../stacks/infix_to_postfix_conversion.py     |  2 -
 .../stacks/next_greater_element.py            |  9 ++-
 data_structures/stacks/stack.py               |  1 -
 data_structures/stacks/stock_span_problem.py  |  1 -
 divide_and_conquer/convex_hull.py             | 12 ++--
 divide_and_conquer/inversions.py              | 14 ++--
 dynamic_programming/bitmask.py                | 35 +++++----
 dynamic_programming/coin_change.py            |  3 -
 dynamic_programming/edit_distance.py          | 23 ++----
 dynamic_programming/fast_fibonacci.py         |  1 -
 dynamic_programming/fibonacci.py              | 14 ++--
 dynamic_programming/integer_partition.py      | 22 ++----
 .../longest_common_subsequence.py             |  2 -
 .../longest_increasing_subsequence.py         |  4 +-
 ...longest_increasing_subsequence_o(nlogn).py | 21 +++---
 dynamic_programming/longest_sub_array.py      |  1 -
 dynamic_programming/matrix_chain_order.py     |  2 -
 dynamic_programming/max_sub_array.py          | 23 +++---
 graphs/a_star.py                              | 16 ++---
 graphs/basic_graphs.py                        | 53 ++++++--------
 graphs/bellman_ford.py                        |  2 -
 graphs/breadth_first_search.py                |  2 -
 graphs/depth_first_search.py                  |  1 -
 graphs/dijkstra_2.py                          |  2 -
 graphs/dijkstra_algorithm.py                  |  1 -
 graphs/even_tree.py                           |  1 -
 graphs/graph_list.py                          |  1 -
 graphs/graph_matrix.py                        |  3 -
 graphs/graphs_floyd_warshall.py               |  8 +--
 graphs/minimum_spanning_tree_kruskal.py       |  2 -
 graphs/multi_hueristic_astar.py               |  8 +--
 graphs/scc_kosaraju.py                        |  3 -
 hashes/chaos_machine.py                       |  8 +--
 hashes/enigma_machine.py                      |  2 -
 hashes/md5.py                                 |  5 +-
 machine_learning/decision_tree.py             | 10 ++-
 machine_learning/gradient_descent.py          |  1 -
 machine_learning/k_means_clust.py             | 71 +++++++++----------
 machine_learning/linear_regression.py         |  2 -
 maths/simpson_rule.py                         |  3 -
 maths/trapezoidal_rule.py                     |  4 +-
 maths/zellers_congruence.py                   |  5 +-
 ...h_fibonacci_using_matrix_exponentiation.py |  3 -
 neural_network/convolution_neural_network.py  |  2 -
 neural_network/perceptron.py                  |  2 -
 other/anagrams.py                             |  1 -
 other/euclidean_gcd.py                        |  1 -
 other/linear_congruential_generator.py        |  7 +-
 other/nested_brackets.py                      |  3 -
 other/password_generator.py                   |  1 -
 other/tower_of_hanoi.py                       |  3 +-
 other/two_sum.py                              |  4 +-
 other/word_patterns.py                        |  1 -
 project_euler/problem_01/sol1.py              | 12 +---
 project_euler/problem_01/sol2.py              | 10 +--
 project_euler/problem_01/sol3.py              | 12 +---
 project_euler/problem_01/sol4.py              | 12 +---
 project_euler/problem_01/sol5.py              | 10 +--
 project_euler/problem_01/sol6.py              | 12 +---
 project_euler/problem_02/sol1.py              | 12 +---
 project_euler/problem_02/sol2.py              | 12 +---
 project_euler/problem_02/sol3.py              | 12 +---
 project_euler/problem_02/sol4.py              | 10 +--
 project_euler/problem_03/sol1.py              |  8 +--
 project_euler/problem_03/sol2.py              |  8 +--
 project_euler/problem_04/sol1.py              | 12 +---
 project_euler/problem_04/sol2.py              | 12 +---
 project_euler/problem_05/sol1.py              | 10 +--
 project_euler/problem_05/sol2.py              | 11 +--
 project_euler/problem_06/sol1.py              | 12 +---
 project_euler/problem_06/sol2.py              | 12 +---
 project_euler/problem_06/sol3.py              | 10 +--
 project_euler/problem_07/sol1.py              | 10 +--
 project_euler/problem_07/sol2.py              | 12 +---
 project_euler/problem_07/sol3.py              | 10 +--
 project_euler/problem_09/sol1.py              |  3 +-
 project_euler/problem_09/sol2.py              | 12 +---
 project_euler/problem_09/sol3.py              |  3 -
 project_euler/problem_10/sol1.py              | 19 ++---
 project_euler/problem_10/sol2.py              | 10 +--
 project_euler/problem_11/sol1.py              | 14 ++--
 project_euler/problem_11/sol2.py              | 26 +++----
 project_euler/problem_12/sol1.py              | 10 +--
 project_euler/problem_12/sol2.py              |  5 +-
 project_euler/problem_14/sol1.py              | 12 +---
 project_euler/problem_14/sol2.py              | 10 +--
 project_euler/problem_21/sol1.py              |  8 +--
 project_euler/problem_22/sol1.py              |  6 --
 project_euler/problem_25/sol1.py              |  8 +--
 project_euler/problem_28/sol1.py              |  7 +-
 project_euler/problem_29/solution.py          |  5 +-
 project_euler/problem_31/sol1.py              |  8 ---
 project_euler/problem_36/sol1.py              |  8 +--
 project_euler/problem_40/sol1.py              |  5 +-
 project_euler/problem_48/sol1.py              |  7 +-
 project_euler/problem_53/sol1.py              | 10 +--
 project_euler/problem_76/sol1.py              | 14 ++--
 searches/binary_search.py                     | 14 ++--
 searches/interpolation_search.py              | 24 +++----
 searches/jump_search.py                       |  1 -
 searches/linear_search.py                     |  9 +--
 searches/sentinel_linear_search.py            |  9 +--
 searches/ternary_search.py                    | 29 +++-----
 sorts/bogo_sort.py                            |  8 +--
 sorts/bubble_sort.py                          | 19 +++--
 sorts/cocktail_shaker_sort.py                 | 15 ++--
 sorts/comb_sort.py                            |  7 +-
 sorts/counting_sort.py                        | 13 ++--
 sorts/cycle_sort.py                           | 10 +--
 sorts/gnome_sort.py                           |  9 +--
 sorts/heap_sort.py                            | 10 +--
 sorts/insertion_sort.py                       | 10 +--
 sorts/merge_sort.py                           | 10 +--
 sorts/merge_sort_fastest.py                   | 10 +--
 sorts/pigeon_sort.py                          | 10 +--
 sorts/quick_sort.py                           | 10 +--
 sorts/quick_sort_3_partition.py               |  9 +--
 sorts/random_normal_distribution_quicksort.py | 22 +++---
 sorts/selection_sort.py                       | 10 +--
 sorts/shell_sort.py                           | 10 +--
 sorts/topological_sort.py                     |  1 -
 strings/levenshtein_distance.py               |  9 +--
 strings/min_cost_string_conversion.py         | 31 ++++----
 145 files changed, 367 insertions(+), 976 deletions(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 3202b817f1c5..8c0f54ad528d 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -56,7 +56,7 @@ We want your work to be readable by others; therefore, we encourage you to note
 
   ```python
       """
-  	This function sums a and b    
+  	This function sums a and b
   """
   def sum(a, b):
       return a + b
@@ -82,13 +82,13 @@ We want your work to be readable by others; therefore, we encourage you to note
   The following "testing" approaches are **not** encouraged:
 
   ```python
-  input('Enter your input:') 
+  input('Enter your input:')
   # Or even worse...
-  input = eval(raw_input("Enter your input: "))
+  input = eval(input("Enter your input: "))
   ```
-  
+
   However, if your code uses __input()__ then we encourage you to gracefully deal with leading and trailing whitespace in user input by adding __.strip()__ to the end as in:
-  
+
   ```python
   starting_value = int(input("Please enter a starting value: ").strip())
   ```
@@ -99,13 +99,13 @@ We want your work to be readable by others; therefore, we encourage you to note
   def sumab(a, b):
       return a + b
   # Write tests this way:
-  print(sumab(1,2))	# 1+2 = 3
-  print(sumab(6,4))	# 6+4 = 10
+  print(sumab(1, 2))	# 1+2 = 3
+  print(sumab(6, 4))	# 6+4 = 10
   # Or this way:
-  print("1 + 2 = ", sumab(1,2))	# 1+2 = 3
-  print("6 + 4 = ", sumab(6,4))	# 6+4 = 10
+  print("1 + 2 = ", sumab(1, 2))	# 1+2 = 3
+  print("6 + 4 = ", sumab(6, 4))	# 6+4 = 10
   ```
-  
+
   Better yet, if you know how to write [__doctests__](https://docs.python.org/3/library/doctest.html), please consider adding them.
 
 - Avoid importing external libraries for basic algorithms. Only use those libraries for complicated algorithms.
diff --git a/ciphers/affine_cipher.py b/ciphers/affine_cipher.py
index af5f4e0ff4c6..a5d94f087dbf 100644
--- a/ciphers/affine_cipher.py
+++ b/ciphers/affine_cipher.py
@@ -1,4 +1,3 @@
-from __future__ import print_function
 import sys, random, cryptomath_module as cryptoMath
 
 SYMBOLS = r""" !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~"""
diff --git a/ciphers/atbash.py b/ciphers/atbash.py
index 5653f0213745..9ed47e0874f8 100644
--- a/ciphers/atbash.py
+++ b/ciphers/atbash.py
@@ -1,23 +1,15 @@
-try:               # Python 2
-    raw_input
-    unichr
-except NameError:  # Python 3
-    raw_input = input
-    unichr = chr
-
-
-def Atbash():
+def atbash():
     output=""
-    for i in raw_input("Enter the sentence to be encrypted ").strip():
+    for i in input("Enter the sentence to be encrypted ").strip():
         extract = ord(i)
         if 65 <= extract <= 90:
-            output += unichr(155-extract)
+            output += chr(155-extract)
         elif 97 <= extract <= 122:
-            output += unichr(219-extract)
+            output += chr(219-extract)
         else:
-            output+=i
+            output += i
     print(output)
 
 
 if __name__ == '__main__':
-    Atbash()
+    atbash()
diff --git a/ciphers/brute_force_caesar_cipher.py b/ciphers/brute_force_caesar_cipher.py
index 3b0716442fc5..3e6e975c8297 100644
--- a/ciphers/brute_force_caesar_cipher.py
+++ b/ciphers/brute_force_caesar_cipher.py
@@ -1,4 +1,3 @@
-from __future__ import print_function
 def decrypt(message):
     """
     >>> decrypt('TMDETUX PMDVU')
diff --git a/ciphers/onepad_cipher.py b/ciphers/onepad_cipher.py
index 6afbd45249ec..1dac270bda1f 100644
--- a/ciphers/onepad_cipher.py
+++ b/ciphers/onepad_cipher.py
@@ -1,5 +1,3 @@
-from __future__ import print_function
-
 import random
 
 
@@ -15,7 +13,7 @@ def encrypt(self, text):
             cipher.append(c)
             key.append(k)
         return cipher, key
-    
+
     def decrypt(self, cipher, key):
         '''Function to decrypt text using psedo-random numbers.'''
         plain = []
diff --git a/ciphers/rabin_miller.py b/ciphers/rabin_miller.py
index f71fb03c0051..21378cff6885 100644
--- a/ciphers/rabin_miller.py
+++ b/ciphers/rabin_miller.py
@@ -1,4 +1,3 @@
-from __future__ import print_function
 # Primality Testing with the Rabin-Miller Algorithm
 
 import random
diff --git a/ciphers/rot13.py b/ciphers/rot13.py
index 2abf981e9d7d..208de4890e67 100644
--- a/ciphers/rot13.py
+++ b/ciphers/rot13.py
@@ -1,4 +1,3 @@
-from __future__ import print_function
 def dencrypt(s, n):
     out = ''
     for c in s:
diff --git a/ciphers/rsa_cipher.py b/ciphers/rsa_cipher.py
index d81f1ffc1a1e..02e5d95d1e95 100644
--- a/ciphers/rsa_cipher.py
+++ b/ciphers/rsa_cipher.py
@@ -1,4 +1,3 @@
-from __future__ import print_function
 import sys, rsa_key_generator as rkg, os
 
 DEFAULT_BLOCK_SIZE = 128
@@ -16,7 +15,7 @@ def main():
     if mode == 'encrypt':
         if not os.path.exists('rsa_pubkey.txt'):
             rkg.makeKeyFiles('rsa', 1024)
-            
+
         message = input('\nEnter message: ')
         pubKeyFilename = 'rsa_pubkey.txt'
         print('Encrypting and writing to %s...' % (filename))
diff --git a/ciphers/rsa_key_generator.py b/ciphers/rsa_key_generator.py
index 541e90d6e884..7cd7163b68d5 100644
--- a/ciphers/rsa_key_generator.py
+++ b/ciphers/rsa_key_generator.py
@@ -1,4 +1,3 @@
-from __future__ import print_function
 import random, sys, os
 import rabin_miller as rabinMiller, cryptomath_module as cryptoMath
 
diff --git a/ciphers/simple_substitution_cipher.py b/ciphers/simple_substitution_cipher.py
index 1bdd7dc04a57..5da07f8526b9 100644
--- a/ciphers/simple_substitution_cipher.py
+++ b/ciphers/simple_substitution_cipher.py
@@ -1,4 +1,3 @@
-from __future__ import print_function
 import sys, random
 
 LETTERS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
@@ -18,7 +17,7 @@ def main():
         translated = decryptMessage(key, message)
 
     print('\n%sion: \n%s' % (mode.title(), translated))
-    
+
 def checkValidKey(key):
     keyList = list(key)
     lettersList = list(LETTERS)
@@ -49,7 +48,7 @@ def translateMessage(key, message, mode):
 
     if mode == 'decrypt':
         charsA, charsB = charsB, charsA
-        
+
     for symbol in message:
         if symbol.upper() in charsA:
             symIndex = charsA.find(symbol.upper())
diff --git a/ciphers/transposition_cipher.py b/ciphers/transposition_cipher.py
index dbb358315d22..1c2ed0aa0452 100644
--- a/ciphers/transposition_cipher.py
+++ b/ciphers/transposition_cipher.py
@@ -1,4 +1,3 @@
-from __future__ import print_function
 import math
 
 def main():
diff --git a/ciphers/transposition_cipher_encrypt_decrypt_file.py b/ciphers/transposition_cipher_encrypt_decrypt_file.py
index a186cf81cde7..8ebfc1ea7e0c 100644
--- a/ciphers/transposition_cipher_encrypt_decrypt_file.py
+++ b/ciphers/transposition_cipher_encrypt_decrypt_file.py
@@ -1,4 +1,3 @@
-from __future__ import print_function
 import time, os, sys
 import transposition_cipher as transCipher
 
@@ -16,7 +15,7 @@ def main():
         response = input('> ')
         if not response.lower().startswith('y'):
             sys.exit()
-            
+
     startTime = time.time()
     if mode.lower().startswith('e'):
         with open(inputFile) as f:
@@ -29,9 +28,9 @@ def main():
 
     with open(outputFile, 'w') as outputObj:
         outputObj.write(translated)
-    
+
     totalTime = round(time.time() - startTime, 2)
     print(('Done (', totalTime, 'seconds )'))
-    
+
 if __name__ == '__main__':
     main()
diff --git a/ciphers/vigenere_cipher.py b/ciphers/vigenere_cipher.py
index 5d5be0792835..95eeb431109f 100644
--- a/ciphers/vigenere_cipher.py
+++ b/ciphers/vigenere_cipher.py
@@ -1,4 +1,3 @@
-from __future__ import print_function
 LETTERS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
 
 def main():
diff --git a/data_structures/binary_tree/binary_search_tree.py b/data_structures/binary_tree/binary_search_tree.py
index cef5b55f245d..634b6cbcc231 100644
--- a/data_structures/binary_tree/binary_search_tree.py
+++ b/data_structures/binary_tree/binary_search_tree.py
@@ -1,7 +1,6 @@
 '''
 A binary search Tree
 '''
-from __future__ import print_function
 class Node:
 
     def __init__(self, label, parent):
@@ -66,8 +65,8 @@ def insert(self, label):
             else:
                 parent_node.setRight(new_node)
             #Set parent to the new node
-            new_node.setParent(parent_node)      
-    
+            new_node.setParent(parent_node)
+
     def delete(self, label):
         if (not self.empty()):
             #Look for the node with that label
@@ -92,7 +91,7 @@ def delete(self, label):
                     self.delete(tmpNode.getLabel())
                     #Assigns the value to the node to delete and keesp tree structure
                     node.setLabel(tmpNode.getLabel())
-    
+
     def getNode(self, label):
         curr_node = None
         #If the tree is not empty
@@ -177,7 +176,7 @@ def traversalTree(self, traversalFunction = None, root = None):
             #Returns a list of nodes in the order that the users wants to
             return traversalFunction(self.root)
 
-    #Returns an string of all the nodes labels in the list 
+    #Returns an string of all the nodes labels in the list
     #In Order Traversal
     def __str__(self):
         list = self.__InOrderTraversal(self.root)
@@ -203,7 +202,7 @@ def testBinarySearchTree():
                / \    \
               1   6    14
                  / \   /
-                4   7 13 
+                4   7 13
     '''
 
     r'''
@@ -236,11 +235,11 @@ def testBinarySearchTree():
         print("The label -1 exists")
     else:
         print("The label -1 doesn't exist")
-    
+
     if(not t.empty()):
         print(("Max Value: ", t.getMax().getLabel()))
         print(("Min Value: ", t.getMin().getLabel()))
-    
+
     t.delete(13)
     t.delete(10)
     t.delete(8)
diff --git a/data_structures/binary_tree/fenwick_tree.py b/data_structures/binary_tree/fenwick_tree.py
index ef984082d9e8..30a87fbd7fcf 100644
--- a/data_structures/binary_tree/fenwick_tree.py
+++ b/data_structures/binary_tree/fenwick_tree.py
@@ -1,4 +1,3 @@
-from __future__ import print_function
 class FenwickTree:
 
     def __init__(self, SIZE): # create fenwick tree with size SIZE
diff --git a/data_structures/binary_tree/lazy_segment_tree.py b/data_structures/binary_tree/lazy_segment_tree.py
index 215399976dd3..bbe37a6eb97f 100644
--- a/data_structures/binary_tree/lazy_segment_tree.py
+++ b/data_structures/binary_tree/lazy_segment_tree.py
@@ -1,4 +1,3 @@
-from __future__ import print_function
 import math
 
 class SegmentTree:
diff --git a/data_structures/binary_tree/segment_tree.py b/data_structures/binary_tree/segment_tree.py
index 7e61198ca59c..da3d15f26b6a 100644
--- a/data_structures/binary_tree/segment_tree.py
+++ b/data_structures/binary_tree/segment_tree.py
@@ -1,4 +1,3 @@
-from __future__ import print_function
 import math
 
 class SegmentTree:
diff --git a/data_structures/heap/heap.py b/data_structures/heap/heap.py
index 39778f725c3a..2373d71bb897 100644
--- a/data_structures/heap/heap.py
+++ b/data_structures/heap/heap.py
@@ -1,15 +1,8 @@
 #!/usr/bin/python
 
-from __future__ import print_function, division
-
-try:
-    raw_input          # Python 2
-except NameError:
-    raw_input = input  # Python 3
-
-#This heap class start from here.
+# This heap class start from here.
 class Heap:
-	def __init__(self): #Default constructor of heap class.
+	def __init__(self): # Default constructor of heap class.
 	    self.h = []
 	    self.currsize = 0
 
@@ -79,7 +72,7 @@ def display(self): #This function is used to print the heap.
 		print(self.h)
 
 def main():
-	l = list(map(int, raw_input().split()))
+	l = list(map(int, input().split()))
 	h = Heap()
 	h.buildHeap(l)
 	h.heapSort()
diff --git a/data_structures/linked_list/doubly_linked_list.py b/data_structures/linked_list/doubly_linked_list.py
index 75b1f889dfc2..23d91383fa0e 100644
--- a/data_structures/linked_list/doubly_linked_list.py
+++ b/data_structures/linked_list/doubly_linked_list.py
@@ -4,14 +4,13 @@
 - Each link references the next link and the previous one.
 - A Doubly Linked List (DLL) contains an extra pointer, typically called previous pointer, together with next pointer and data which are there in singly linked list.
  - Advantages over SLL - IT can be traversed in both forward and backward direction.,Delete operation is more efficent'''
-from __future__ import print_function
 
 
 class LinkedList:           #making main class named linked list
     def __init__(self):
         self.head = None
         self.tail = None
-        
+
     def insertHead(self, x):
         newLink = Link(x)                            #Create a new link with a value attached to it
         if(self.isEmpty() == True):                  #Set the first element added to be the tail
@@ -20,52 +19,52 @@ def insertHead(self, x):
             self.head.previous = newLink             # newLink <-- currenthead(head)
         newLink.next = self.head                     # newLink <--> currenthead(head)
         self.head = newLink                          # newLink(head) <--> oldhead
-    
+
     def deleteHead(self):
         temp = self.head
-        self.head = self.head.next                   # oldHead <--> 2ndElement(head) 
+        self.head = self.head.next                   # oldHead <--> 2ndElement(head)
         self.head.previous = None                    # oldHead --> 2ndElement(head) nothing pointing at it so the old head will be removed
         if(self.head is None):
             self.tail = None                         #if empty linked list
         return temp
-    
+
     def insertTail(self, x):
         newLink = Link(x)
         newLink.next = None                         # currentTail(tail)    newLink -->
         self.tail.next = newLink                    # currentTail(tail) --> newLink -->
         newLink.previous = self.tail                #currentTail(tail) <--> newLink -->
         self.tail = newLink                         # oldTail <--> newLink(tail) -->
-    
+
     def deleteTail(self):
         temp = self.tail
         self.tail = self.tail.previous              # 2ndLast(tail) <--> oldTail --> None
         self.tail.next = None                       # 2ndlast(tail) --> None
         return temp
-    
+
     def delete(self, x):
         current = self.head
-        
+
         while(current.value != x):                  # Find the position to delete
             current = current.next
-            
+
         if(current == self.head):
             self.deleteHead()
-            
+
         elif(current == self.tail):
             self.deleteTail()
-            
+
         else: #Before: 1 <--> 2(current) <--> 3
             current.previous.next = current.next # 1 --> 3
             current.next.previous = current.previous # 1 <--> 3
-    
+
     def isEmpty(self):                               #Will return True if the list is empty
         return(self.head is None)
-        
+
     def display(self):                                #Prints contents of the list
         current = self.head
         while(current != None):
             current.displayLink()
-            current = current.next  
+            current = current.next
         print()
 
 class Link:
diff --git a/data_structures/linked_list/singly_linked_list.py b/data_structures/linked_list/singly_linked_list.py
index 5ae97523b9a1..5943b88d5964 100644
--- a/data_structures/linked_list/singly_linked_list.py
+++ b/data_structures/linked_list/singly_linked_list.py
@@ -1,6 +1,3 @@
-from __future__ import print_function
-
-
 class Node:  # create a Node
     def __init__(self, data):
         self.data = data  # given data
@@ -10,7 +7,7 @@ def __init__(self, data):
 class Linked_List:
     def __init__(self):
         self.Head = None    # Initialize Head to None
-        
+
     def insert_tail(self, data):
         if(self.Head is None): self.insert_head(data)    #If this is first node, call insert_head
         else:
@@ -37,7 +34,7 @@ def delete_head(self):  # delete from head
             self.Head = self.Head.next
             temp.next = None
         return temp
-        
+
     def delete_tail(self):  # delete from tail
         tamp = self.Head
         if self.Head != None:
@@ -46,7 +43,7 @@ def delete_tail(self):  # delete from tail
             else:
                 while tamp.next.next is not None:  # find the 2nd last element
                     tamp = tamp.next
-                tamp.next, tamp = None, tamp.next    #(2nd last element).next = None and tamp = last element 
+                tamp.next, tamp = None, tamp.next    #(2nd last element).next = None and tamp = last element
         return tamp
 
     def isEmpty(self):
@@ -79,7 +76,7 @@ def main():
     print("\nPrint List : ")
     A.printList()
     print("\nInserting 1st at Tail")
-    a3=input()    
+    a3=input()
     A.insert_tail(a3)
     print("Inserting 2nd at Tail")
     a4=input()
@@ -96,6 +93,6 @@ def main():
     A.reverse()
     print("\nPrint List : ")
     A.printList()
-    
+
 if __name__ == '__main__':
 	main()
diff --git a/data_structures/queue/double_ended_queue.py b/data_structures/queue/double_ended_queue.py
index 838bf2f4bc36..a2fc8f66ec22 100644
--- a/data_structures/queue/double_ended_queue.py
+++ b/data_structures/queue/double_ended_queue.py
@@ -1,4 +1,3 @@
-from __future__ import print_function
 # Python code to demonstrate working of
 # extend(), extendleft(), rotate(), reverse()
 
diff --git a/data_structures/stacks/balanced_parentheses.py b/data_structures/stacks/balanced_parentheses.py
index 36a4e07a97a3..3f43ccbf5760 100644
--- a/data_structures/stacks/balanced_parentheses.py
+++ b/data_structures/stacks/balanced_parentheses.py
@@ -1,6 +1,3 @@
-from __future__ import print_function
-from __future__ import absolute_import
-
 from .stack import Stack
 
 __author__ = 'Omkar Pathak'
diff --git a/data_structures/stacks/infix_to_postfix_conversion.py b/data_structures/stacks/infix_to_postfix_conversion.py
index 9376b55b8b23..84a5d1480a24 100644
--- a/data_structures/stacks/infix_to_postfix_conversion.py
+++ b/data_structures/stacks/infix_to_postfix_conversion.py
@@ -1,5 +1,3 @@
-from __future__ import print_function
-from __future__ import absolute_import
 import string
 
 from .stack import Stack
diff --git a/data_structures/stacks/next_greater_element.py b/data_structures/stacks/next_greater_element.py
index bca83339592c..2e67f1764a5a 100644
--- a/data_structures/stacks/next_greater_element.py
+++ b/data_structures/stacks/next_greater_element.py
@@ -1,17 +1,16 @@
-from __future__ import print_function
 # Function to print element and NGE pair for all elements of list
 def printNGE(arr):
- 
+
     for i in range(0, len(arr), 1):
- 
+
         next = -1
         for j in range(i+1, len(arr), 1):
             if arr[i] < arr[j]:
                 next = arr[j]
                 break
-             
+
         print(str(arr[i]) + " -- " + str(next))
- 
+
 # Driver program to test above function
 arr = [11,13,21,3]
 printNGE(arr)
diff --git a/data_structures/stacks/stack.py b/data_structures/stacks/stack.py
index 7f979d927d08..387367db2fcc 100644
--- a/data_structures/stacks/stack.py
+++ b/data_structures/stacks/stack.py
@@ -1,4 +1,3 @@
-from __future__ import print_function
 __author__ = 'Omkar Pathak'
 
 
diff --git a/data_structures/stacks/stock_span_problem.py b/data_structures/stacks/stock_span_problem.py
index e9afebc193b6..47d916fde9ed 100644
--- a/data_structures/stacks/stock_span_problem.py
+++ b/data_structures/stacks/stock_span_problem.py
@@ -6,7 +6,6 @@
 number of consecutive days just before the given day, for which the price of the stock
 on the current day is less than or equal to its price on the given day.
 '''
-from __future__ import print_function
 def calculateSpan(price, S):
 
     n = len(price)
diff --git a/divide_and_conquer/convex_hull.py b/divide_and_conquer/convex_hull.py
index f15d74ddea68..42219794aed1 100644
--- a/divide_and_conquer/convex_hull.py
+++ b/divide_and_conquer/convex_hull.py
@@ -1,18 +1,16 @@
-from __future__ import print_function, absolute_import, division
-
 from numbers import Number
 """
-The convex hull problem is problem of finding all the vertices of convex polygon, P of 
+The convex hull problem is problem of finding all the vertices of convex polygon, P of
 a set of points in a plane such that all the points are either on the vertices of P or
-inside P. TH convex hull problem has several applications in geometrical problems, 
-computer graphics and game development. 
+inside P. TH convex hull problem has several applications in geometrical problems,
+computer graphics and game development.
 
-Two algorithms have been implemented for the convex hull problem here. 
+Two algorithms have been implemented for the convex hull problem here.
 1. A brute-force algorithm which runs in O(n^3)
 2. A divide-and-conquer algorithm which runs in O(n^3)
 
 There are other several other algorithms for the convex hull problem
-which have not been implemented here, yet. 
+which have not been implemented here, yet.
 
 """
 
diff --git a/divide_and_conquer/inversions.py b/divide_and_conquer/inversions.py
index 527741cad3b7..e4d50b7d4729 100644
--- a/divide_and_conquer/inversions.py
+++ b/divide_and_conquer/inversions.py
@@ -1,15 +1,13 @@
-from __future__ import print_function, absolute_import, division
-
 """
 Given an array-like data structure A[1..n], how many pairs
-(i, j) for all 1 <= i < j <= n such that A[i] > A[j]? These pairs are 
-called inversions. Counting the number of such inversions in an array-like 
-object is the important. Among other things, counting inversions  can help 
+(i, j) for all 1 <= i < j <= n such that A[i] > A[j]? These pairs are
+called inversions. Counting the number of such inversions in an array-like
+object is the important. Among other things, counting inversions  can help
 us determine how close a given array is to being sorted
- 
+
 In this implementation, I provide two algorithms, a divide-and-conquer
-algorithm which runs in nlogn and the brute-force n^2 algorithm. 
- 
+algorithm which runs in nlogn and the brute-force n^2 algorithm.
+
 """
 
 
diff --git a/dynamic_programming/bitmask.py b/dynamic_programming/bitmask.py
index 213b22fe9051..6685e1c68ee6 100644
--- a/dynamic_programming/bitmask.py
+++ b/dynamic_programming/bitmask.py
@@ -9,27 +9,26 @@
 
 
 """
-from __future__ import print_function
 from collections import defaultdict
 
 
 class AssignmentUsingBitmask:
     def __init__(self,task_performed,total):
-        
+
         self.total_tasks = total    #total no of tasks (N)
-        
+
         # DP table will have a dimension of (2^M)*N
         # initially all values are set to -1
         self.dp = [[-1 for i in range(total+1)] for j in range(2**len(task_performed))]
-        
+
         self.task = defaultdict(list)   #stores the list of persons for each task
-        
+
         #finalmask is used to check if all persons are included by setting all bits to 1
         self.finalmask = (1<<len(task_performed)) - 1
-    
-    
+
+
     def CountWaysUtil(self,mask,taskno):
-        
+
         # if mask == self.finalmask all persons are distributed tasks, return 1
         if mask == self.finalmask:
             return 1
@@ -48,18 +47,18 @@ def CountWaysUtil(self,mask,taskno):
         # now assign the tasks one by one to all possible persons and recursively assign for the remaining tasks.
         if taskno in self.task:
             for p in self.task[taskno]:
-                
+
                 # if p is already given a task
                 if mask & (1<<p):
                     continue
-                
+
                 # assign this task to p and change the mask value. And recursively assign tasks with the new mask value.
                 total_ways_util+=self.CountWaysUtil(mask|(1<<p),taskno+1)
-        
+
         # save the value.
         self.dp[mask][taskno] = total_ways_util
-        
-        return self.dp[mask][taskno] 
+
+        return self.dp[mask][taskno]
 
     def countNoOfWays(self,task_performed):
 
@@ -67,17 +66,17 @@ def countNoOfWays(self,task_performed):
         for i in range(len(task_performed)):
             for j in task_performed[i]:
                 self.task[j].append(i)
-        
+
         # call the function to fill the DP table, final answer is stored in dp[0][1]
         return self.CountWaysUtil(0,1)
-        
+
 
 if __name__ == '__main__':
-    
+
     total_tasks = 5    #total no of tasks (the value of N)
-    
+
     #the list of tasks that can be done by M persons.
-    task_performed = [ 
+    task_performed = [
         [ 1 , 3 , 4 ],
         [ 1 , 2 , 5 ],
         [ 3 , 4 ]
diff --git a/dynamic_programming/coin_change.py b/dynamic_programming/coin_change.py
index 74d86661f52d..61deccd124e6 100644
--- a/dynamic_programming/coin_change.py
+++ b/dynamic_programming/coin_change.py
@@ -5,9 +5,6 @@
 the given types of coins?
 https://www.hackerrank.com/challenges/coin-change/problem
 """
-from __future__ import print_function
-
-
 def dp_count(S, m, n):
 
     # table[i] represents the number of ways to get to amount i
diff --git a/dynamic_programming/edit_distance.py b/dynamic_programming/edit_distance.py
index b71f80d68935..585c762ad017 100644
--- a/dynamic_programming/edit_distance.py
+++ b/dynamic_programming/edit_distance.py
@@ -7,7 +7,6 @@
 The problem is :
 Given two strings A and B. Find the minimum number of operations to string B such that A = B. The permitted operations are removal,  insertion, and substitution.
 """
-from __future__ import print_function
 
 
 class EditDistance:
@@ -67,14 +66,14 @@ def min_distance_bottom_up(word1: str, word2: str) -> int:
     dp = [[0 for _ in range(n+1) ] for _ in range(m+1)]
     for i in range(m+1):
         for j in range(n+1):
-            
+
             if i == 0:  #first string is empty
                 dp[i][j] = j
-            elif j == 0: #second string is empty 
-                dp[i][j] = i 
+            elif j == 0: #second string is empty
+                dp[i][j] = i
             elif word1[i-1] == word2[j-1]: #last character of both substing is equal
                 dp[i][j] = dp[i-1][j-1]
-            else: 
+            else:
                 insert = dp[i][j-1]
                 delete = dp[i-1][j]
                 replace = dp[i-1][j-1]
@@ -82,21 +81,13 @@ def min_distance_bottom_up(word1: str, word2: str) -> int:
     return dp[m][n]
 
 if __name__ == '__main__':
-        try:
-            raw_input          # Python 2
-        except NameError:
-            raw_input = input  # Python 3
-
         solver = EditDistance()
 
         print("****************** Testing Edit Distance DP Algorithm ******************")
         print()
 
-        print("Enter the first string: ", end="")
-        S1 = raw_input().strip()
-
-        print("Enter the second string: ", end="")
-        S2 = raw_input().strip()
+        S1 = input("Enter the first string: ").strip()
+        S2 = input("Enter the second string: ").strip()
 
         print()
         print("The minimum Edit Distance is: %d" % (solver.solve(S1, S2)))
@@ -106,4 +97,4 @@ def min_distance_bottom_up(word1: str, word2: str) -> int:
 
 
 
- 
+
diff --git a/dynamic_programming/fast_fibonacci.py b/dynamic_programming/fast_fibonacci.py
index cbc118467b3c..47248078bd81 100644
--- a/dynamic_programming/fast_fibonacci.py
+++ b/dynamic_programming/fast_fibonacci.py
@@ -5,7 +5,6 @@
 This program calculates the nth Fibonacci number in O(log(n)).
 It's possible to calculate F(1000000) in less than a second.
 """
-from __future__ import print_function
 import sys
 
 
diff --git a/dynamic_programming/fibonacci.py b/dynamic_programming/fibonacci.py
index b453ce255853..90fe6386044a 100644
--- a/dynamic_programming/fibonacci.py
+++ b/dynamic_programming/fibonacci.py
@@ -1,7 +1,6 @@
 """
 This is a pure Python implementation of Dynamic Programming solution to the fibonacci sequence problem.
 """
-from __future__ import print_function
 
 
 class Fibonacci:
@@ -29,21 +28,16 @@ def get(self, sequence_no=None):
 
 if __name__ == '__main__':
     print("\n********* Fibonacci Series Using Dynamic Programming ************\n")
-    try:
-        raw_input          # Python 2
-    except NameError:
-        raw_input = input  # Python 3
-
     print("\n Enter the upper limit for the fibonacci sequence: ", end="")
     try:
-        N = eval(raw_input().strip())
+        N = int(input().strip())
         fib = Fibonacci(N)
         print(
-            "\n********* Enter different values to get the corresponding fibonacci sequence, enter any negative number to exit. ************\n")
+            "\n********* Enter different values to get the corresponding fibonacci "
+            "sequence, enter any negative number to exit. ************\n")
         while True:
-            print("Enter value: ", end=" ")
             try:
-                i = eval(raw_input().strip())
+                i = int(input("Enter value: ").strip())
                 if i < 0:
                     print("\n********* Good Bye!! ************\n")
                     break
diff --git a/dynamic_programming/integer_partition.py b/dynamic_programming/integer_partition.py
index 7b27afebaa6c..f17561fc135b 100644
--- a/dynamic_programming/integer_partition.py
+++ b/dynamic_programming/integer_partition.py
@@ -1,27 +1,15 @@
-from __future__ import print_function
-
-try:
-	xrange		#Python 2
-except NameError:
-	xrange = range	#Python 3
-
-try:
-	raw_input		#Python 2
-except NameError:
-	raw_input = input	#Python 3
-
 '''
 The number of partitions of a number n into at least k parts equals the number of partitions into exactly k parts
 plus the number of partitions into at least k-1 parts. Subtracting 1 from each part of a partition of n into k parts
 gives a partition of n-k into k parts. These two facts together are used for this algorithm.
 '''
 def partition(m):
-	memo = [[0 for _ in xrange(m)] for _ in xrange(m+1)]
-	for i in xrange(m+1):
+	memo = [[0 for _ in range(m)] for _ in range(m+1)]
+	for i in range(m+1):
 		memo[i][0] = 1
 
-	for n in xrange(m+1):
-		for k in xrange(1, m):
+	for n in range(m+1):
+		for k in range(1, m):
 			memo[n][k] += memo[n][k-1]
 			if n-k > 0:
 				memo[n][k] += memo[n-k-1][k]
@@ -33,7 +21,7 @@ def partition(m):
 
 	if len(sys.argv) == 1:
 		try:
-			n = int(raw_input('Enter a number: '))
+			n = int(input('Enter a number: ').strip())
 			print(partition(n))
 		except ValueError:
 			print('Please enter a number.')
diff --git a/dynamic_programming/longest_common_subsequence.py b/dynamic_programming/longest_common_subsequence.py
index 7836fe303688..7447a0cc7810 100644
--- a/dynamic_programming/longest_common_subsequence.py
+++ b/dynamic_programming/longest_common_subsequence.py
@@ -3,7 +3,6 @@
 A subsequence is a sequence that appears in the same relative order, but not necessarily continuous.
 Example:"abc", "abg" are subsequences of "abcdefgh".
 """
-from __future__ import print_function
 
 
 def longest_common_subsequence(x: str, y: str):
@@ -80,4 +79,3 @@ def longest_common_subsequence(x: str, y: str):
     assert expected_ln == ln
     assert expected_subseq == subseq
     print("len =", ln, ", sub-sequence =", subseq)
-
diff --git a/dynamic_programming/longest_increasing_subsequence.py b/dynamic_programming/longest_increasing_subsequence.py
index b6d165909e70..151a5e0b7c80 100644
--- a/dynamic_programming/longest_increasing_subsequence.py
+++ b/dynamic_programming/longest_increasing_subsequence.py
@@ -7,10 +7,8 @@
 Given an ARRAY, to find the longest and increasing sub ARRAY in that given ARRAY and return it.
 Example: [10, 22, 9, 33, 21, 50, 41, 60, 80] as input will return [10, 22, 33, 41, 60, 80] as output
 '''
-from __future__ import print_function
-
 def longestSub(ARRAY): 			#This function is recursive
-	
+
 	ARRAY_LENGTH = len(ARRAY)
 	if(ARRAY_LENGTH <= 1):  	#If the array contains only one element, we return it (it's the stop condition of recursion)
 		return ARRAY
diff --git a/dynamic_programming/longest_increasing_subsequence_o(nlogn).py b/dynamic_programming/longest_increasing_subsequence_o(nlogn).py
index 86bec089adc7..9b27ed6be303 100644
--- a/dynamic_programming/longest_increasing_subsequence_o(nlogn).py
+++ b/dynamic_programming/longest_increasing_subsequence_o(nlogn).py
@@ -1,9 +1,8 @@
-from __future__ import print_function
 #############################
 # Author: Aravind Kashyap
 # File: lis.py
 # comments: This programme outputs the Longest Strictly Increasing Subsequence in O(NLogN)
-#           Where N is the Number of elements in the list 
+#           Where N is the Number of elements in the list
 #############################
 def CeilIndex(v,l,r,key):
 	while r-l > 1:
@@ -12,30 +11,30 @@ def CeilIndex(v,l,r,key):
 			r = m
 		else:
 			l = m
-	
+
 	return r
-	
+
 
 def LongestIncreasingSubsequenceLength(v):
 	if(len(v) == 0):
-		return 0	
-	
+		return 0
+
 	tail = [0]*len(v)
 	length = 1
-	
+
 	tail[0] = v[0]
-	
+
 	for i in range(1,len(v)):
 		if v[i] < tail[0]:
 			tail[0] = v[i]
 		elif v[i] > tail[length-1]:
 			tail[length] = v[i]
-			length += 1			
+			length += 1
 		else:
 			tail[CeilIndex(tail,-1,length-1,v[i])] = v[i]
-	
+
 	return length
-	
+
 
 if __name__ == "__main__":
 	v = [2, 5, 3, 7, 11, 8, 10, 13, 6]
diff --git a/dynamic_programming/longest_sub_array.py b/dynamic_programming/longest_sub_array.py
index de2c88a8b525..856b31f03982 100644
--- a/dynamic_programming/longest_sub_array.py
+++ b/dynamic_programming/longest_sub_array.py
@@ -6,7 +6,6 @@
 The problem is  :
 Given an array, to find the longest and continuous sub array and get the max sum of the sub array in the given array.
 '''
-from __future__ import print_function
 
 
 class SubArray:
diff --git a/dynamic_programming/matrix_chain_order.py b/dynamic_programming/matrix_chain_order.py
index b8234a65acbe..cb4aec345437 100644
--- a/dynamic_programming/matrix_chain_order.py
+++ b/dynamic_programming/matrix_chain_order.py
@@ -1,5 +1,3 @@
-from __future__ import print_function
-
 import sys
 '''
 Dynamic Programming
diff --git a/dynamic_programming/max_sub_array.py b/dynamic_programming/max_sub_array.py
index 56983b7d22c2..d6084ecfd6d9 100644
--- a/dynamic_programming/max_sub_array.py
+++ b/dynamic_programming/max_sub_array.py
@@ -1,7 +1,6 @@
 """
 author : Mayank Kumar Jha (mk9440)
 """
-from __future__ import print_function
 from typing import List
 import time
 import matplotlib.pyplot as plt
@@ -10,7 +9,7 @@ def find_max_sub_array(A,low,high):
     if low==high:
         return low,high,A[low]
     else :
-        mid=(low+high)//2        
+        mid=(low+high)//2
         left_low,left_high,left_sum=find_max_sub_array(A,low,mid)
         right_low,right_high,right_sum=find_max_sub_array(A,mid+1,high)
         cross_left,cross_right,cross_sum=find_max_cross_sum(A,low,mid,high)
@@ -30,7 +29,7 @@ def find_max_cross_sum(A,low,mid,high):
         if summ > left_sum:
             left_sum=summ
             max_left=i
-    summ=0        
+    summ=0
     for i in range(mid+1,high+1):
         summ+=A[i]
         if summ > right_sum:
@@ -40,7 +39,7 @@ def find_max_cross_sum(A,low,mid,high):
 
 def max_sub_array(nums: List[int]) -> int:
     """
-     Finds the contiguous subarray (can be empty array) 
+     Finds the contiguous subarray (can be empty array)
      which has the largest sum and return its sum.
 
     >>> max_sub_array([-2,1,-3,4,-1,2,1,-5,4])
@@ -50,14 +49,14 @@ def max_sub_array(nums: List[int]) -> int:
     >>> max_sub_array([-1,-2,-3])
     0
     """
-    best = 0 
-    current = 0 
-    for i in nums: 
-        current += i 
+    best = 0
+    current = 0
+    for i in nums:
+        current += i
         if current < 0:
             current = 0
         best = max(best, current)
-    return best 
+    return best
 
 if __name__=='__main__':
     inputs=[10,100,1000,10000,50000,100000,200000,300000,400000,500000]
@@ -68,8 +67,8 @@ def max_sub_array(nums: List[int]) -> int:
         (find_max_sub_array(li,0,len(li)-1))
         end=time.time()
         tim.append(end-strt)
-    print("No of Inputs       Time Taken")    
-    for i in range(len(inputs)):    
+    print("No of Inputs       Time Taken")
+    for i in range(len(inputs)):
         print(inputs[i],'\t\t',tim[i])
     plt.plot(inputs,tim)
     plt.xlabel("Number of Inputs");plt.ylabel("Time taken in seconds ")
@@ -77,4 +76,4 @@ def max_sub_array(nums: List[int]) -> int:
 
 
 
-        
+
diff --git a/graphs/a_star.py b/graphs/a_star.py
index 584222e6f62b..09a7a0e579d8 100644
--- a/graphs/a_star.py
+++ b/graphs/a_star.py
@@ -1,5 +1,3 @@
-from __future__ import print_function
-
 grid = [[0, 1, 0, 0, 0, 0],
         [0, 1, 0, 0, 0, 0],#0 are free path whereas 1's are obstacles
         [0, 1, 0, 0, 0, 0],
@@ -14,13 +12,13 @@
              [5, 4, 3, 2, 1, 0]]'''
 
 init = [0, 0]
-goal = [len(grid)-1, len(grid[0])-1] #all coordinates are given in format [y,x] 
+goal = [len(grid)-1, len(grid[0])-1] #all coordinates are given in format [y,x]
 cost = 1
 
 #the cost map which pushes the path closer to the goal
 heuristic = [[0 for row in range(len(grid[0]))] for col in range(len(grid))]
-for i in range(len(grid)):    
-    for j in range(len(grid[0])):            
+for i in range(len(grid)):
+    for j in range(len(grid[0])):
         heuristic[i][j] = abs(i - goal[0]) + abs(j - goal[1])
         if grid[i][j] == 1:
             heuristic[i][j] = 99 #added extra penalty in the heuristic map
@@ -62,7 +60,7 @@ def search(grid,init,goal,cost,heuristic):
             g = next[1]
             f = next[0]
 
-            
+
             if x == goal[0] and y == goal[1]:
                 found = True
             else:
@@ -93,10 +91,10 @@ def search(grid,init,goal,cost,heuristic):
     print("ACTION MAP")
     for i in range(len(action)):
         print(action[i])
-                  
+
     return path
-    
+
 a = search(grid,init,goal,cost,heuristic)
 for i in range(len(a)):
-	print(a[i]) 
+	print(a[i])
 
diff --git a/graphs/basic_graphs.py b/graphs/basic_graphs.py
index ee63ca995de6..64c51e139cca 100644
--- a/graphs/basic_graphs.py
+++ b/graphs/basic_graphs.py
@@ -1,23 +1,10 @@
-from __future__ import print_function
-
-try:
-    raw_input  # Python 2
-except NameError:
-    raw_input = input  # Python 3
-
-try:
-    xrange  # Python 2
-except NameError:
-    xrange = range  # Python 3
-
-
 if __name__ == "__main__":
     # Accept No. of Nodes and edges
-    n, m = map(int, raw_input().split(" "))
+    n, m = map(int, input().split(" "))
 
     # Initialising Dictionary of edges
     g = {}
-    for i in xrange(n):
+    for i in range(n):
         g[i + 1] = []
 
     """
@@ -25,8 +12,8 @@
         Accepting edges of Unweighted Directed Graphs
     ----------------------------------------------------------------------------
     """
-    for _ in xrange(m):
-        x, y = map(int, raw_input().strip().split(" "))
+    for _ in range(m):
+        x, y = map(int, input().strip().split(" "))
         g[x].append(y)
 
     """
@@ -34,8 +21,8 @@
         Accepting edges of Unweighted Undirected Graphs
     ----------------------------------------------------------------------------
     """
-    for _ in xrange(m):
-        x, y = map(int, raw_input().strip().split(" "))
+    for _ in range(m):
+        x, y = map(int, input().strip().split(" "))
         g[x].append(y)
         g[y].append(x)
 
@@ -44,8 +31,8 @@
         Accepting edges of Weighted Undirected Graphs
     ----------------------------------------------------------------------------
     """
-    for _ in xrange(m):
-        x, y, r = map(int, raw_input().strip().split(" "))
+    for _ in range(m):
+        x, y, r = map(int, input().strip().split(" "))
         g[x].append([y, r])
         g[y].append([x, r])
 
@@ -170,10 +157,10 @@ def topo(G, ind=None, Q=[1]):
 
 
 def adjm():
-    n = raw_input().strip()
+    n = input().strip()
     a = []
-    for i in xrange(n):
-        a.append(map(int, raw_input().strip().split()))
+    for i in range(n):
+        a.append(map(int, input().strip().split()))
     return a, n
 
 
@@ -193,10 +180,10 @@ def adjm():
 def floy(A_and_n):
     (A, n) = A_and_n
     dist = list(A)
-    path = [[0] * n for i in xrange(n)]
-    for k in xrange(n):
-        for i in xrange(n):
-            for j in xrange(n):
+    path = [[0] * n for i in range(n)]
+    for k in range(n):
+        for i in range(n):
+            for j in range(n):
                 if dist[i][j] > dist[i][k] + dist[k][j]:
                     dist[i][j] = dist[i][k] + dist[k][j]
                     path[i][k] = k
@@ -245,10 +232,10 @@ def prim(G, s):
 
 
 def edglist():
-    n, m = map(int, raw_input().split(" "))
+    n, m = map(int, input().split(" "))
     l = []
-    for i in xrange(m):
-        l.append(map(int, raw_input().split(' ')))
+    for i in range(m):
+        l.append(map(int, input().split(' ')))
     return l, n
 
 
@@ -272,10 +259,10 @@ def krusk(E_and_n):
             break
         print(s)
         x = E.pop()
-        for i in xrange(len(s)):
+        for i in range(len(s)):
             if x[0] in s[i]:
                 break
-        for j in xrange(len(s)):
+        for j in range(len(s)):
             if x[1] in s[j]:
                 if i == j:
                     break
diff --git a/graphs/bellman_ford.py b/graphs/bellman_ford.py
index f49157230054..bebe8f354b26 100644
--- a/graphs/bellman_ford.py
+++ b/graphs/bellman_ford.py
@@ -1,5 +1,3 @@
-from __future__ import print_function
-
 def printDist(dist, V):
 	print("\nVertex Distance")
 	for i in range(V):
diff --git a/graphs/breadth_first_search.py b/graphs/breadth_first_search.py
index 3992e2d4d892..205f49a6172b 100644
--- a/graphs/breadth_first_search.py
+++ b/graphs/breadth_first_search.py
@@ -3,8 +3,6 @@
 
 """ Author: OMKAR PATHAK """
 
-from __future__ import print_function
-
 
 class Graph():
     def __init__(self):
diff --git a/graphs/depth_first_search.py b/graphs/depth_first_search.py
index 98faf61354f9..2b03683c0047 100644
--- a/graphs/depth_first_search.py
+++ b/graphs/depth_first_search.py
@@ -2,7 +2,6 @@
 # encoding=utf8
 
 """ Author: OMKAR PATHAK """
-from __future__ import print_function
 
 
 class Graph():
diff --git a/graphs/dijkstra_2.py b/graphs/dijkstra_2.py
index 8f39aec41906..f6118830c9c0 100644
--- a/graphs/dijkstra_2.py
+++ b/graphs/dijkstra_2.py
@@ -1,5 +1,3 @@
-from __future__ import print_function
-
 def printDist(dist, V):
 	print("\nVertex Distance")
 	for i in range(V):
diff --git a/graphs/dijkstra_algorithm.py b/graphs/dijkstra_algorithm.py
index 985c7f6c1301..c43ff37f5336 100644
--- a/graphs/dijkstra_algorithm.py
+++ b/graphs/dijkstra_algorithm.py
@@ -2,7 +2,6 @@
 # Author: Shubham Malik
 # References: https://en.wikipedia.org/wiki/Dijkstra%27s_algorithm
 
-from __future__ import print_function
 import math
 import sys
 # For storing the vertex set to retreive node with the lowest distance
diff --git a/graphs/even_tree.py b/graphs/even_tree.py
index 9383ea9a13c1..45d55eecff8a 100644
--- a/graphs/even_tree.py
+++ b/graphs/even_tree.py
@@ -12,7 +12,6 @@
 Note: The tree input will be such that it can always be decomposed into
 components containing an even number of nodes.
 """
-from __future__ import print_function
 # pylint: disable=invalid-name
 from collections import defaultdict
 
diff --git a/graphs/graph_list.py b/graphs/graph_list.py
index 0c981c39d320..2ca363b1d746 100644
--- a/graphs/graph_list.py
+++ b/graphs/graph_list.py
@@ -1,7 +1,6 @@
 #!/usr/bin/python
 # encoding=utf8
 
-from __future__ import print_function
 # Author: OMKAR PATHAK
 
 # We can use Python's dictionary for constructing the graph.
diff --git a/graphs/graph_matrix.py b/graphs/graph_matrix.py
index de25301d6dd1..1998fec8d6fe 100644
--- a/graphs/graph_matrix.py
+++ b/graphs/graph_matrix.py
@@ -1,6 +1,3 @@
-from __future__ import print_function
-
-
 class Graph:
 
     def __init__(self, vertex):
diff --git a/graphs/graphs_floyd_warshall.py b/graphs/graphs_floyd_warshall.py
index a1d12aac02b4..5f159683733f 100644
--- a/graphs/graphs_floyd_warshall.py
+++ b/graphs/graphs_floyd_warshall.py
@@ -4,8 +4,6 @@
     have negative edge weights.
 """
 
-from __future__ import print_function
-
 
 def _print_dist(dist, v):
 	print("\nThe shortest path matrix using Floyd Warshall algorithm\n")
@@ -34,9 +32,9 @@ def floyd_warshall(graph, v):
     4. The above is repeated for each vertex k in the graph.
     5. Whenever distance[i][j] is given a new minimum value, next vertex[i][j] is updated to the next vertex[i][k].
     """
-		
+
 	dist=[[float('inf') for _ in range(v)] for _ in range(v)]
-	
+
 	for i in range(v):
 		for j in range(v):
 			dist[i][j] = graph[i][j]
@@ -53,7 +51,7 @@ def floyd_warshall(graph, v):
 	_print_dist(dist, v)
 	return dist, v
 
-			
+
 
 if __name__== '__main__':
 	v = int(input("Enter number of vertices: "))
diff --git a/graphs/minimum_spanning_tree_kruskal.py b/graphs/minimum_spanning_tree_kruskal.py
index 975151c90ede..a2211582ec40 100644
--- a/graphs/minimum_spanning_tree_kruskal.py
+++ b/graphs/minimum_spanning_tree_kruskal.py
@@ -1,5 +1,3 @@
-from __future__ import print_function
-
 if __name__ == "__main__":
     num_nodes, num_edges = list(map(int, input().strip().split()))
 
diff --git a/graphs/multi_hueristic_astar.py b/graphs/multi_hueristic_astar.py
index 1c01fe9aa6d3..3021c4162b8e 100644
--- a/graphs/multi_hueristic_astar.py
+++ b/graphs/multi_hueristic_astar.py
@@ -1,12 +1,6 @@
-from __future__ import print_function
 import heapq
 import numpy as np
 
-try:
-    xrange          # Python 2
-except NameError:
-    xrange = range  # Python 3
-
 
 class PriorityQueue:
 	def __init__(self):
@@ -96,7 +90,7 @@ def do_something(back_pointer, goal, start):
 	grid[(n-1)][0] = "-"
 
 
-	for i in xrange(n):
+	for i in range(n):
 		for j in range(n):
 			if (i, j) == (0, n-1):
 				print(grid[i][j], end=' ')
diff --git a/graphs/scc_kosaraju.py b/graphs/scc_kosaraju.py
index 0d0375203b6d..99564a7cfa35 100644
--- a/graphs/scc_kosaraju.py
+++ b/graphs/scc_kosaraju.py
@@ -1,6 +1,3 @@
-from __future__ import print_function
-
-
 def dfs(u):
     global g, r, scc, component, visit, stack
     if visit[u]: return
diff --git a/hashes/chaos_machine.py b/hashes/chaos_machine.py
index f0a305bfeade..3a7c3950bb29 100644
--- a/hashes/chaos_machine.py
+++ b/hashes/chaos_machine.py
@@ -1,10 +1,4 @@
 """example of simple chaos machine"""
-from __future__ import print_function
-
-try:
-  input = raw_input  # Python 2
-except NameError:
-  pass               # Python 3
 
 # Chaos Machine (K, t, m)
 K = [0.33, 0.44, 0.55, 0.44, 0.33]; t = 3; m = 5
@@ -96,7 +90,7 @@ def reset():
 for chunk in message:
   push(chunk)
 
-# for controlling 
+# for controlling
 inp = ""
 
 # Pulling Data (Output)
diff --git a/hashes/enigma_machine.py b/hashes/enigma_machine.py
index bd410c5cb21d..06215785765f 100644
--- a/hashes/enigma_machine.py
+++ b/hashes/enigma_machine.py
@@ -1,5 +1,3 @@
-from __future__ import print_function
-
 alphabets = [chr(i) for i in range(32, 126)]
 gear_one = [i for i in range(len(alphabets))]
 gear_two = [i for i in range(len(alphabets))]
diff --git a/hashes/md5.py b/hashes/md5.py
index 7891f2077986..1ad43013363f 100644
--- a/hashes/md5.py
+++ b/hashes/md5.py
@@ -1,4 +1,3 @@
-from __future__ import print_function
 import math
 
 
@@ -66,7 +65,7 @@ def getBlock(bitString):
     """[summary]
     Iterator:
             Returns by each call a list of length 16 with the 32 bit
-            integer blocks. 
+            integer blocks.
 
     Arguments:
             bitString {[string]} -- [binary string >= 512]
@@ -95,7 +94,7 @@ def not32(i):
 
 def sum32(a, b):
     '''
-    
+
     '''
     return (a + b) % 2**32
 
diff --git a/machine_learning/decision_tree.py b/machine_learning/decision_tree.py
index 71849904ccf2..acdf646875ac 100644
--- a/machine_learning/decision_tree.py
+++ b/machine_learning/decision_tree.py
@@ -1,10 +1,8 @@
 """
 Implementation of a basic regression decision tree.
 Input data set: The input data set must be 1-dimensional with continuous labels.
-Output: The decision tree maps a real number input to a real number output. 
+Output: The decision tree maps a real number input to a real number output.
 """
-from __future__ import print_function
-
 import numpy as np
 
 class Decision_Tree:
@@ -19,7 +17,7 @@ def __init__(self, depth = 5, min_leaf_size = 5):
     def mean_squared_error(self, labels, prediction):
         """
         mean_squared_error:
-        @param labels: a one dimensional numpy array 
+        @param labels: a one dimensional numpy array
         @param prediction: a floating point value
         return value: mean_squared_error calculates the error if prediction is used to estimate the labels
         """
@@ -32,7 +30,7 @@ def train(self, X, y):
         """
         train:
         @param X: a one dimensional numpy array
-        @param y: a one dimensional numpy array. 
+        @param y: a one dimensional numpy array.
         The contents of y are the labels for the corresponding X values
 
         train does not have a return value
@@ -135,6 +133,6 @@ def main():
     print("Predictions: " + str(predictions))
     print("Average error: " + str(avg_error))
 
-            
+
 if __name__ == '__main__':
     main()
\ No newline at end of file
diff --git a/machine_learning/gradient_descent.py b/machine_learning/gradient_descent.py
index 6387d4939205..9a17113b7ddb 100644
--- a/machine_learning/gradient_descent.py
+++ b/machine_learning/gradient_descent.py
@@ -1,7 +1,6 @@
 """
 Implementation of gradient descent algorithm for minimizing cost of a linear hypothesis function.
 """
-from __future__ import print_function, division
 import numpy
 
 # List of input, output pairs
diff --git a/machine_learning/k_means_clust.py b/machine_learning/k_means_clust.py
index 368739a45fe9..d0ce0f2599e0 100644
--- a/machine_learning/k_means_clust.py
+++ b/machine_learning/k_means_clust.py
@@ -17,36 +17,35 @@
 
 Usage:
   1. define 'k' value, 'X' features array and 'hetrogeneity' empty list
-  
+
   2. create initial_centroids,
         initial_centroids = get_initial_centroids(
-            X, 
-            k, 
+            X,
+            k,
             seed=0 # seed value for initial centroid generation, None for randomness(default=None)
             )
 
   3. find centroids and clusters using kmeans function.
-  
+
         centroids, cluster_assignment = kmeans(
-            X, 
-            k, 
-            initial_centroids, 
+            X,
+            k,
+            initial_centroids,
             maxiter=400,
-            record_heterogeneity=heterogeneity, 
+            record_heterogeneity=heterogeneity,
             verbose=True # whether to print logs in console or not.(default=False)
             )
-  
-  
+
+
   4. Plot the loss function, hetrogeneity values for every iteration saved in hetrogeneity list.
         plot_heterogeneity(
-            heterogeneity, 
+            heterogeneity,
             k
         )
-  
+
   5. Have fun..
-  
+
 '''
-from __future__ import print_function
 from sklearn.metrics import pairwise_distances
 import numpy as np
 
@@ -57,30 +56,30 @@ def get_initial_centroids(data, k, seed=None):
     if seed is not None: # useful for obtaining consistent results
         np.random.seed(seed)
     n = data.shape[0] # number of data points
-        
+
     # Pick K indices from range [0, N).
     rand_indices = np.random.randint(0, n, k)
-    
+
     # Keep centroids as dense format, as many entries will be nonzero due to averaging.
     # As long as at least one document in a cluster contains a word,
     # it will carry a nonzero weight in the TF-IDF vector of the centroid.
     centroids = data[rand_indices,:]
-    
+
     return centroids
 
 def centroid_pairwise_dist(X,centroids):
     return pairwise_distances(X,centroids,metric='euclidean')
 
 def assign_clusters(data, centroids):
-    
+
     # Compute distances between each data point and the set of centroids:
     # Fill in the blank (RHS only)
     distances_from_centroids = centroid_pairwise_dist(data,centroids)
-    
+
     # Compute cluster assignments for each data point:
     # Fill in the blank (RHS only)
     cluster_assignment = np.argmin(distances_from_centroids,axis=1)
-    
+
     return cluster_assignment
 
 def revise_centroids(data, k, cluster_assignment):
@@ -92,23 +91,23 @@ def revise_centroids(data, k, cluster_assignment):
         centroid = member_data_points.mean(axis=0)
         new_centroids.append(centroid)
     new_centroids = np.array(new_centroids)
-    
+
     return new_centroids
 
 def compute_heterogeneity(data, k, centroids, cluster_assignment):
-    
+
     heterogeneity = 0.0
     for i in range(k):
-        
+
         # Select all data points that belong to cluster i. Fill in the blank (RHS only)
         member_data_points = data[cluster_assignment==i, :]
-        
+
         if member_data_points.shape[0] > 0: # check if i-th cluster is non-empty
             # Compute distances from centroid to data points (RHS only)
             distances = pairwise_distances(member_data_points, [centroids[i]], metric='euclidean')
             squared_distances = distances**2
             heterogeneity += np.sum(squared_distances)
-        
+
     return heterogeneity
 
 from matplotlib import pyplot as plt
@@ -129,36 +128,36 @@ def kmeans(data, k, initial_centroids, maxiter=500, record_heterogeneity=None, v
        verbose: if True, print how many data points changed their cluster labels in each iteration'''
     centroids = initial_centroids[:]
     prev_cluster_assignment = None
-    
-    for itr in range(maxiter):        
+
+    for itr in range(maxiter):
         if verbose:
             print(itr, end='')
-        
+
         # 1. Make cluster assignments using nearest centroids
         cluster_assignment = assign_clusters(data,centroids)
-            
+
         # 2. Compute a new centroid for each of the k clusters, averaging all data points assigned to that cluster.
         centroids = revise_centroids(data,k, cluster_assignment)
-            
+
         # Check for convergence: if none of the assignments changed, stop
         if prev_cluster_assignment is not None and \
           (prev_cluster_assignment==cluster_assignment).all():
             break
-        
-        # Print number of new assignments 
+
+        # Print number of new assignments
         if prev_cluster_assignment is not None:
             num_changed = np.sum(prev_cluster_assignment!=cluster_assignment)
             if verbose:
-                print('    {0:5d} elements changed their cluster assignment.'.format(num_changed))   
-        
+                print('    {0:5d} elements changed their cluster assignment.'.format(num_changed))
+
         # Record heterogeneity convergence metric
         if record_heterogeneity is not None:
             # YOUR CODE HERE
             score = compute_heterogeneity(data,k,centroids,cluster_assignment)
             record_heterogeneity.append(score)
-        
+
         prev_cluster_assignment = cluster_assignment[:]
-        
+
     return centroids, cluster_assignment
 
 # Mock test below
diff --git a/machine_learning/linear_regression.py b/machine_learning/linear_regression.py
index 03f16629e451..9d9738fced8d 100644
--- a/machine_learning/linear_regression.py
+++ b/machine_learning/linear_regression.py
@@ -7,8 +7,6 @@
 fits our dataset. In this particular code, i had used a CSGO dataset (ADR vs
 Rating). We try to best fit a line through dataset and estimate the parameters.
 """
-from __future__ import print_function
-
 import requests
 import numpy as np
 
diff --git a/maths/simpson_rule.py b/maths/simpson_rule.py
index 2b237d2e1a4e..5cf9c14b07ee 100644
--- a/maths/simpson_rule.py
+++ b/maths/simpson_rule.py
@@ -8,9 +8,6 @@
 "Simpson Rule"
 
 """
-from __future__ import print_function
-
-
 def method_2(boundary, steps):
 # "Simpson Rule"
 # int(f) = delta_x/2 * (b-a)/3*(f1 + 4f2 + 2f_3 + ... + fn)
diff --git a/maths/trapezoidal_rule.py b/maths/trapezoidal_rule.py
index 789f263c6991..f5e5fbbc2662 100644
--- a/maths/trapezoidal_rule.py
+++ b/maths/trapezoidal_rule.py
@@ -7,8 +7,6 @@
 "extended trapezoidal rule"
 
 """
-from __future__ import print_function
-
 def method_1(boundary, steps):
 # "extended trapezoidal rule"
 # int(f) = dx/2 * (f1 + 2f2 + ... + fn)
@@ -19,7 +17,7 @@ def method_1(boundary, steps):
 	y = 0.0
 	y += (h/2.0)*f(a)
 	for i in x_i:
-		#print(i)	
+		#print(i)
 		y += h*f(i)
 	y += (h/2.0)*f(b)
 	return y
diff --git a/maths/zellers_congruence.py b/maths/zellers_congruence.py
index e04425eec903..67c5550802ea 100644
--- a/maths/zellers_congruence.py
+++ b/maths/zellers_congruence.py
@@ -1,4 +1,3 @@
-from __future__ import annotations
 import datetime
 import argparse
 
@@ -7,7 +6,7 @@ def zeller(date_input: str) -> str:
 
     """
     Zellers Congruence Algorithm
-    Find the day of the week for nearly any Gregorian or Julian calendar date 
+    Find the day of the week for nearly any Gregorian or Julian calendar date
 
     >>> zeller('01-31-2010')
     'Your date 01-31-2010, is a Sunday!'
@@ -108,7 +107,7 @@ def zeller(date_input: str) -> str:
     # Validate
     if not 0 < d < 32:
         raise ValueError("Date must be between 1 - 31")
-    
+
     # Get second seperator
     sep_2: str = date_input[5]
     # Validate
diff --git a/matrix/nth_fibonacci_using_matrix_exponentiation.py b/matrix/nth_fibonacci_using_matrix_exponentiation.py
index 7491abcae031..57cdfacd47dd 100644
--- a/matrix/nth_fibonacci_using_matrix_exponentiation.py
+++ b/matrix/nth_fibonacci_using_matrix_exponentiation.py
@@ -13,9 +13,6 @@
 So we just need the n times multiplication of the matrix [1,1],[1,0]].
 We can decrease the n times multiplication by following the divide and conquer approach.
 """
-from __future__ import print_function
-
-
 def multiply(matrix_a, matrix_b):
     matrix_c = []
     n = len(matrix_a)
diff --git a/neural_network/convolution_neural_network.py b/neural_network/convolution_neural_network.py
index 0e72f0c0dca2..e4dd0a11db9d 100644
--- a/neural_network/convolution_neural_network.py
+++ b/neural_network/convolution_neural_network.py
@@ -15,8 +15,6 @@
     Date: 2017.9.20
     - - - - - -- - - - - - - - - - - - - - - - - - - - - - -
 '''
-from __future__ import print_function
-
 import pickle
 import numpy as np
 import matplotlib.pyplot as plt
diff --git a/neural_network/perceptron.py b/neural_network/perceptron.py
index 871eca20273b..fdc710597241 100644
--- a/neural_network/perceptron.py
+++ b/neural_network/perceptron.py
@@ -9,8 +9,6 @@
     p2 = 1
 
 '''
-from __future__ import print_function
-
 import random
 
 
diff --git a/other/anagrams.py b/other/anagrams.py
index 29b34fbdc5d3..1e6e38dee139 100644
--- a/other/anagrams.py
+++ b/other/anagrams.py
@@ -1,4 +1,3 @@
-from __future__ import print_function
 import collections, pprint, time, os
 
 start_time = time.time()
diff --git a/other/euclidean_gcd.py b/other/euclidean_gcd.py
index 30853e172076..13378379f286 100644
--- a/other/euclidean_gcd.py
+++ b/other/euclidean_gcd.py
@@ -1,4 +1,3 @@
-from __future__ import print_function
 # https://en.wikipedia.org/wiki/Euclidean_algorithm
 
 def euclidean_gcd(a, b):
diff --git a/other/linear_congruential_generator.py b/other/linear_congruential_generator.py
index 34abdf34eaf3..7c592a6400b5 100644
--- a/other/linear_congruential_generator.py
+++ b/other/linear_congruential_generator.py
@@ -1,4 +1,3 @@
-from __future__ import print_function
 __author__ = "Tobias Carryer"
 
 from time import time
@@ -7,11 +6,11 @@ class LinearCongruentialGenerator(object):
     """
     A pseudorandom number generator.
     """
-    
+
     def __init__( self, multiplier, increment, modulo, seed=int(time()) ):
         """
         These parameters are saved and used when nextNumber() is called.
-     
+
         modulo is the largest number that can be generated (exclusive). The most
         efficent values are powers of 2. 2^32 is a common value.
         """
@@ -19,7 +18,7 @@ def __init__( self, multiplier, increment, modulo, seed=int(time()) ):
         self.increment = increment
         self.modulo = modulo
         self.seed = seed
-        
+
     def next_number( self ):
         """
         The smallest number that can be generated is zero.
diff --git a/other/nested_brackets.py b/other/nested_brackets.py
index 76677d56439a..14147eaa6456 100644
--- a/other/nested_brackets.py
+++ b/other/nested_brackets.py
@@ -13,9 +13,6 @@
 returns true if S is nested and false otherwise.
 
 '''
-from __future__ import print_function
-
-
 def is_balanced(S):
 
     stack = []
diff --git a/other/password_generator.py b/other/password_generator.py
index fd0701041240..16b7e16b22a1 100644
--- a/other/password_generator.py
+++ b/other/password_generator.py
@@ -1,5 +1,4 @@
 """Password generator allows you to generate a random password of length N."""
-from __future__ import print_function
 from random import choice
 from string import ascii_letters, digits, punctuation
 
diff --git a/other/tower_of_hanoi.py b/other/tower_of_hanoi.py
index 9cc5b9e40543..cd6fbf4d88ac 100644
--- a/other/tower_of_hanoi.py
+++ b/other/tower_of_hanoi.py
@@ -1,5 +1,4 @@
-from __future__ import print_function
-def moveTower(height, fromPole, toPole, withPole):  
+def moveTower(height, fromPole, toPole, withPole):
     '''
     >>> moveTower(3, 'A', 'B', 'C')
     moving disk from A to B
diff --git a/other/two_sum.py b/other/two_sum.py
index d4484aa85505..b784da82767a 100644
--- a/other/two_sum.py
+++ b/other/two_sum.py
@@ -9,8 +9,6 @@
 Because nums[0] + nums[1] = 2 + 7 = 9,
 return [0, 1].
 """
-from __future__ import print_function
-
 def twoSum(nums, target):
     """
     :type nums: List[int]
@@ -20,7 +18,7 @@ def twoSum(nums, target):
     chk_map = {}
     for index, val in enumerate(nums):
       compl = target - val
-      if compl in chk_map: 
+      if compl in chk_map:
         indices = [chk_map[compl], index]
         print(indices)
         return [indices]
diff --git a/other/word_patterns.py b/other/word_patterns.py
index c33d520087f7..1364d1277255 100644
--- a/other/word_patterns.py
+++ b/other/word_patterns.py
@@ -1,4 +1,3 @@
-from __future__ import print_function
 import pprint, time
 
 def getWordPattern(word):
diff --git a/project_euler/problem_01/sol1.py b/project_euler/problem_01/sol1.py
index 1433129af303..76b13b852c87 100644
--- a/project_euler/problem_01/sol1.py
+++ b/project_euler/problem_01/sol1.py
@@ -4,17 +4,9 @@
 we get 3,5,6 and 9. The sum of these multiples is 23.
 Find the sum of all the multiples of 3 or 5 below N.
 """
-from __future__ import print_function
-
-try:
-    raw_input  # Python 2
-except NameError:
-    raw_input = input  # Python 3
-
-
 def solution(n):
     """Returns the sum of all the multiples of 3 or 5 below n.
-    
+
     >>> solution(3)
     0
     >>> solution(4)
@@ -31,4 +23,4 @@ def solution(n):
 
 
 if __name__ == "__main__":
-    print(solution(int(raw_input().strip())))
+    print(solution(int(input().strip())))
diff --git a/project_euler/problem_01/sol2.py b/project_euler/problem_01/sol2.py
index e58fb03a8fb0..8041c7ffa589 100644
--- a/project_euler/problem_01/sol2.py
+++ b/project_euler/problem_01/sol2.py
@@ -4,17 +4,11 @@
 we get 3,5,6 and 9. The sum of these multiples is 23.
 Find the sum of all the multiples of 3 or 5 below N.
 """
-from __future__ import print_function
-
-try:
-    raw_input  # Python 2
-except NameError:
-    raw_input = input  # Python 3
 
 
 def solution(n):
     """Returns the sum of all the multiples of 3 or 5 below n.
-    
+
     >>> solution(3)
     0
     >>> solution(4)
@@ -36,4 +30,4 @@ def solution(n):
 
 
 if __name__ == "__main__":
-    print(solution(int(raw_input().strip())))
+    print(solution(int(input().strip())))
diff --git a/project_euler/problem_01/sol3.py b/project_euler/problem_01/sol3.py
index 013ce5e54fdf..532203ddd95d 100644
--- a/project_euler/problem_01/sol3.py
+++ b/project_euler/problem_01/sol3.py
@@ -4,20 +4,12 @@
 we get 3,5,6 and 9. The sum of these multiples is 23.
 Find the sum of all the multiples of 3 or 5 below N.
 """
-from __future__ import print_function
-
-try:
-    raw_input  # Python 2
-except NameError:
-    raw_input = input  # Python 3
-
-
 def solution(n):
     """
     This solution is based on the pattern that the successive numbers in the
     series follow: 0+3,+2,+1,+3,+1,+2,+3.
     Returns the sum of all the multiples of 3 or 5 below n.
-    
+
     >>> solution(3)
     0
     >>> solution(4)
@@ -63,4 +55,4 @@ def solution(n):
 
 
 if __name__ == "__main__":
-    print(solution(int(raw_input().strip())))
+    print(solution(int(input().strip())))
diff --git a/project_euler/problem_01/sol4.py b/project_euler/problem_01/sol4.py
index 90403c3bd6a3..3e6712618870 100644
--- a/project_euler/problem_01/sol4.py
+++ b/project_euler/problem_01/sol4.py
@@ -4,17 +4,9 @@
 we get 3,5,6 and 9. The sum of these multiples is 23.
 Find the sum of all the multiples of 3 or 5 below N.
 """
-from __future__ import print_function
-
-try:
-    raw_input  # Python 2
-except NameError:
-    raw_input = input  # Python 3
-
-
 def solution(n):
     """Returns the sum of all the multiples of 3 or 5 below n.
-    
+
     >>> solution(3)
     0
     >>> solution(4)
@@ -50,4 +42,4 @@ def solution(n):
 
 
 if __name__ == "__main__":
-    print(solution(int(raw_input().strip())))
+    print(solution(int(input().strip())))
diff --git a/project_euler/problem_01/sol5.py b/project_euler/problem_01/sol5.py
index 302fe44f8bfa..bd96d965f92d 100644
--- a/project_euler/problem_01/sol5.py
+++ b/project_euler/problem_01/sol5.py
@@ -4,19 +4,13 @@
 we get 3,5,6 and 9. The sum of these multiples is 23.
 Find the sum of all the multiples of 3 or 5 below N.
 """
-from __future__ import print_function
-
-try:
-    raw_input  # Python 2
-except NameError:
-    raw_input = input  # Python 3
 
 """A straightforward pythonic solution using list comprehension"""
 
 
 def solution(n):
     """Returns the sum of all the multiples of 3 or 5 below n.
-    
+
     >>> solution(3)
     0
     >>> solution(4)
@@ -31,4 +25,4 @@ def solution(n):
 
 
 if __name__ == "__main__":
-    print(solution(int(raw_input().strip())))
+    print(solution(int(input().strip())))
diff --git a/project_euler/problem_01/sol6.py b/project_euler/problem_01/sol6.py
index cf6e751d4c05..b9c3db4f8550 100644
--- a/project_euler/problem_01/sol6.py
+++ b/project_euler/problem_01/sol6.py
@@ -4,17 +4,9 @@
 we get 3,5,6 and 9. The sum of these multiples is 23.
 Find the sum of all the multiples of 3 or 5 below N.
 """
-from __future__ import print_function
-
-try:
-    raw_input  # Python 2
-except NameError:
-    raw_input = input  # Python 3
-
-
 def solution(n):
     """Returns the sum of all the multiples of 3 or 5 below n.
-    
+
     >>> solution(3)
     0
     >>> solution(4)
@@ -37,4 +29,4 @@ def solution(n):
 
 
 if __name__ == "__main__":
-    print(solution(int(raw_input().strip())))
+    print(solution(int(input().strip())))
diff --git a/project_euler/problem_02/sol1.py b/project_euler/problem_02/sol1.py
index f61d04e3dfce..d2ad67e2f424 100644
--- a/project_euler/problem_02/sol1.py
+++ b/project_euler/problem_02/sol1.py
@@ -9,18 +9,10 @@
 n, find the sum of the even-valued terms. e.g. for n=10, we have {2,8}, sum is
 10.
 """
-from __future__ import print_function
-
-try:
-    raw_input  # Python 2
-except NameError:
-    raw_input = input  # Python 3
-
-
 def solution(n):
     """Returns the sum of all fibonacci sequence even elements that are lower
     or equals to n.
-    
+
     >>> solution(10)
     10
     >>> solution(15)
@@ -44,4 +36,4 @@ def solution(n):
 
 
 if __name__ == "__main__":
-    print(solution(int(raw_input().strip())))
+    print(solution(int(input().strip())))
diff --git a/project_euler/problem_02/sol2.py b/project_euler/problem_02/sol2.py
index 3e103a6a4373..71f51b695e84 100644
--- a/project_euler/problem_02/sol2.py
+++ b/project_euler/problem_02/sol2.py
@@ -9,18 +9,10 @@
 n, find the sum of the even-valued terms. e.g. for n=10, we have {2,8}, sum is
 10.
 """
-from __future__ import print_function
-
-try:
-    raw_input  # Python 2
-except NameError:
-    raw_input = input  # Python 3
-
-
 def solution(n):
     """Returns the sum of all fibonacci sequence even elements that are lower
     or equals to n.
-    
+
     >>> solution(10)
     [2, 8]
     >>> solution(15)
@@ -42,4 +34,4 @@ def solution(n):
 
 
 if __name__ == "__main__":
-    print(solution(int(raw_input().strip())))
+    print(solution(int(input().strip())))
diff --git a/project_euler/problem_02/sol3.py b/project_euler/problem_02/sol3.py
index abd9d6c753b8..c698b8e38ab2 100644
--- a/project_euler/problem_02/sol3.py
+++ b/project_euler/problem_02/sol3.py
@@ -9,18 +9,10 @@
 n, find the sum of the even-valued terms. e.g. for n=10, we have {2,8}, sum is
 10.
 """
-from __future__ import print_function
-
-try:
-    raw_input  # Python 2
-except NameError:
-    raw_input = input  # Python 3
-
-
 def solution(n):
     """Returns the sum of all fibonacci sequence even elements that are lower
     or equals to n.
-    
+
     >>> solution(10)
     10
     >>> solution(15)
@@ -44,4 +36,4 @@ def solution(n):
 
 
 if __name__ == "__main__":
-    print(solution(int(raw_input().strip())))
+    print(solution(int(input().strip())))
diff --git a/project_euler/problem_02/sol4.py b/project_euler/problem_02/sol4.py
index 5e8c04899f3d..92ea0a51e026 100644
--- a/project_euler/problem_02/sol4.py
+++ b/project_euler/problem_02/sol4.py
@@ -9,20 +9,14 @@
 n, find the sum of the even-valued terms. e.g. for n=10, we have {2,8}, sum is
 10.
 """
-from __future__ import print_function
 import math
 from decimal import Decimal, getcontext
 
-try:
-    raw_input  # Python 2
-except NameError:
-    raw_input = input  # Python 3
-
 
 def solution(n):
     """Returns the sum of all fibonacci sequence even elements that are lower
     or equals to n.
-    
+
     >>> solution(10)
     10
     >>> solution(15)
@@ -68,4 +62,4 @@ def solution(n):
 
 
 if __name__ == "__main__":
-    print(solution(int(raw_input().strip())))
+    print(solution(int(input().strip())))
diff --git a/project_euler/problem_03/sol1.py b/project_euler/problem_03/sol1.py
index ab19d8b30457..9f8ecc5e6565 100644
--- a/project_euler/problem_03/sol1.py
+++ b/project_euler/problem_03/sol1.py
@@ -5,14 +5,8 @@
 
 e.g. for 10, largest prime factor = 5. For 17, largest prime factor = 17.
 """
-from __future__ import print_function, division
 import math
 
-try:
-    raw_input  # Python 2
-except NameError:
-    raw_input = input  # Python 3
-
 
 def isprime(no):
     if no == 2:
@@ -81,4 +75,4 @@ def solution(n):
 
 
 if __name__ == "__main__":
-    print(solution(int(raw_input().strip())))
+    print(solution(int(input().strip())))
diff --git a/project_euler/problem_03/sol2.py b/project_euler/problem_03/sol2.py
index f93a0b75f4e0..b6fad079fa31 100644
--- a/project_euler/problem_03/sol2.py
+++ b/project_euler/problem_03/sol2.py
@@ -5,12 +5,6 @@
 
 e.g. for 10, largest prime factor = 5. For 17, largest prime factor = 17.
 """
-from __future__ import print_function, division
-
-try:
-    raw_input  # Python 2
-except NameError:
-    raw_input = input  # Python 3
 
 
 def solution(n):
@@ -60,4 +54,4 @@ def solution(n):
 
 
 if __name__ == "__main__":
-    print(solution(int(raw_input().strip())))
+    print(solution(int(input().strip())))
diff --git a/project_euler/problem_04/sol1.py b/project_euler/problem_04/sol1.py
index 7a255f7308e6..51417b146bbf 100644
--- a/project_euler/problem_04/sol1.py
+++ b/project_euler/problem_04/sol1.py
@@ -6,18 +6,10 @@
 Find the largest palindrome made from the product of two 3-digit numbers which
 is less than N.
 """
-from __future__ import print_function
-
-try:
-    raw_input  # Python 2
-except NameError:
-    raw_input = input  # Python 3
-
-
 def solution(n):
     """Returns the largest palindrome made from the product of two 3-digit
     numbers which is less than n.
-    
+
     >>> solution(20000)
     19591
     >>> solution(30000)
@@ -47,4 +39,4 @@ def solution(n):
 
 
 if __name__ == "__main__":
-    print(solution(int(raw_input().strip())))
+    print(solution(int(input().strip())))
diff --git a/project_euler/problem_04/sol2.py b/project_euler/problem_04/sol2.py
index 45c6b256daf8..8740ee44a4b4 100644
--- a/project_euler/problem_04/sol2.py
+++ b/project_euler/problem_04/sol2.py
@@ -6,18 +6,10 @@
 Find the largest palindrome made from the product of two 3-digit numbers which
 is less than N.
 """
-from __future__ import print_function
-
-try:
-    raw_input  # Python 2
-except NameError:
-    raw_input = input  # Python 3
-
-
 def solution(n):
     """Returns the largest palindrome made from the product of two 3-digit
     numbers which is less than n.
-    
+
     >>> solution(20000)
     19591
     >>> solution(30000)
@@ -35,4 +27,4 @@ def solution(n):
 
 
 if __name__ == "__main__":
-    print(solution(int(raw_input().strip())))
+    print(solution(int(input().strip())))
diff --git a/project_euler/problem_05/sol1.py b/project_euler/problem_05/sol1.py
index e2deb91fb6aa..83c387e4ae6e 100644
--- a/project_euler/problem_05/sol1.py
+++ b/project_euler/problem_05/sol1.py
@@ -6,14 +6,6 @@
 What is the smallest positive number that is evenly divisible(divisible with no
 remainder) by all of the numbers from 1 to N?
 """
-from __future__ import print_function
-
-try:
-    raw_input  # Python 2
-except NameError:
-    raw_input = input  # Python 3
-
-
 def solution(n):
     """Returns the smallest positive number that is evenly divisible(divisible
     with no remainder) by all of the numbers from 1 to n.
@@ -66,4 +58,4 @@ def solution(n):
 
 
 if __name__ == "__main__":
-    print(solution(int(raw_input().strip())))
+    print(solution(int(input().strip())))
diff --git a/project_euler/problem_05/sol2.py b/project_euler/problem_05/sol2.py
index 293dd96f2294..5aa84d21c8e8 100644
--- a/project_euler/problem_05/sol2.py
+++ b/project_euler/problem_05/sol2.py
@@ -6,13 +6,6 @@
 What is the smallest positive number that is evenly divisible(divisible with no
 remainder) by all of the numbers from 1 to N?
 """
-from __future__ import print_function
-
-try:
-    raw_input  # Python 2
-except NameError:
-    raw_input = input  # Python 3
-
 """ Euclidean GCD Algorithm """
 
 
@@ -30,7 +23,7 @@ def lcm(x, y):
 def solution(n):
     """Returns the smallest positive number that is evenly divisible(divisible
     with no remainder) by all of the numbers from 1 to n.
-    
+
     >>> solution(10)
     2520
     >>> solution(15)
@@ -47,4 +40,4 @@ def solution(n):
 
 
 if __name__ == "__main__":
-    print(solution(int(raw_input().strip())))
+    print(solution(int(input().strip())))
diff --git a/project_euler/problem_06/sol1.py b/project_euler/problem_06/sol1.py
index 728701e167c3..0a964272e7e8 100644
--- a/project_euler/problem_06/sol1.py
+++ b/project_euler/problem_06/sol1.py
@@ -14,18 +14,10 @@
 Find the difference between the sum of the squares of the first N natural
 numbers and the square of the sum.
 """
-from __future__ import print_function
-
-try:
-    raw_input  # Python 2
-except NameError:
-    raw_input = input  # Python 3
-
-
 def solution(n):
     """Returns the difference between the sum of the squares of the first n
     natural numbers and the square of the sum.
- 
+
     >>> solution(10)
     2640
     >>> solution(15)
@@ -45,4 +37,4 @@ def solution(n):
 
 
 if __name__ == "__main__":
-    print(solution(int(raw_input().strip())))
+    print(solution(int(input().strip())))
diff --git a/project_euler/problem_06/sol2.py b/project_euler/problem_06/sol2.py
index 2c64812d56f8..45d08d244647 100644
--- a/project_euler/problem_06/sol2.py
+++ b/project_euler/problem_06/sol2.py
@@ -14,18 +14,10 @@
 Find the difference between the sum of the squares of the first N natural
 numbers and the square of the sum.
 """
-from __future__ import print_function
-
-try:
-    raw_input  # Python 2
-except NameError:
-    raw_input = input  # Python 3
-
-
 def solution(n):
     """Returns the difference between the sum of the squares of the first n
     natural numbers and the square of the sum.
- 
+
     >>> solution(10)
     2640
     >>> solution(15)
@@ -42,4 +34,4 @@ def solution(n):
 
 
 if __name__ == "__main__":
-    print(solution(int(raw_input().strip())))
+    print(solution(int(input().strip())))
diff --git a/project_euler/problem_06/sol3.py b/project_euler/problem_06/sol3.py
index 7d94b1e2254f..f9c5dacb3777 100644
--- a/project_euler/problem_06/sol3.py
+++ b/project_euler/problem_06/sol3.py
@@ -14,19 +14,13 @@
 Find the difference between the sum of the squares of the first N natural
 numbers and the square of the sum.
 """
-from __future__ import print_function
 import math
 
-try:
-    raw_input  # Python 2
-except NameError:
-    raw_input = input  # Python 3
-
 
 def solution(n):
     """Returns the difference between the sum of the squares of the first n
     natural numbers and the square of the sum.
- 
+
     >>> solution(10)
     2640
     >>> solution(15)
@@ -42,4 +36,4 @@ def solution(n):
 
 
 if __name__ == "__main__":
-    print(solution(int(raw_input().strip())))
+    print(solution(int(input().strip())))
diff --git a/project_euler/problem_07/sol1.py b/project_euler/problem_07/sol1.py
index 403ded568dda..d8d67e157860 100644
--- a/project_euler/problem_07/sol1.py
+++ b/project_euler/problem_07/sol1.py
@@ -6,14 +6,8 @@
 
 We can see that the 6th prime is 13. What is the Nth prime number?
 """
-from __future__ import print_function
 from math import sqrt
 
-try:
-    raw_input  # Python 2
-except NameError:
-    raw_input = input  # Python 3
-
 
 def isprime(n):
     if n == 2:
@@ -30,7 +24,7 @@ def isprime(n):
 
 def solution(n):
     """Returns the n-th prime number.
- 
+
     >>> solution(6)
     13
     >>> solution(1)
@@ -58,4 +52,4 @@ def solution(n):
 
 
 if __name__ == "__main__":
-    print(solution(int(raw_input().strip())))
+    print(solution(int(input().strip())))
diff --git a/project_euler/problem_07/sol2.py b/project_euler/problem_07/sol2.py
index 67336f7c1c96..7d078af32176 100644
--- a/project_euler/problem_07/sol2.py
+++ b/project_euler/problem_07/sol2.py
@@ -6,14 +6,6 @@
 
 We can see that the 6th prime is 13. What is the Nth prime number?
 """
-from __future__ import print_function
-
-try:
-    raw_input  # Python 2
-except NameError:
-    raw_input = input  # Python 3
-
-
 def isprime(number):
     for i in range(2, int(number ** 0.5) + 1):
         if number % i == 0:
@@ -23,7 +15,7 @@ def isprime(number):
 
 def solution(n):
     """Returns the n-th prime number.
- 
+
     >>> solution(6)
     13
     >>> solution(1)
@@ -73,4 +65,4 @@ def solution(n):
 
 
 if __name__ == "__main__":
-    print(solution(int(raw_input().strip())))
+    print(solution(int(input().strip())))
diff --git a/project_euler/problem_07/sol3.py b/project_euler/problem_07/sol3.py
index bc94762604b3..3c28ecf7fb34 100644
--- a/project_euler/problem_07/sol3.py
+++ b/project_euler/problem_07/sol3.py
@@ -6,15 +6,9 @@
 
 We can see that the 6th prime is 13. What is the Nth prime number?
 """
-from __future__ import print_function
 import math
 import itertools
 
-try:
-    raw_input  # Python 2
-except NameError:
-    raw_input = input  # Python 3
-
 
 def primeCheck(number):
     if number % 2 == 0 and number > 2:
@@ -32,7 +26,7 @@ def prime_generator():
 
 def solution(n):
     """Returns the n-th prime number.
- 
+
     >>> solution(6)
     13
     >>> solution(1)
@@ -50,4 +44,4 @@ def solution(n):
 
 
 if __name__ == "__main__":
-    print(solution(int(raw_input().strip())))
+    print(solution(int(input().strip())))
diff --git a/project_euler/problem_09/sol1.py b/project_euler/problem_09/sol1.py
index d9ebe8760861..3bb5c968115d 100644
--- a/project_euler/problem_09/sol1.py
+++ b/project_euler/problem_09/sol1.py
@@ -7,7 +7,6 @@
 There exists exactly one Pythagorean triplet for which a + b + c = 1000.
 Find the product abc.
 """
-from __future__ import print_function
 
 
 def solution():
@@ -17,7 +16,7 @@ def solution():
      1. a < b < c
      2. a**2 + b**2 = c**2
      3. a + b + c = 1000
-    
+
     # The code below has been commented due to slow execution affecting Travis.
     # >>> solution()
     # 31875000
diff --git a/project_euler/problem_09/sol2.py b/project_euler/problem_09/sol2.py
index 674daae9ec8e..502f334417c8 100644
--- a/project_euler/problem_09/sol2.py
+++ b/project_euler/problem_09/sol2.py
@@ -7,14 +7,6 @@
 There exists exactly one Pythagorean triplet for which a + b + c = 1000.
 Find the product abc.
 """
-from __future__ import print_function
-
-try:
-    raw_input  # Python 2
-except NameError:
-    raw_input = input  # Python 3
-
-
 def solution(n):
     """
      Return the product of a,b,c which are Pythagorean Triplet that satisfies
@@ -22,7 +14,7 @@ def solution(n):
      1. a < b < c
      2. a**2 + b**2 = c**2
      3. a + b + c = 1000
-    
+
     >>> solution(1000)
     31875000
     """
@@ -41,4 +33,4 @@ def solution(n):
 
 
 if __name__ == "__main__":
-    print(solution(int(raw_input().strip())))
+    print(solution(int(input().strip())))
diff --git a/project_euler/problem_09/sol3.py b/project_euler/problem_09/sol3.py
index 006029c8a30d..bbe7dcf743e7 100644
--- a/project_euler/problem_09/sol3.py
+++ b/project_euler/problem_09/sol3.py
@@ -10,9 +10,6 @@
 There exists exactly one Pythagorean triplet for which a + b + c = 1000.
 Find the product abc.
 """
-from __future__ import print_function
-
-
 def solution():
     """
      Returns the product of a,b,c which are Pythagorean Triplet that satisfies
diff --git a/project_euler/problem_10/sol1.py b/project_euler/problem_10/sol1.py
index 49384d7c78f0..c81085951ecf 100644
--- a/project_euler/problem_10/sol1.py
+++ b/project_euler/problem_10/sol1.py
@@ -4,22 +4,11 @@
 
 Find the sum of all the primes below two million.
 """
-from __future__ import print_function
 from math import sqrt
 
-try:
-    raw_input  # Python 2
-except NameError:
-    raw_input = input  # Python 3
-
-try:
-    xrange  # Python 2
-except NameError:
-    xrange = range  # Python 3
-
 
 def is_prime(n):
-    for i in xrange(2, int(sqrt(n)) + 1):
+    for i in range(2, int(sqrt(n)) + 1):
         if n % i == 0:
             return False
 
@@ -32,7 +21,7 @@ def sum_of_primes(n):
     else:
         return 0
 
-    for i in xrange(3, n, 2):
+    for i in range(3, n, 2):
         if is_prime(i):
             sumOfPrimes += i
 
@@ -41,7 +30,7 @@ def sum_of_primes(n):
 
 def solution(n):
     """Returns the sum of all the primes below n.
-    
+
     # The code below has been commented due to slow execution affecting Travis.
     # >>> solution(2000000)
     # 142913828922
@@ -58,4 +47,4 @@ def solution(n):
 
 
 if __name__ == "__main__":
-    print(solution(int(raw_input().strip())))
+    print(solution(int(input().strip())))
diff --git a/project_euler/problem_10/sol2.py b/project_euler/problem_10/sol2.py
index 451a4ae5e8f3..b2e2b6e1adf3 100644
--- a/project_euler/problem_10/sol2.py
+++ b/project_euler/problem_10/sol2.py
@@ -4,15 +4,9 @@
 
 Find the sum of all the primes below two million.
 """
-from __future__ import print_function
 import math
 from itertools import takewhile
 
-try:
-    raw_input  # Python 2
-except NameError:
-    raw_input = input  # Python 3
-
 
 def primeCheck(number):
     if number % 2 == 0 and number > 2:
@@ -30,7 +24,7 @@ def prime_generator():
 
 def solution(n):
     """Returns the sum of all the primes below n.
-    
+
     # The code below has been commented due to slow execution affecting Travis.
     # >>> solution(2000000)
     # 142913828922
@@ -47,4 +41,4 @@ def solution(n):
 
 
 if __name__ == "__main__":
-    print(solution(int(raw_input().strip())))
+    print(solution(int(input().strip())))
diff --git a/project_euler/problem_11/sol1.py b/project_euler/problem_11/sol1.py
index 3bdddc89d917..1473439ae00d 100644
--- a/project_euler/problem_11/sol1.py
+++ b/project_euler/problem_11/sol1.py
@@ -24,14 +24,8 @@
 01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48
 """
 
-from __future__ import print_function
 import os
 
-try:
-    xrange  # Python 2
-except NameError:
-    xrange = range  # Python 2
-
 
 def largest_product(grid):
     nColumns = len(grid[0])
@@ -43,8 +37,8 @@ def largest_product(grid):
 
     # Check vertically, horizontally, diagonally at the same time (only works
     # for nxn grid)
-    for i in xrange(nColumns):
-        for j in xrange(nRows - 3):
+    for i in range(nColumns):
+        for j in range(nRows - 3):
             vertProduct = (
                 grid[j][i] * grid[j + 1][i] * grid[j + 2][i] * grid[j + 3][i]
             )
@@ -81,7 +75,7 @@ def largest_product(grid):
 
 def solution():
     """Returns the sum of all the multiples of 3 or 5 below n.
-    
+
     >>> solution()
     70600674
     """
@@ -90,7 +84,7 @@ def solution():
         for line in file:
             grid.append(line.strip("\n").split(" "))
 
-    grid = [[int(i) for i in grid[j]] for j in xrange(len(grid))]
+    grid = [[int(i) for i in grid[j]] for j in range(len(grid))]
 
     return largest_product(grid)
 
diff --git a/project_euler/problem_11/sol2.py b/project_euler/problem_11/sol2.py
index 0a5785b42b2c..be6c11a378ad 100644
--- a/project_euler/problem_11/sol2.py
+++ b/project_euler/problem_11/sol2.py
@@ -24,45 +24,39 @@
 01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48
 """
 
-from __future__ import print_function
 import os
 
-try:
-    xrange  # Python 2
-except NameError:
-    xrange = range  # Python 2
-
 
 def solution():
     """Returns the sum of all the multiples of 3 or 5 below n.
-    
+
     >>> solution()
     70600674
     """
     with open(os.path.dirname(__file__) + "/grid.txt") as f:
         l = []
-        for i in xrange(20):
+        for i in range(20):
             l.append([int(x) for x in f.readline().split()])
 
         maximum = 0
 
         # right
-        for i in xrange(20):
-            for j in xrange(17):
+        for i in range(20):
+            for j in range(17):
                 temp = l[i][j] * l[i][j + 1] * l[i][j + 2] * l[i][j + 3]
                 if temp > maximum:
                     maximum = temp
 
         # down
-        for i in xrange(17):
-            for j in xrange(20):
+        for i in range(17):
+            for j in range(20):
                 temp = l[i][j] * l[i + 1][j] * l[i + 2][j] * l[i + 3][j]
                 if temp > maximum:
                     maximum = temp
 
         # diagonal 1
-        for i in xrange(17):
-            for j in xrange(17):
+        for i in range(17):
+            for j in range(17):
                 temp = (
                     l[i][j]
                     * l[i + 1][j + 1]
@@ -73,8 +67,8 @@ def solution():
                     maximum = temp
 
         # diagonal 2
-        for i in xrange(17):
-            for j in xrange(3, 20):
+        for i in range(17):
+            for j in range(3, 20):
                 temp = (
                     l[i][j]
                     * l[i + 1][j - 1]
diff --git a/project_euler/problem_12/sol1.py b/project_euler/problem_12/sol1.py
index 54476110b503..7e080c4e45a1 100644
--- a/project_euler/problem_12/sol1.py
+++ b/project_euler/problem_12/sol1.py
@@ -21,18 +21,12 @@
 What is the value of the first triangle number to have over five hundred
 divisors?
 """
-from __future__ import print_function
 from math import sqrt
 
-try:
-    xrange  # Python 2
-except NameError:
-    xrange = range  # Python 3
-
 
 def count_divisors(n):
     nDivisors = 0
-    for i in xrange(1, int(sqrt(n)) + 1):
+    for i in range(1, int(sqrt(n)) + 1):
         if n % i == 0:
             nDivisors += 2
     # check if n is perfect square
@@ -44,7 +38,7 @@ def count_divisors(n):
 def solution():
     """Returns the value of the first triangle number to have over five hundred
     divisors.
-    
+
     # The code below has been commented due to slow execution affecting Travis.
     # >>> solution()
     # 76576500
diff --git a/project_euler/problem_12/sol2.py b/project_euler/problem_12/sol2.py
index 0d1502830bee..97a4910723ac 100644
--- a/project_euler/problem_12/sol2.py
+++ b/project_euler/problem_12/sol2.py
@@ -21,9 +21,6 @@
 What is the value of the first triangle number to have over five hundred
 divisors?
 """
-from __future__ import print_function
-
-
 def triangle_number_generator():
     for n in range(1, 1000000):
         yield n * (n + 1) // 2
@@ -38,7 +35,7 @@ def count_divisors(n):
 def solution():
     """Returns the value of the first triangle number to have over five hundred
     divisors.
-    
+
     # The code below has been commented due to slow execution affecting Travis.
     # >>> solution()
     # 76576500
diff --git a/project_euler/problem_14/sol1.py b/project_euler/problem_14/sol1.py
index 8d3efbc59eb5..156322b7d507 100644
--- a/project_euler/problem_14/sol1.py
+++ b/project_euler/problem_14/sol1.py
@@ -16,20 +16,12 @@
 
 Which starting number, under one million, produces the longest chain?
 """
-from __future__ import print_function
-
-try:
-    raw_input  # Python 2
-except NameError:
-    raw_input = input  # Python 3
-
-
 def solution(n):
     """Returns the number under n that generates the longest sequence using the
     formula:
     n → n/2 (n is even)
     n → 3n + 1 (n is odd)
- 
+
     # The code below has been commented due to slow execution affecting Travis.
     # >>> solution(1000000)
     # {'counter': 525, 'largest_number': 837799}
@@ -62,7 +54,7 @@ def solution(n):
 
 
 if __name__ == "__main__":
-    result = solution(int(raw_input().strip()))
+    result = solution(int(input().strip()))
     print(
         (
             "Largest Number:",
diff --git a/project_euler/problem_14/sol2.py b/project_euler/problem_14/sol2.py
index 0ec80e221f09..25ebd41571c2 100644
--- a/project_euler/problem_14/sol2.py
+++ b/project_euler/problem_14/sol2.py
@@ -24,14 +24,6 @@
 
 Which starting number, under one million, produces the longest chain?
 """
-from __future__ import print_function
-
-try:
-    raw_input  # Python 2
-except NameError:
-    raw_input = input  # Python 3
-
-
 def collatz_sequence(n):
     """Returns the Collatz sequence for n."""
     sequence = [n]
@@ -63,7 +55,7 @@ def solution(n):
 
 
 if __name__ == "__main__":
-    result = solution(int(raw_input().strip()))
+    result = solution(int(input().strip()))
     print(
         "Longest Collatz sequence under one million is %d with length %d"
         % (result["largest_number"], result["counter"])
diff --git a/project_euler/problem_21/sol1.py b/project_euler/problem_21/sol1.py
index 9cf2a64cf2a9..a890e6a98611 100644
--- a/project_euler/problem_21/sol1.py
+++ b/project_euler/problem_21/sol1.py
@@ -16,15 +16,9 @@
 
 Evaluate the sum of all the amicable numbers under 10000.
 """
-try:
-    xrange  # Python 2
-except NameError:
-    xrange = range  # Python 3
-
-
 def sum_of_divisors(n):
     total = 0
-    for i in xrange(1, int(sqrt(n) + 1)):
+    for i in range(1, int(sqrt(n) + 1)):
         if n % i == 0 and i != sqrt(n):
             total += i + n // i
         elif i == sqrt(n):
diff --git a/project_euler/problem_22/sol1.py b/project_euler/problem_22/sol1.py
index aa779f222eaa..f6275e2138bb 100644
--- a/project_euler/problem_22/sol1.py
+++ b/project_euler/problem_22/sol1.py
@@ -18,12 +18,6 @@
 import os
 
 
-try:
-    xrange  # Python 2
-except NameError:
-    xrange = range  # Python 3
-
-
 def solution():
     """Returns the total of all the name scores in the file.
 
diff --git a/project_euler/problem_25/sol1.py b/project_euler/problem_25/sol1.py
index be3b4d9b2d7d..4371c533ce16 100644
--- a/project_euler/problem_25/sol1.py
+++ b/project_euler/problem_25/sol1.py
@@ -25,12 +25,6 @@
 digits?
 """
 
-try:
-    xrange  # Python 2
-except NameError:
-    xrange = range  # Python 3
-
-
 def fibonacci(n):
     if n == 1 or type(n) is not int:
         return 0
@@ -38,7 +32,7 @@ def fibonacci(n):
         return 1
     else:
         sequence = [0, 1]
-        for i in xrange(2, n + 1):
+        for i in range(2, n + 1):
             sequence.append(sequence[i - 1] + sequence[i - 2])
 
         return sequence[n]
diff --git a/project_euler/problem_28/sol1.py b/project_euler/problem_28/sol1.py
index 63386ce3058c..11b48fea9adf 100644
--- a/project_euler/problem_28/sol1.py
+++ b/project_euler/problem_28/sol1.py
@@ -16,11 +16,6 @@
 
 from math import ceil
 
-try:
-    xrange  # Python 2
-except NameError:
-    xrange = range  # Python 3
-
 
 def diagonal_sum(n):
     """Returns the sum of the numbers on the diagonals in a n by n spiral
@@ -39,7 +34,7 @@ def diagonal_sum(n):
     """
     total = 1
 
-    for i in xrange(1, int(ceil(n / 2.0))):
+    for i in range(1, int(ceil(n / 2.0))):
         odd = 2 * i + 1
         even = 2 * i
         total = total + 4 * odd ** 2 - 6 * even
diff --git a/project_euler/problem_29/solution.py b/project_euler/problem_29/solution.py
index e67dafe4639d..24d3e20d94fe 100644
--- a/project_euler/problem_29/solution.py
+++ b/project_euler/problem_29/solution.py
@@ -14,13 +14,10 @@
 How many distinct terms are in the sequence generated by ab
 for 2 <= a <= 100 and 2 <= b <= 100?
 """
-from __future__ import print_function
-
-
 def solution(n):
     """Returns the number of distinct terms in the sequence generated by a^b
     for 2 <= a <= 100 and 2 <= b <= 100.
- 
+
     >>> solution(100)
     9183
     >>> solution(50)
diff --git a/project_euler/problem_31/sol1.py b/project_euler/problem_31/sol1.py
index e2a209e5df5a..f7439d346130 100644
--- a/project_euler/problem_31/sol1.py
+++ b/project_euler/problem_31/sol1.py
@@ -11,14 +11,6 @@
 1×£1 + 1×50p + 2×20p + 1×5p + 1×2p + 3×1p
 How many different ways can £2 be made using any number of coins?
 """
-from __future__ import print_function
-
-try:
-    raw_input  # Python 2
-except NameError:
-    raw_input = input  # Python 3
-
-
 def one_pence():
     return 1
 
diff --git a/project_euler/problem_36/sol1.py b/project_euler/problem_36/sol1.py
index 38b60420992b..7ed74af8fd63 100644
--- a/project_euler/problem_36/sol1.py
+++ b/project_euler/problem_36/sol1.py
@@ -9,12 +9,6 @@
 (Please note that the palindromic number, in either base, may not include
 leading zeros.)
 """
-try:
-    xrange  # Python 2
-except NameError:
-    xrange = range  # Python 3
-
-
 def is_palindrome(n):
     n = str(n)
 
@@ -47,7 +41,7 @@ def solution(n):
     """
     total = 0
 
-    for i in xrange(1, n):
+    for i in range(1, n):
         if is_palindrome(i) and is_palindrome(bin(i).split("b")[1]):
             total += i
     return total
diff --git a/project_euler/problem_40/sol1.py b/project_euler/problem_40/sol1.py
index accd7125354c..d15376b739db 100644
--- a/project_euler/problem_40/sol1.py
+++ b/project_euler/problem_40/sol1.py
@@ -14,11 +14,8 @@
 
 d1 × d10 × d100 × d1000 × d10000 × d100000 × d1000000
 """
-from __future__ import print_function
-
-
 def solution():
-    """Returns 
+    """Returns
 
     >>> solution()
     210
diff --git a/project_euler/problem_48/sol1.py b/project_euler/problem_48/sol1.py
index 95af951c0e8a..06ad1408dcef 100644
--- a/project_euler/problem_48/sol1.py
+++ b/project_euler/problem_48/sol1.py
@@ -7,11 +7,6 @@
 Find the last ten digits of the series, 11 + 22 + 33 + ... + 10001000.
 """
 
-try:
-    xrange
-except NameError:
-    xrange = range
-
 
 def solution():
     """Returns the last 10 digits of the series, 11 + 22 + 33 + ... + 10001000.
@@ -20,7 +15,7 @@ def solution():
     '9110846700'
     """
     total = 0
-    for i in xrange(1, 1001):
+    for i in range(1, 1001):
         total += i ** i
     return str(total)[-10:]
 
diff --git a/project_euler/problem_53/sol1.py b/project_euler/problem_53/sol1.py
index c72e0b993a34..f17508b005d1 100644
--- a/project_euler/problem_53/sol1.py
+++ b/project_euler/problem_53/sol1.py
@@ -17,14 +17,8 @@
 How many, not necessarily distinct, values of nCr, for 1 ≤ n ≤ 100, are greater
 than one-million?
 """
-from __future__ import print_function
 from math import factorial
 
-try:
-    xrange  # Python 2
-except NameError:
-    xrange = range  # Python 3
-
 
 def combinations(n, r):
     return factorial(n) / (factorial(r) * factorial(n - r))
@@ -39,8 +33,8 @@ def solution():
     """
     total = 0
 
-    for i in xrange(1, 101):
-        for j in xrange(1, i + 1):
+    for i in range(1, 101):
+        for j in range(1, i + 1):
             if combinations(i, j) > 1e6:
                 total += 1
     return total
diff --git a/project_euler/problem_76/sol1.py b/project_euler/problem_76/sol1.py
index c9e3c452fbc4..ed0ee6b507e9 100644
--- a/project_euler/problem_76/sol1.py
+++ b/project_euler/problem_76/sol1.py
@@ -14,12 +14,6 @@
 How many different ways can one hundred be written as a sum of at least two
 positive integers?
 """
-from __future__ import print_function
-
-try:
-    xrange  # Python 2
-except NameError:
-    xrange = range  # Python 3
 
 
 def partition(m):
@@ -43,12 +37,12 @@ def partition(m):
     >>> partition(1)
     0
     """
-    memo = [[0 for _ in xrange(m)] for _ in xrange(m + 1)]
-    for i in xrange(m + 1):
+    memo = [[0 for _ in range(m)] for _ in range(m + 1)]
+    for i in range(m + 1):
         memo[i][0] = 1
 
-    for n in xrange(m + 1):
-        for k in xrange(1, m):
+    for n in range(m + 1):
+        for k in range(1, m):
             memo[n][k] += memo[n][k - 1]
             if n > k:
                 memo[n][k] += memo[n - k - 1][k]
diff --git a/searches/binary_search.py b/searches/binary_search.py
index e658dac2a3ef..77abf90239ab 100644
--- a/searches/binary_search.py
+++ b/searches/binary_search.py
@@ -9,14 +9,8 @@
 For manual testing run:
 python binary_search.py
 """
-from __future__ import print_function
 import bisect
 
-try:
-    raw_input          # Python 2
-except NameError:
-    raw_input = input  # Python 3
-
 
 def binary_search(sorted_collection, item):
     """Pure implementation of binary search algorithm in Python
@@ -112,7 +106,7 @@ def binary_search_by_recursion(sorted_collection, item, left, right):
     """
     if (right < left):
         return None
-    
+
     midpoint = left + (right - left) // 2
 
     if sorted_collection[midpoint] == item:
@@ -121,7 +115,7 @@ def binary_search_by_recursion(sorted_collection, item, left, right):
         return binary_search_by_recursion(sorted_collection, item, left, midpoint-1)
     else:
         return binary_search_by_recursion(sorted_collection, item, midpoint+1, right)
-      
+
 def __assert_sorted(collection):
     """Check if collection is ascending sorted, if not - raises :py:class:`ValueError`
 
@@ -145,14 +139,14 @@ def __assert_sorted(collection):
 
 if __name__ == '__main__':
     import sys
-    user_input = raw_input('Enter numbers separated by comma:\n').strip()
+    user_input = input('Enter numbers separated by comma:\n').strip()
     collection = [int(item) for item in user_input.split(',')]
     try:
         __assert_sorted(collection)
     except ValueError:
         sys.exit('Sequence must be ascending sorted to apply binary search')
 
-    target_input = raw_input('Enter a single number to be found in the list:\n')
+    target_input = input('Enter a single number to be found in the list:\n')
     target = int(target_input)
     result = binary_search(collection, target)
     if result is not None:
diff --git a/searches/interpolation_search.py b/searches/interpolation_search.py
index 329596d340a5..27ee979bb649 100644
--- a/searches/interpolation_search.py
+++ b/searches/interpolation_search.py
@@ -1,12 +1,6 @@
 """
 This is pure python implementation of interpolation search algorithm
 """
-from __future__ import print_function
-
-try:
-    raw_input          # Python 2
-except NameError:
-    raw_input = input  # Python 3
 
 
 def interpolation_search(sorted_collection, item):
@@ -29,7 +23,7 @@ def interpolation_search(sorted_collection, item):
                 return None
 
         point = left + ((item - sorted_collection[left]) * (right - left)) // (sorted_collection[right] - sorted_collection[left])
-        
+
         #out of range check
         if point<0 or point>=len(sorted_collection):
             return None
@@ -42,9 +36,9 @@ def interpolation_search(sorted_collection, item):
                 right = left
                 left = point
             elif point>right:
-                left = right 
+                left = right
                 right = point
-            else:    
+            else:
                 if item < current_item:
                     right = point - 1
                 else:
@@ -70,7 +64,7 @@ def interpolation_search_by_recursion(sorted_collection, item, left, right):
             return None
 
     point = left + ((item - sorted_collection[left]) * (right - left)) // (sorted_collection[right] - sorted_collection[left])
-    
+
     #out of range check
     if point<0 or point>=len(sorted_collection):
         return None
@@ -86,7 +80,7 @@ def interpolation_search_by_recursion(sorted_collection, item, left, right):
             return interpolation_search_by_recursion(sorted_collection, item, left, point-1)
         else:
             return interpolation_search_by_recursion(sorted_collection, item, point+1, right)
-      
+
 def __assert_sorted(collection):
     """Check if collection is ascending sorted, if not - raises :py:class:`ValueError`
     :param collection: collection
@@ -107,16 +101,16 @@ def __assert_sorted(collection):
 
 if __name__ == '__main__':
     import sys
-    
+
     """
-	user_input = raw_input('Enter numbers separated by comma:\n').strip()
+	user_input = input('Enter numbers separated by comma:\n').strip()
     collection = [int(item) for item in user_input.split(',')]
     try:
         __assert_sorted(collection)
     except ValueError:
         sys.exit('Sequence must be ascending sorted to apply interpolation search')
 
-    target_input = raw_input('Enter a single number to be found in the list:\n')
+    target_input = input('Enter a single number to be found in the list:\n')
     target = int(target_input)
 	"""
 
@@ -128,7 +122,7 @@ def __assert_sorted(collection):
         except ValueError:
             sys.exit('Sequence must be ascending sorted to apply interpolation search')
         target = 67
-        
+
     result = interpolation_search(collection, target)
     if result is not None:
         print('{} found at positions: {}'.format(target, result))
diff --git a/searches/jump_search.py b/searches/jump_search.py
index 10cb933f2f35..78d9f79dc6a8 100644
--- a/searches/jump_search.py
+++ b/searches/jump_search.py
@@ -1,4 +1,3 @@
-from __future__ import print_function
 import math
 def jump_search(arr, x):
     n = len(arr)
diff --git a/searches/linear_search.py b/searches/linear_search.py
index 058322f21d09..fb784924132e 100644
--- a/searches/linear_search.py
+++ b/searches/linear_search.py
@@ -9,12 +9,7 @@
 For manual testing run:
 python linear_search.py
 """
-from __future__ import print_function
 
-try:
-    raw_input          # Python 2
-except NameError:
-    raw_input = input  # Python 3
 
 def linear_search(sequence, target):
     """Pure implementation of linear search algorithm in Python
@@ -43,10 +38,10 @@ def linear_search(sequence, target):
 
 
 if __name__ == '__main__':
-    user_input = raw_input('Enter numbers separated by comma:\n').strip()
+    user_input = input('Enter numbers separated by comma:\n').strip()
     sequence = [int(item) for item in user_input.split(',')]
 
-    target_input = raw_input('Enter a single number to be found in the list:\n')
+    target_input = input('Enter a single number to be found in the list:\n')
     target = int(target_input)
     result = linear_search(sequence, target)
     if result is not None:
diff --git a/searches/sentinel_linear_search.py b/searches/sentinel_linear_search.py
index 336cc5ab3b74..eb9d32e5f503 100644
--- a/searches/sentinel_linear_search.py
+++ b/searches/sentinel_linear_search.py
@@ -45,15 +45,10 @@ def sentinel_linear_search(sequence, target):
 
 
 if __name__ == '__main__':
-    try:
-        raw_input          # Python 2
-    except NameError:
-        raw_input = input  # Python 3
-
-    user_input = raw_input('Enter numbers separated by comma:\n').strip()
+    user_input = input('Enter numbers separated by comma:\n').strip()
     sequence = [int(item) for item in user_input.split(',')]
 
-    target_input = raw_input('Enter a single number to be found in the list:\n')
+    target_input = input('Enter a single number to be found in the list:\n')
     target = int(target_input)
     result = sentinel_linear_search(sequence, target)
     if result is not None:
diff --git a/searches/ternary_search.py b/searches/ternary_search.py
index c610f9b3c6da..41033f33cec6 100644
--- a/searches/ternary_search.py
+++ b/searches/ternary_search.py
@@ -1,20 +1,13 @@
 '''
 This is a type of divide and conquer algorithm which divides the search space into
-3 parts and finds the target value based on the property of the array or list 
+3 parts and finds the target value based on the property of the array or list
 (usually monotonic property).
 
 Time Complexity  : O(log3 N)
 Space Complexity : O(1)
 '''
-from __future__ import print_function
-
 import sys
 
-try:
-    raw_input          # Python 2
-except NameError:
-    raw_input = input  # Python 3
-
 # This is the precision for this function which can be altered.
 # It is recommended for users to keep this number greater than or equal to 10.
 precision = 10
@@ -31,23 +24,23 @@ def ite_ternary_search(A, target):
     right = len(A) - 1;
     while(True):
         if(left<right):
-            
+
             if(right-left < precision):
                 return lin_search(left,right,A,target)
 
             oneThird = (left+right)/3+1;
             twoThird = 2*(left+right)/3+1;
-            
+
             if(A[oneThird] == target):
                 return oneThird
             elif(A[twoThird] == target):
                 return twoThird
-            
+
             elif(target < A[oneThird]):
                 right = oneThird-1
             elif(A[twoThird] < target):
                 left = twoThird+1
-            
+
             else:
                 left = oneThird+1
                 right = twoThird-1
@@ -57,7 +50,7 @@ def ite_ternary_search(A, target):
 # This is the recursive method of the ternary search algorithm.
 def rec_ternary_search(left, right, A, target):
     if(left<right):
-        
+
         if(right-left < precision):
             return lin_search(left,right,A,target)
 
@@ -68,12 +61,12 @@ def rec_ternary_search(left, right, A, target):
             return oneThird
         elif(A[twoThird] == target):
             return twoThird
-        
+
         elif(target < A[oneThird]):
             return rec_ternary_search(left, oneThird-1, A, target)
         elif(A[twoThird] < target):
             return rec_ternary_search(twoThird+1, right, A, target)
-        
+
         else:
             return rec_ternary_search(oneThird+1, twoThird-1, A, target)
     else:
@@ -87,7 +80,7 @@ def __assert_sorted(collection):
 
 
 if __name__ == '__main__':
-    user_input = raw_input('Enter numbers separated by coma:\n').strip()
+    user_input = input('Enter numbers separated by coma:\n').strip()
     collection = [int(item) for item in user_input.split(',')]
 
     try:
@@ -95,11 +88,11 @@ def __assert_sorted(collection):
     except ValueError:
         sys.exit('Sequence must be sorted to apply the ternary search')
 
-    target_input = raw_input('Enter a single number to be found in the list:\n')
+    target_input = input('Enter a single number to be found in the list:\n')
     target = int(target_input)
     result1 = ite_ternary_search(collection, target)
     result2 = rec_ternary_search(0, len(collection)-1, collection, target)
-    
+
     if result2 is not None:
         print('Iterative search: {} found at positions: {}'.format(target, result1))
         print('Recursive search: {} found at positions: {}'.format(target, result2))
diff --git a/sorts/bogo_sort.py b/sorts/bogo_sort.py
index 056e8e68a92e..a3b2cbc1aa29 100644
--- a/sorts/bogo_sort.py
+++ b/sorts/bogo_sort.py
@@ -8,7 +8,6 @@
 python bogo_sort.py
 """
 
-from __future__ import print_function
 import random
 
 
@@ -39,11 +38,6 @@ def isSorted(collection):
     return collection
 
 if __name__ == '__main__':
-    try:
-        raw_input          # Python 2
-    except NameError:
-        raw_input = input  # Python 3
-
-    user_input = raw_input('Enter numbers separated by a comma:\n').strip()
+    user_input = input('Enter numbers separated by a comma:\n').strip()
     unsorted = [int(item) for item in user_input.split(',')]
     print(bogo_sort(unsorted))
diff --git a/sorts/bubble_sort.py b/sorts/bubble_sort.py
index 4e2c19b65e02..c41a51ea3cbf 100644
--- a/sorts/bubble_sort.py
+++ b/sorts/bubble_sort.py
@@ -1,6 +1,3 @@
-from __future__ import print_function
-
-
 def bubble_sort(collection):
     """Pure implementation of bubble sort algorithm in Python
 
@@ -17,9 +14,12 @@ def bubble_sort(collection):
 
     >>> bubble_sort([-2, -5, -45])
     [-45, -5, -2]
-    
-    >>> bubble_sort([-23,0,6,-4,34])
+
+    >>> bubble_sort([-23, 0, 6, -4, 34])
     [-23, -4, 0, 6, 34]
+
+    >>> bubble_sort([-23, 0, 6, -4, 34]) == sorted([-23, 0, 6, -4, 34])
+    True
     """
     length = len(collection)
     for i in range(length-1):
@@ -28,15 +28,12 @@ def bubble_sort(collection):
             if collection[j] > collection[j+1]:
                 swapped = True
                 collection[j], collection[j+1] = collection[j+1], collection[j]
-        if not swapped: break  # Stop iteration if the collection is sorted.
+        if not swapped:
+            break  # Stop iteration if the collection is sorted.
     return collection
 
 
 if __name__ == '__main__':
-    try:
-        raw_input          # Python 2
-    except NameError:
-        raw_input = input  # Python 3
-    user_input = raw_input('Enter numbers separated by a comma:').strip()
+    user_input = input('Enter numbers separated by a comma:').strip()
     unsorted = [int(item) for item in user_input.split(',')]
     print(*bubble_sort(unsorted), sep=',')
diff --git a/sorts/cocktail_shaker_sort.py b/sorts/cocktail_shaker_sort.py
index 8ad3383bbe9f..d486e6a11dfa 100644
--- a/sorts/cocktail_shaker_sort.py
+++ b/sorts/cocktail_shaker_sort.py
@@ -1,12 +1,10 @@
-from __future__ import print_function
-
 def cocktail_shaker_sort(unsorted):
     """
     Pure implementation of the cocktail shaker sort algorithm in Python.
     """
     for i in range(len(unsorted)-1, 0, -1):
         swapped = False
-        
+
         for j in range(i, 0, -1):
             if unsorted[j] < unsorted[j-1]:
                 unsorted[j], unsorted[j-1] = unsorted[j-1], unsorted[j]
@@ -16,17 +14,12 @@ def cocktail_shaker_sort(unsorted):
             if unsorted[j] > unsorted[j+1]:
                 unsorted[j], unsorted[j+1] = unsorted[j+1], unsorted[j]
                 swapped = True
-        
+
         if not swapped:
             return unsorted
-            
+
 if __name__ == '__main__':
-    try:
-        raw_input          # Python 2
-    except NameError:
-        raw_input = input  # Python 3
-    
-    user_input = raw_input('Enter numbers separated by a comma:\n').strip()
+    user_input = input('Enter numbers separated by a comma:\n').strip()
     unsorted = [int(item) for item in user_input.split(',')]
     cocktail_shaker_sort(unsorted)
     print(unsorted)
diff --git a/sorts/comb_sort.py b/sorts/comb_sort.py
index 22b6f66f04cc..6ce6c1c094f9 100644
--- a/sorts/comb_sort.py
+++ b/sorts/comb_sort.py
@@ -48,11 +48,6 @@ def comb_sort(data):
 
 
 if __name__ == '__main__':
-    try:
-        raw_input          # Python 2
-    except NameError:
-        raw_input = input  # Python 3
-
-    user_input = raw_input('Enter numbers separated by a comma:\n').strip()
+    user_input = input('Enter numbers separated by a comma:\n').strip()
     unsorted = [int(item) for item in user_input.split(',')]
     print(comb_sort(unsorted))
diff --git a/sorts/counting_sort.py b/sorts/counting_sort.py
index ad98f1a0da4c..a3de1811849e 100644
--- a/sorts/counting_sort.py
+++ b/sorts/counting_sort.py
@@ -8,8 +8,6 @@
 python counting_sort.py
 """
 
-from __future__ import print_function
-
 
 def counting_sort(collection):
     """Pure implementation of counting sort algorithm in Python
@@ -58,6 +56,10 @@ def counting_sort(collection):
     return ordered
 
 def counting_sort_string(string):
+    """
+    >>> counting_sort_string("thisisthestring")
+    'eghhiiinrsssttt'
+    """
     return ''.join([chr(i) for i in counting_sort([ord(c) for c in string])])
 
 
@@ -65,11 +67,6 @@ def counting_sort_string(string):
     # Test string sort
     assert "eghhiiinrsssttt" == counting_sort_string("thisisthestring")
 
-    try:
-        raw_input          # Python 2
-    except NameError:
-        raw_input = input  # Python 3
-
-    user_input = raw_input('Enter numbers separated by a comma:\n').strip()
+    user_input = input('Enter numbers separated by a comma:\n').strip()
     unsorted = [int(item) for item in user_input.split(',')]
     print(counting_sort(unsorted))
diff --git a/sorts/cycle_sort.py b/sorts/cycle_sort.py
index 492022164427..06a377cbd906 100644
--- a/sorts/cycle_sort.py
+++ b/sorts/cycle_sort.py
@@ -1,7 +1,4 @@
 # Code contributed by Honey Sharma
-from __future__ import print_function
-
-
 def cycle_sort(array):
     ans = 0
 
@@ -45,12 +42,7 @@ def cycle_sort(array):
 
 #  Main Code starts here
 if __name__ == '__main__':
-    try:
-        raw_input          # Python 2
-    except NameError:
-        raw_input = input  # Python 3
-        
-    user_input = raw_input('Enter numbers separated by a comma:\n')
+    user_input = input('Enter numbers separated by a comma:\n')
     unsorted = [int(item) for item in user_input.split(',')]
     n = len(unsorted)
     cycle_sort(unsorted)
diff --git a/sorts/gnome_sort.py b/sorts/gnome_sort.py
index 075749e37663..fed70eb6bc1b 100644
--- a/sorts/gnome_sort.py
+++ b/sorts/gnome_sort.py
@@ -1,7 +1,5 @@
 """Gnome Sort Algorithm."""
 
-from __future__ import print_function
-
 
 def gnome_sort(unsorted):
     """Pure implementation of the gnome sort algorithm in Python."""
@@ -21,12 +19,7 @@ def gnome_sort(unsorted):
 
 
 if __name__ == '__main__':
-    try:
-        raw_input          # Python 2
-    except NameError:
-        raw_input = input  # Python 3
-
-    user_input = raw_input('Enter numbers separated by a comma:\n').strip()
+    user_input = input('Enter numbers separated by a comma:\n').strip()
     unsorted = [int(item) for item in user_input.split(',')]
     gnome_sort(unsorted)
     print(unsorted)
diff --git a/sorts/heap_sort.py b/sorts/heap_sort.py
index 3c72abca8059..ca4a061afbb7 100644
--- a/sorts/heap_sort.py
+++ b/sorts/heap_sort.py
@@ -10,9 +10,6 @@
 python heap_sort.py
 '''
 
-from __future__ import print_function
-
-
 def heapify(unsorted, index, heap_size):
     largest = index
     left_index = 2 * index + 1
@@ -54,11 +51,6 @@ def heap_sort(unsorted):
     return unsorted
 
 if __name__ == '__main__':
-    try:
-        raw_input          # Python 2
-    except NameError:
-        raw_input = input  # Python 3
-
-    user_input = raw_input('Enter numbers separated by a comma:\n').strip()
+    user_input = input('Enter numbers separated by a comma:\n').strip()
     unsorted = [int(item) for item in user_input.split(',')]
     print(heap_sort(unsorted))
diff --git a/sorts/insertion_sort.py b/sorts/insertion_sort.py
index e088705947d4..e10497b0e282 100644
--- a/sorts/insertion_sort.py
+++ b/sorts/insertion_sort.py
@@ -9,9 +9,6 @@
 For manual testing run:
 python insertion_sort.py
 """
-from __future__ import print_function
-
-
 def insertion_sort(collection):
     """Pure implementation of the insertion sort algorithm in Python
 
@@ -40,11 +37,6 @@ def insertion_sort(collection):
 
 
 if __name__ == '__main__':
-    try:
-        raw_input          # Python 2
-    except NameError:
-        raw_input = input  # Python 3
-
-    user_input = raw_input('Enter numbers separated by a comma:\n').strip()
+    user_input = input('Enter numbers separated by a comma:\n').strip()
     unsorted = [int(item) for item in user_input.split(',')]
     print(insertion_sort(unsorted))
diff --git a/sorts/merge_sort.py b/sorts/merge_sort.py
index 714861e72642..e64e90785a32 100644
--- a/sorts/merge_sort.py
+++ b/sorts/merge_sort.py
@@ -9,9 +9,6 @@
 For manual testing run:
 python merge_sort.py
 """
-from __future__ import print_function
-
-
 def merge_sort(collection):
     """Pure implementation of the merge sort algorithm in Python
 
@@ -46,11 +43,6 @@ def merge(left, right):
 
 
 if __name__ == '__main__':
-    try:
-        raw_input          # Python 2
-    except NameError:
-        raw_input = input  # Python 3
-
-    user_input = raw_input('Enter numbers separated by a comma:\n').strip()
+    user_input = input('Enter numbers separated by a comma:\n').strip()
     unsorted = [int(item) for item in user_input.split(',')]
     print(*merge_sort(unsorted), sep=',')
diff --git a/sorts/merge_sort_fastest.py b/sorts/merge_sort_fastest.py
index bd356c935ca0..3c9ed3e9e8ee 100644
--- a/sorts/merge_sort_fastest.py
+++ b/sorts/merge_sort_fastest.py
@@ -4,9 +4,6 @@
 Best Case Scenario : O(n)
 Worst Case Scenario : O(n^2) because native python functions:min, max and remove are already O(n)
 '''
-from __future__ import print_function
-
-
 def merge_sort(collection):
     """Pure implementation of the fastest merge sort algorithm in Python
 
@@ -36,11 +33,6 @@ def merge_sort(collection):
 
 
 if __name__ == '__main__':
-    try:
-        raw_input          # Python 2
-    except NameError:
-        raw_input = input  # Python 3
-
-    user_input = raw_input('Enter numbers separated by a comma:\n').strip()
+    user_input = input('Enter numbers separated by a comma:\n').strip()
     unsorted = [int(item) for item in user_input.split(',')]
     print(*merge_sort(unsorted), sep=',')
diff --git a/sorts/pigeon_sort.py b/sorts/pigeon_sort.py
index 65eb8896ea9c..5e5afa137685 100644
--- a/sorts/pigeon_sort.py
+++ b/sorts/pigeon_sort.py
@@ -1,9 +1,6 @@
 '''
     This is an implementation of Pigeon Hole Sort.
 '''
-
-from __future__ import print_function
-
 def pigeon_sort(array):
     # Manually finds the minimum and maximum of the array.
     min = array[0]
@@ -38,12 +35,7 @@ def pigeon_sort(array):
     return array
 
 if __name__ == '__main__':
-    try:
-        raw_input           # Python2
-    except NameError:
-        raw_input = input   # Python 3
-    
-    user_input = raw_input('Enter numbers separated by comma:\n')
+    user_input = input('Enter numbers separated by comma:\n')
     unsorted = [int(x) for x in user_input.split(',')]
     sorted = pigeon_sort(unsorted)
 
diff --git a/sorts/quick_sort.py b/sorts/quick_sort.py
index 7e8c868ebb06..60f8803cb79c 100644
--- a/sorts/quick_sort.py
+++ b/sorts/quick_sort.py
@@ -9,9 +9,6 @@
 For manual testing run:
 python quick_sort.py
 """
-from __future__ import print_function
-
-
 def quick_sort(collection):
     """Pure implementation of quick sort algorithm in Python
 
@@ -47,11 +44,6 @@ def quick_sort(collection):
 
 
 if __name__ == '__main__':
-    try:
-        raw_input          # Python 2
-    except NameError:
-        raw_input = input  # Python 3
-
-    user_input = raw_input('Enter numbers separated by a comma:\n').strip()
+    user_input = input('Enter numbers separated by a comma:\n').strip()
     unsorted = [ int(item) for item in user_input.split(',') ]
     print( quick_sort(unsorted) )
diff --git a/sorts/quick_sort_3_partition.py b/sorts/quick_sort_3_partition.py
index def646cdbc50..9056b204740a 100644
--- a/sorts/quick_sort_3_partition.py
+++ b/sorts/quick_sort_3_partition.py
@@ -1,5 +1,3 @@
-from __future__ import print_function
-
 def quick_sort_3partition(sorting, left, right):
     if right <= left:
         return
@@ -20,12 +18,7 @@ def quick_sort_3partition(sorting, left, right):
     quick_sort_3partition(sorting, b + 1, right)
 
 if __name__ == '__main__':
-    try:
-        raw_input          # Python 2
-    except NameError:
-        raw_input = input  # Python 3
-
-    user_input = raw_input('Enter numbers separated by a comma:\n').strip()
+    user_input = input('Enter numbers separated by a comma:\n').strip()
     unsorted = [ int(item) for item in user_input.split(',') ]
     quick_sort_3partition(unsorted,0,len(unsorted)-1)
     print(unsorted)
diff --git a/sorts/random_normal_distribution_quicksort.py b/sorts/random_normal_distribution_quicksort.py
index dfa37da61e26..39c54c46e263 100644
--- a/sorts/random_normal_distribution_quicksort.py
+++ b/sorts/random_normal_distribution_quicksort.py
@@ -1,25 +1,23 @@
-from __future__ import print_function
 from random import randint
 from tempfile import TemporaryFile
 import numpy as np
 
 
-
-def _inPlaceQuickSort(A,start,end):  
+def _inPlaceQuickSort(A,start,end):
     count = 0
     if start<end:
         pivot=randint(start,end)
         temp=A[end]
         A[end]=A[pivot]
         A[pivot]=temp
-        
+
         p,count= _inPlacePartition(A,start,end)
         count += _inPlaceQuickSort(A,start,p-1)
         count += _inPlaceQuickSort(A,p+1,end)
     return count
 
 def _inPlacePartition(A,start,end):
-    
+
     count = 0
     pivot= randint(start,end)
     temp=A[end]
@@ -27,20 +25,20 @@ def _inPlacePartition(A,start,end):
     A[pivot]=temp
     newPivotIndex=start-1
     for index in range(start,end):
-               
+
         count += 1
         if A[index]<A[end]:#check if current val is less than pivot value
             newPivotIndex=newPivotIndex+1
             temp=A[newPivotIndex]
             A[newPivotIndex]=A[index]
             A[index]=temp
-    
+
     temp=A[newPivotIndex+1]
     A[newPivotIndex+1]=A[end]
     A[end]=temp
     return newPivotIndex+1,count
-    
-outfile = TemporaryFile()    
+
+outfile = TemporaryFile()
 p = 100 # 1000 elements are to be sorted
 
 
@@ -52,15 +50,15 @@ def _inPlacePartition(A,start,end):
 print('The array is')
 print(X)
 
-  
-    
+
+
 
 
 
 outfile.seek(0)  # using the same array
 M = np.load(outfile)
 r = (len(M)-1)
-z = _inPlaceQuickSort(M,0,r) 
+z = _inPlaceQuickSort(M,0,r)
 
 print("No of Comparisons for 100 elements selected from a standard normal distribution is :")
 print(z)
diff --git a/sorts/selection_sort.py b/sorts/selection_sort.py
index c1d66c5a8b38..28eaa4fabd95 100644
--- a/sorts/selection_sort.py
+++ b/sorts/selection_sort.py
@@ -9,9 +9,6 @@
 For manual testing run:
 python selection_sort.py
 """
-from __future__ import print_function
-
-
 def selection_sort(collection):
     """Pure implementation of the selection sort algorithm in Python
     :param collection: some mutable ordered collection with heterogeneous
@@ -43,11 +40,6 @@ def selection_sort(collection):
 
 
 if __name__ == '__main__':
-    try:
-        raw_input          # Python 2
-    except NameError:
-        raw_input = input  # Python 3
-
-    user_input = raw_input('Enter numbers separated by a comma:\n').strip()
+    user_input = input('Enter numbers separated by a comma:\n').strip()
     unsorted = [int(item) for item in user_input.split(',')]
     print(selection_sort(unsorted))
diff --git a/sorts/shell_sort.py b/sorts/shell_sort.py
index dc1846758243..9427394485bc 100644
--- a/sorts/shell_sort.py
+++ b/sorts/shell_sort.py
@@ -9,9 +9,6 @@
 For manual testing run:
 python shell_sort.py
 """
-from __future__ import print_function
-
-
 def shell_sort(collection):
     """Pure implementation of shell sort algorithm in Python
     :param collection:  Some mutable ordered collection with heterogeneous
@@ -44,11 +41,6 @@ def shell_sort(collection):
     return collection
 
 if __name__ == '__main__':
-    try:
-        raw_input          # Python 2
-    except NameError:
-        raw_input = input  # Python 3
-
-    user_input = raw_input('Enter numbers separated by a comma:\n').strip()
+    user_input = input('Enter numbers separated by a comma:\n').strip()
     unsorted = [int(item) for item in user_input.split(',')]
     print(shell_sort(unsorted))
diff --git a/sorts/topological_sort.py b/sorts/topological_sort.py
index 400cfb4ca270..74e58899a9a0 100644
--- a/sorts/topological_sort.py
+++ b/sorts/topological_sort.py
@@ -1,6 +1,5 @@
 """Topological Sort."""
 
-from __future__ import print_function
 #     a
 #    / \
 #   b  c
diff --git a/strings/levenshtein_distance.py b/strings/levenshtein_distance.py
index 274dfd7ccf9b..78175576194b 100644
--- a/strings/levenshtein_distance.py
+++ b/strings/levenshtein_distance.py
@@ -65,13 +65,8 @@ def levenshtein_distance(first_word, second_word):
 
 
 if __name__ == '__main__':
-    try:
-        raw_input          # Python 2
-    except NameError:
-        raw_input = input  # Python 3
-
-    first_word = raw_input('Enter the first word:\n').strip()
-    second_word = raw_input('Enter the second word:\n').strip()
+    first_word = input('Enter the first word:\n').strip()
+    second_word = input('Enter the second word:\n').strip()
 
     result = levenshtein_distance(first_word, second_word)
     print('Levenshtein distance between {} and {} is {}'.format(
diff --git a/strings/min_cost_string_conversion.py b/strings/min_cost_string_conversion.py
index de7f9f727283..95840c484ba7 100644
--- a/strings/min_cost_string_conversion.py
+++ b/strings/min_cost_string_conversion.py
@@ -1,10 +1,3 @@
-from __future__ import print_function
-
-try:
-	xrange		#Python 2
-except NameError:
-	xrange = range	#Python 3
-
 '''
 Algorithm for calculating the most cost-efficient sequence for converting one string into another.
 The only allowed operations are
@@ -19,19 +12,19 @@ def compute_transform_tables(X, Y, cC, cR, cD, cI):
 	m = len(X)
 	n = len(Y)
 
-	costs = [[0 for _ in xrange(n+1)] for _ in xrange(m+1)]
-	ops = [[0 for _ in xrange(n+1)] for _ in xrange(m+1)]
+	costs = [[0 for _ in range(n+1)] for _ in range(m+1)]
+	ops = [[0 for _ in range(n+1)] for _ in range(m+1)]
 
-	for i in xrange(1, m+1):
+	for i in range(1, m+1):
 		costs[i][0] = i*cD
 		ops[i][0] = 'D%c' % X[i-1]
 
-	for i in xrange(1, n+1):
+	for i in range(1, n+1):
 		costs[0][i] = i*cI
 		ops[0][i] = 'I%c' % Y[i-1]
 
-	for i in xrange(1, m+1):
-		for j in xrange(1, n+1):
+	for i in range(1, m+1):
+		for j in range(1, n+1):
 			if X[i-1] == Y[j-1]:
 				costs[i][j] = costs[i-1][j-1] + cC
 				ops[i][j] = 'C%c' % X[i-1]
@@ -77,7 +70,7 @@ def assemble_transformation(ops, i, j):
 	string = list('Python')
 	i = 0
 	cost = 0
-	
+
 	with open('min_cost.txt', 'w') as file:
 		for op in sequence:
 			print(''.join(string))
@@ -86,7 +79,7 @@ def assemble_transformation(ops, i, j):
 				file.write('%-16s' % 'Copy %c' % op[1])
 				file.write('\t\t\t' + ''.join(string))
 				file.write('\r\n')
-				
+
 				cost -= 1
 			elif op[0] == 'R':
 				string[i] = op[2]
@@ -94,7 +87,7 @@ def assemble_transformation(ops, i, j):
 				file.write('%-16s' % ('Replace %c' % op[1] + ' with ' + str(op[2])))
 				file.write('\t\t' + ''.join(string))
 				file.write('\r\n')
-				
+
 				cost += 1
 			elif op[0] == 'D':
 				string.pop(i)
@@ -102,7 +95,7 @@ def assemble_transformation(ops, i, j):
 				file.write('%-16s' % 'Delete %c' % op[1])
 				file.write('\t\t\t' + ''.join(string))
 				file.write('\r\n')
-				
+
 				cost += 2
 			else:
 				string.insert(i, op[1])
@@ -110,12 +103,12 @@ def assemble_transformation(ops, i, j):
 				file.write('%-16s' % 'Insert %c' % op[1])
 				file.write('\t\t\t' + ''.join(string))
 				file.write('\r\n')
-				
+
 				cost += 2
 
 			i += 1
 
 		print(''.join(string))
 		print('Cost: ', cost)
-		
+
 		file.write('\r\nMinimum cost: ' + str(cost))

From 2304e31994539ca9773eb8cd07758ee91fcc9375 Mon Sep 17 00:00:00 2001
From: Hector S <hfsam88@gmail.com>
Date: Tue, 20 Aug 2019 01:02:43 -0400
Subject: [PATCH 193/348] Fixing lgtm issue in basic graphs (#1141)

* Added print function into matrix_multiplication_addition.py and removed blank space in data_structures/binary tree directory

* Removed .vs/ folder per #893

* Rename matrix_multiplication_addition.py to matrix_operation.py

* Fixing lgtm issue in basic_graphs per ##1024

* Fixed lgtm issue per @cclauss recommendation in #1024
---
 graphs/basic_graphs.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/graphs/basic_graphs.py b/graphs/basic_graphs.py
index 64c51e139cca..308abc0839fa 100644
--- a/graphs/basic_graphs.py
+++ b/graphs/basic_graphs.py
@@ -128,7 +128,9 @@ def dijk(G, s):
 from collections import deque
 
 
-def topo(G, ind=None, Q=[1]):
+def topo(G, ind=None, Q=None):
+    if Q is None:
+        Q = [1]
     if ind is None:
         ind = [0] * (len(G) + 1)  # SInce oth Index is ignored
         for u in G:

From 47cb394b5c9a42682803f09d41b3cbe9d1b09304 Mon Sep 17 00:00:00 2001
From: pathak-deep15 <44609019+pathak-deep15@users.noreply.github.com>
Date: Thu, 22 Aug 2019 22:25:41 +0530
Subject: [PATCH 194/348] added doctests for compare_string and is_for_table
 (#1138)

* added doctests for compare_string and is_for_table

>>>compare_string('0010','0110')
       '0_10'
>>> is_for_table('__1','011',2)
	True
The above doctests were added

* Update quine_mc_cluskey.py

* Update quine_mc_cluskey.py

* Update quine_mc_cluskey.py
---
 boolean_algebra/quine_mc_cluskey.py | 48 ++++++++++++++++++++---------
 1 file changed, 33 insertions(+), 15 deletions(-)

diff --git a/boolean_algebra/quine_mc_cluskey.py b/boolean_algebra/quine_mc_cluskey.py
index 94319ca45482..b7ca8da437a3 100644
--- a/boolean_algebra/quine_mc_cluskey.py
+++ b/boolean_algebra/quine_mc_cluskey.py
@@ -1,19 +1,11 @@
-"""
-	doctests
-
-	>>> decimal_to_binary(3,[1.5])
-	['0.00.01.5']
-
-	>>> check(['0.00.01.5'])
-	['0.00.01.5']
-
-	>>> prime_implicant_chart(['0.00.01.5'],['0.00.01.5'])
-	[[1]]
-
-	>>> selection([[1]],['0.00.01.5'])
-	['0.00.01.5']
-"""
 def compare_string(string1, string2):
+	"""
+	>>> compare_string('0010','0110')
+	'0_10'
+	
+	>>> compare_string('0110','1101')
+	-1
+	"""
 	l1 = list(string1); l2 = list(string2)
 	count = 0
 	for i in range(len(l1)):
@@ -26,6 +18,10 @@ def compare_string(string1, string2):
 		return("".join(l1))
 
 def check(binary):
+	"""
+	>>> check(['0.00.01.5'])
+	['0.00.01.5']
+	"""
 	pi = []
 	while 1:
 		check1 = ['$']*len(binary)
@@ -45,6 +41,10 @@ def check(binary):
 		binary = list(set(temp))
 
 def decimal_to_binary(no_of_variable, minterms):
+	"""
+	>>> decimal_to_binary(3,[1.5])
+	['0.00.01.5']
+	"""
 	temp = []
 	s = ''
 	for m in minterms:
@@ -56,6 +56,13 @@ def decimal_to_binary(no_of_variable, minterms):
 	return temp
 
 def is_for_table(string1, string2, count):
+	"""
+	>>> is_for_table('__1','011',2)
+	True
+	
+	>>> is_for_table('01_','001',1)
+	False
+	"""
 	l1 = list(string1);l2=list(string2)
 	count_n = 0
 	for i in range(len(l1)):
@@ -67,6 +74,13 @@ def is_for_table(string1, string2, count):
 		return False 
 
 def selection(chart, prime_implicants):
+	"""
+	>>> selection([[1]],['0.00.01.5'])
+	['0.00.01.5']
+	
+	>>> selection([[1]],['0.00.01.5'])
+	['0.00.01.5']
+	"""
 	temp = []
 	select = [0]*len(chart)
 	for i in range(len(chart[0])):
@@ -104,6 +118,10 @@ def selection(chart, prime_implicants):
 					chart[j][i] = 0
 		
 def prime_implicant_chart(prime_implicants, binary):
+	"""
+	>>> prime_implicant_chart(['0.00.01.5'],['0.00.01.5'])
+	[[1]]
+	"""
 	chart = [[0 for x in range(len(binary))] for x in range(len(prime_implicants))]
 	for i in range(len(prime_implicants)):
 		count = prime_implicants[i].count('_')

From e694e596a3fc42ae5f28f0e267c44f74948e25ee Mon Sep 17 00:00:00 2001
From: Nishant Aklecha <31594715+Naklecha@users.noreply.github.com>
Date: Sun, 25 Aug 2019 17:44:17 +0530
Subject: [PATCH 195/348] Added a few doctests for traversals (#1149)

---
 traversals/binary_tree_traversals.py | 116 +++++++++++++++++++++++++++
 1 file changed, 116 insertions(+)

diff --git a/traversals/binary_tree_traversals.py b/traversals/binary_tree_traversals.py
index 7fd9f7111844..389311a7cfde 100644
--- a/traversals/binary_tree_traversals.py
+++ b/traversals/binary_tree_traversals.py
@@ -39,6 +39,20 @@ def build_tree():
 
 
 def pre_order(node: TreeNode) -> None:
+    """
+    >>> root = TreeNode(1)
+    >>> tree_node2 = TreeNode(2)
+    >>> tree_node3 = TreeNode(3)
+    >>> tree_node4 = TreeNode(4)
+    >>> tree_node5 = TreeNode(5)
+    >>> tree_node6 = TreeNode(6)
+    >>> tree_node7 = TreeNode(7)
+    >>> root.left, root.right = tree_node2, tree_node3
+    >>> tree_node2.left, tree_node2.right = tree_node4 , tree_node5
+    >>> tree_node3.left, tree_node3.right = tree_node6 , tree_node7
+    >>> pre_order(root)
+    1 2 4 5 3 6 7 
+    """
     if not isinstance(node, TreeNode) or not node:
         return
     print(node.data, end=" ")
@@ -47,6 +61,20 @@ def pre_order(node: TreeNode) -> None:
 
 
 def in_order(node: TreeNode) -> None:
+    """
+    >>> root = TreeNode(1)
+    >>> tree_node2 = TreeNode(2)
+    >>> tree_node3 = TreeNode(3)
+    >>> tree_node4 = TreeNode(4)
+    >>> tree_node5 = TreeNode(5)
+    >>> tree_node6 = TreeNode(6)
+    >>> tree_node7 = TreeNode(7)
+    >>> root.left, root.right = tree_node2, tree_node3
+    >>> tree_node2.left, tree_node2.right = tree_node4 , tree_node5
+    >>> tree_node3.left, tree_node3.right = tree_node6 , tree_node7
+    >>> in_order(root)
+    4 2 5 1 6 3 7 
+    """
     if not isinstance(node, TreeNode) or not node:
         return
     in_order(node.left)
@@ -55,6 +83,20 @@ def in_order(node: TreeNode) -> None:
 
 
 def post_order(node: TreeNode) -> None:
+    """
+    >>> root = TreeNode(1)
+    >>> tree_node2 = TreeNode(2)
+    >>> tree_node3 = TreeNode(3)
+    >>> tree_node4 = TreeNode(4)
+    >>> tree_node5 = TreeNode(5)
+    >>> tree_node6 = TreeNode(6)
+    >>> tree_node7 = TreeNode(7)
+    >>> root.left, root.right = tree_node2, tree_node3
+    >>> tree_node2.left, tree_node2.right = tree_node4 , tree_node5
+    >>> tree_node3.left, tree_node3.right = tree_node6 , tree_node7
+    >>> post_order(root)
+    4 5 2 6 7 3 1 
+    """
     if not isinstance(node, TreeNode) or not node:
         return
     post_order(node.left)
@@ -63,6 +105,20 @@ def post_order(node: TreeNode) -> None:
 
 
 def level_order(node: TreeNode) -> None:
+    """
+    >>> root = TreeNode(1)
+    >>> tree_node2 = TreeNode(2)
+    >>> tree_node3 = TreeNode(3)
+    >>> tree_node4 = TreeNode(4)
+    >>> tree_node5 = TreeNode(5)
+    >>> tree_node6 = TreeNode(6)
+    >>> tree_node7 = TreeNode(7)
+    >>> root.left, root.right = tree_node2, tree_node3
+    >>> tree_node2.left, tree_node2.right = tree_node4 , tree_node5
+    >>> tree_node3.left, tree_node3.right = tree_node6 , tree_node7
+    >>> level_order(root)
+    1 2 3 4 5 6 7 
+    """
     if not isinstance(node, TreeNode) or not node:
         return
     q: queue.Queue = queue.Queue()
@@ -77,6 +133,22 @@ def level_order(node: TreeNode) -> None:
 
 
 def level_order_actual(node: TreeNode) -> None:
+    """
+    >>> root = TreeNode(1)
+    >>> tree_node2 = TreeNode(2)
+    >>> tree_node3 = TreeNode(3)
+    >>> tree_node4 = TreeNode(4)
+    >>> tree_node5 = TreeNode(5)
+    >>> tree_node6 = TreeNode(6)
+    >>> tree_node7 = TreeNode(7)
+    >>> root.left, root.right = tree_node2, tree_node3
+    >>> tree_node2.left, tree_node2.right = tree_node4 , tree_node5
+    >>> tree_node3.left, tree_node3.right = tree_node6 , tree_node7
+    >>> level_order_actual(root)
+    1 
+    2 3 
+    4 5 6 7 
+    """
     if not isinstance(node, TreeNode) or not node:
         return
     q: queue.Queue = queue.Queue()
@@ -97,6 +169,20 @@ def level_order_actual(node: TreeNode) -> None:
 
 # iteration version
 def pre_order_iter(node: TreeNode) -> None:
+    """
+    >>> root = TreeNode(1)
+    >>> tree_node2 = TreeNode(2)
+    >>> tree_node3 = TreeNode(3)
+    >>> tree_node4 = TreeNode(4)
+    >>> tree_node5 = TreeNode(5)
+    >>> tree_node6 = TreeNode(6)
+    >>> tree_node7 = TreeNode(7)
+    >>> root.left, root.right = tree_node2, tree_node3
+    >>> tree_node2.left, tree_node2.right = tree_node4 , tree_node5
+    >>> tree_node3.left, tree_node3.right = tree_node6 , tree_node7
+    >>> pre_order_iter(root)
+    1 2 4 5 3 6 7 
+    """
     if not isinstance(node, TreeNode) or not node:
         return
     stack: List[TreeNode] = []
@@ -113,6 +199,20 @@ def pre_order_iter(node: TreeNode) -> None:
 
 
 def in_order_iter(node: TreeNode) -> None:
+    """
+    >>> root = TreeNode(1)
+    >>> tree_node2 = TreeNode(2)
+    >>> tree_node3 = TreeNode(3)
+    >>> tree_node4 = TreeNode(4)
+    >>> tree_node5 = TreeNode(5)
+    >>> tree_node6 = TreeNode(6)
+    >>> tree_node7 = TreeNode(7)
+    >>> root.left, root.right = tree_node2, tree_node3
+    >>> tree_node2.left, tree_node2.right = tree_node4 , tree_node5
+    >>> tree_node3.left, tree_node3.right = tree_node6 , tree_node7
+    >>> in_order_iter(root)
+    4 2 5 1 6 3 7 
+    """
     if not isinstance(node, TreeNode) or not node:
         return
     stack: List[TreeNode] = []
@@ -127,6 +227,20 @@ def in_order_iter(node: TreeNode) -> None:
 
 
 def post_order_iter(node: TreeNode) -> None:
+    """
+    >>> root = TreeNode(1)
+    >>> tree_node2 = TreeNode(2)
+    >>> tree_node3 = TreeNode(3)
+    >>> tree_node4 = TreeNode(4)
+    >>> tree_node5 = TreeNode(5)
+    >>> tree_node6 = TreeNode(6)
+    >>> tree_node7 = TreeNode(7)
+    >>> root.left, root.right = tree_node2, tree_node3
+    >>> tree_node2.left, tree_node2.right = tree_node4 , tree_node5
+    >>> tree_node3.left, tree_node3.right = tree_node6 , tree_node7
+    >>> post_order_iter(root)
+    4 5 2 6 7 3 1 
+    """
     if not isinstance(node, TreeNode) or not node:
         return
     stack1, stack2 = [], []
@@ -151,6 +265,8 @@ def prompt(s: str = "", width=50, char="*") -> str:
 
 
 if __name__ == "__main__":
+    import doctest
+    doctest.testmod()
     print(prompt("Binary Tree Traversals"))
 
     node = build_tree()

From 2f8516e561dc07571e48044f75a942db05068fa9 Mon Sep 17 00:00:00 2001
From: Riemann <40825655+anand372@users.noreply.github.com>
Date: Wed, 28 Aug 2019 16:26:43 +0530
Subject: [PATCH 196/348] implementation of sorted vector machines (#1156)

* svm.py

for issue #840
I would like to add the Support Vector Machine algorithm implemented in Python 3.6.7
Requirements:
      - sklearn

* update svm.py

* update svm.py

* Update and renamed to sorted_vector_machines.py

* Updated sorted_vector_machines.py
---
 machine_learning/sorted_vector_machines.py | 54 ++++++++++++++++++++++
 1 file changed, 54 insertions(+)
 create mode 100644 machine_learning/sorted_vector_machines.py

diff --git a/machine_learning/sorted_vector_machines.py b/machine_learning/sorted_vector_machines.py
new file mode 100644
index 000000000000..92fa814c998f
--- /dev/null
+++ b/machine_learning/sorted_vector_machines.py
@@ -0,0 +1,54 @@
+from sklearn.datasets import load_iris
+from sklearn import svm
+from sklearn.model_selection import train_test_split
+import doctest
+
+# different functions implementing different types of SVM's
+def NuSVC(train_x, train_y):
+    svc_NuSVC = svm.NuSVC()
+    svc_NuSVC.fit(train_x, train_y)
+    return svc_NuSVC
+
+
+def Linearsvc(train_x, train_y):
+    svc_linear = svm.LinearSVC()
+    svc_linear.fit(train_x, train_y)
+    return svc_linear
+
+
+def SVC(train_x, train_y):
+    # svm.SVC(C=1.0, kernel='rbf', degree=3, gamma=0.0, coef0=0.0, shrinking=True, probability=False,tol=0.001, cache_size=200, class_weight=None, verbose=False, max_iter=-1, random_state=None)
+    # various parameters like "kernal","gamma","C" can effectively tuned for a given machine learning model.
+    SVC = svm.SVC(gamma="auto")
+    SVC.fit(train_x, train_y)
+    return SVC
+
+
+def test(X_new):
+    """
+    3 test cases to be passed
+    an array containing the sepal length (cm), sepal width (cm),petal length (cm),petal width (cm)
+    based on which  the target name will be predicted
+    >>> test([1,2,1,4])
+    'virginica'
+    >>> test([5, 2, 4, 1])
+    'versicolor'
+    >>> test([6,3,4,1])
+    'versicolor'
+
+    """
+    iris = load_iris()
+    # splitting the dataset to test and train
+    train_x, test_x, train_y, test_y = train_test_split(
+        iris["data"], iris["target"], random_state=4
+    )
+    # any of the 3 types of SVM can be used
+    # current_model=SVC(train_x, train_y)
+    # current_model=NuSVC(train_x, train_y)
+    current_model = Linearsvc(train_x, train_y)
+    prediction = current_model.predict([X_new])
+    return iris["target_names"][prediction][0]
+
+
+if __name__ == "__main__":
+    doctest.testmod()

From 82a079c209bf7836baade1aa4e7a6e3a85b740a2 Mon Sep 17 00:00:00 2001
From: Harshil <darjiharshil2994@gmail.com>
Date: Wed, 28 Aug 2019 17:16:12 +0200
Subject: [PATCH 197/348] add .github/stale.yml (#1158)

---
 .github/stale.yml | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 .github/stale.yml

diff --git a/.github/stale.yml b/.github/stale.yml
new file mode 100644
index 000000000000..6af2a10216b8
--- /dev/null
+++ b/.github/stale.yml
@@ -0,0 +1,18 @@
+# Number of days of inactivity before an issue becomes stale
+daysUntilStale: 14
+# Number of days of inactivity before a stale issue is closed
+daysUntilClose: 7
+# Issues with these labels will never be considered stale
+exemptLabels:
+  - bug
+  - help wanted
+  - OK to merge
+# Label to use when marking an issue as stale
+staleLabel: wontfix
+# Comment to post when marking an issue as stale. Set to `false` to disable
+markComment: >
+  This issue has been automatically marked as stale because it has not had
+  recent activity. It will be closed if no further activity occurs. Thank you
+  for your contributions.
+# Comment to post when closing a stale issue. Set to `false` to disable
+closeComment: false
\ No newline at end of file

From d327f107022a51f8ae75436d6dae20fda34622ee Mon Sep 17 00:00:00 2001
From: Rohit Gupta <rohit1997gupta@gmail.com>
Date: Thu, 29 Aug 2019 00:53:42 +0530
Subject: [PATCH 198/348] Update stale.yml

---
 .github/stale.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/stale.yml b/.github/stale.yml
index 6af2a10216b8..70032115fc2c 100644
--- a/.github/stale.yml
+++ b/.github/stale.yml
@@ -1,5 +1,5 @@
 # Number of days of inactivity before an issue becomes stale
-daysUntilStale: 14
+daysUntilStale: 30
 # Number of days of inactivity before a stale issue is closed
 daysUntilClose: 7
 # Issues with these labels will never be considered stale
@@ -15,4 +15,4 @@ markComment: >
   recent activity. It will be closed if no further activity occurs. Thank you
   for your contributions.
 # Comment to post when closing a stale issue. Set to `false` to disable
-closeComment: false
\ No newline at end of file
+closeComment: true

From d4151bd5164d99a8184a4d842fe5e36305716dbc Mon Sep 17 00:00:00 2001
From: Rwithik Manoj <thoriumnitride@gmail.com>
Date: Sat, 31 Aug 2019 17:10:50 +0530
Subject: [PATCH 199/348] Fix possible error in longest_common_subsequence.py
 (#1163)

The comparison at line 53 was not checking if (j > 0).
---
 dynamic_programming/longest_common_subsequence.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dynamic_programming/longest_common_subsequence.py b/dynamic_programming/longest_common_subsequence.py
index 7447a0cc7810..d39485408988 100644
--- a/dynamic_programming/longest_common_subsequence.py
+++ b/dynamic_programming/longest_common_subsequence.py
@@ -50,7 +50,7 @@ def longest_common_subsequence(x: str, y: str):
 
     seq = ""
     i, j = m, n
-    while i > 0 and i > 0:
+    while i > 0 and j > 0:
         if x[i - 1] == y[j - 1]:
             match = 1
         else:

From d567a9eb8c1bf00e7bc5a007f21e3c977d7f83ec Mon Sep 17 00:00:00 2001
From: b63 <52578583+b63@users.noreply.github.com>
Date: Sun, 1 Sep 2019 01:07:31 -0500
Subject: [PATCH 200/348] solution to problem 551 from project euler (#1164)

* solution to problem 551 from project euler

* renamed variables, and added more comments to improve readabilty
---
 project_euler/problem_551/__init__.py |   0
 project_euler/problem_551/sol1.py     | 204 ++++++++++++++++++++++++++
 2 files changed, 204 insertions(+)
 create mode 100644 project_euler/problem_551/__init__.py
 create mode 100644 project_euler/problem_551/sol1.py

diff --git a/project_euler/problem_551/__init__.py b/project_euler/problem_551/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/project_euler/problem_551/sol1.py b/project_euler/problem_551/sol1.py
new file mode 100644
index 000000000000..238d7b772190
--- /dev/null
+++ b/project_euler/problem_551/sol1.py
@@ -0,0 +1,204 @@
+"""
+Sum of digits sequence
+Problem 551
+
+Let a(0), a(1),... be an interger sequence defined by:
+     a(0) = 1
+     for n >= 1, a(n) is the sum of the digits of all preceding terms
+
+The sequence starts with 1, 1, 2, 4, 8, ...
+You are given a(10^6) = 31054319.
+
+Find a(10^15)
+"""
+
+ks = [k for k in range(2, 20+1)]
+base = [10 ** k for k in range(ks[-1] + 1)]
+memo = {}
+
+
+def next_term(a_i, k, i, n):
+    """
+    Calculates and updates a_i in-place to either the n-th term or the
+    smallest term for which c > 10^k when the terms are written in the form:
+            a(i) = b * 10^k + c
+
+    For any a(i), if digitsum(b) and c have the same value, the difference
+    between subsequent terms will be the same until c >= 10^k.  This difference
+    is cached to greatly speed up the computation.
+
+    Arguments:
+    a_i -- array of digits starting from the one's place that represent 
+           the i-th term in the sequence
+    k --  k when terms are written in the from a(i) = b*10^k + c.
+          Term are calulcated until c > 10^k or the n-th term is reached.
+    i -- position along the sequence
+    n -- term to caluclate up to if k is large enough
+
+    Return: a tuple of difference between ending term and starting term, and
+    the number of terms calculated. ex. if starting term is a_0=1, and
+    ending term is a_10=62, then (61, 9) is returned.
+    """
+    # ds_b - digitsum(b)
+    ds_b = 0
+    for j in range(k, len(a_i)):
+        ds_b += a_i[j]
+    c = 0
+    for j in range(min(len(a_i), k)):
+        c += a_i[j] * base[j]
+
+    diff, dn = 0, 0
+    max_dn = n - i
+
+    sub_memo = memo.get(ds_b)
+
+    if sub_memo != None:
+        jumps = sub_memo.get(c)
+
+        if jumps != None and len(jumps) > 0:
+            # find and make the largest jump without going over
+            max_jump = -1
+            for _k in range(len(jumps) - 1, -1, -1):
+                if jumps[_k][2] <= k and jumps[_k][1] <= max_dn:
+                    max_jump = _k
+                    break
+
+            if max_jump >= 0:
+                diff, dn, _kk = jumps[max_jump]
+                # since the difference between jumps is cached, add c
+                new_c = diff + c
+                for j in range(min(k, len(a_i))):
+                    new_c, a_i[j] = divmod(new_c, 10)
+                if new_c > 0:
+                    add(a_i, k, new_c)
+
+        else:
+            sub_memo[c] = []
+    else:
+        sub_memo = {c: []}
+        memo[ds_b] = sub_memo
+
+    if dn >= max_dn or c + diff >= base[k]:
+        return diff, dn
+
+    if k > ks[0]:
+        while True:
+            # keep doing smaller jumps
+            _diff, terms_jumped = next_term(a_i, k - 1, i + dn, n)
+            diff += _diff
+            dn += terms_jumped
+
+            if dn >= max_dn or c + diff >= base[k]:
+                break
+    else:
+        # would be too small a jump, just compute sequential terms instead
+        _diff, terms_jumped = compute(a_i, k, i + dn, n)
+        diff += _diff
+        dn += terms_jumped
+
+    jumps = sub_memo[c]
+
+    # keep jumps sorted by # of terms skipped
+    j = 0
+    while j < len(jumps):
+        if jumps[j][1] > dn:
+            break
+        j += 1
+
+    # cache the jump for this value digitsum(b) and c
+    sub_memo[c].insert(j, (diff, dn, k))
+    return (diff, dn)
+
+
+def compute(a_i, k, i, n):
+    """
+    same as next_term(a_i, k, i, n) but computes terms without memoizing results.
+    """
+    if i >= n:
+        return 0, i
+    if k > len(a_i):
+        a_i.extend([0 for _ in range(k - len(a_i))])
+
+    # note: a_i -> b * 10^k + c
+    # ds_b -> digitsum(b)
+    # ds_c -> digitsum(c)
+    start_i = i
+    ds_b, ds_c, diff = 0, 0, 0
+    for j in range(len(a_i)):
+        if j >= k:
+            ds_b += a_i[j]
+        else:
+            ds_c += a_i[j]
+
+    while i < n:
+        i += 1
+        addend = ds_c + ds_b
+        diff += addend
+        ds_c = 0
+        for j in range(k):
+            s = a_i[j] + addend
+            addend, a_i[j] = divmod(s, 10)
+
+            ds_c += a_i[j]
+
+        if addend > 0:
+            break
+
+    if addend > 0:
+        add(a_i, k, addend)
+    return diff, i - start_i
+
+
+def add(digits, k, addend):
+    """
+    adds addend to digit array given in digits
+    starting at index k
+    """
+    for j in range(k, len(digits)):
+        s = digits[j] + addend
+        if s >= 10:
+            quotient, digits[j] = divmod(s, 10)
+            addend = addend // 10 + quotient
+        else:
+            digits[j] = s
+            addend = addend // 10
+
+        if addend == 0:
+            break
+
+    while addend > 0:
+        addend, digit = divmod(addend, 10)
+        digits.append(digit)
+
+
+def solution(n):
+    """
+    returns n-th term of sequence
+
+    >>> solution(10)
+    62
+
+    >>> solution(10**6)
+    31054319
+
+    >>> solution(10**15)
+    73597483551591773
+    """
+
+    digits = [1]
+    i = 1
+    dn = 0
+    while True:
+        diff, terms_jumped = next_term(digits, 20, i + dn, n)
+        dn += terms_jumped
+        if dn == n - i:
+            break
+
+    a_n = 0
+    for j in range(len(digits)):
+        a_n += digits[j] * 10 ** j
+    return a_n
+
+
+if __name__ == "__main__":
+    print(solution(10 ** 15))

From 9492e7af7cb24bb2fbe9e814c2e96dde96e95909 Mon Sep 17 00:00:00 2001
From: McDic <spongbob9876@naver.com>
Date: Tue, 3 Sep 2019 16:02:53 +0900
Subject: [PATCH 201/348] Created Sherman Morrison method (#1162)

* Created Sherman Morrison

* Added docstring for class

* Updated Sherman morrison

1. Added docstring tests
2. Tweaked __str__() using join
3. Added __repr__()
4. Changed index validation to be independent method

* Applied cclauss's point

1. Reduced line length for __str__()
2. Removed parens for assert
---
 matrix/sherman_morrison.py | 255 +++++++++++++++++++++++++++++++++++++
 1 file changed, 255 insertions(+)
 create mode 100644 matrix/sherman_morrison.py

diff --git a/matrix/sherman_morrison.py b/matrix/sherman_morrison.py
new file mode 100644
index 000000000000..0d49d78509be
--- /dev/null
+++ b/matrix/sherman_morrison.py
@@ -0,0 +1,255 @@
+class Matrix:
+    """
+    <class Matrix>
+    Matrix structure.
+    """
+
+    def __init__(self, row: int, column: int, default_value: float = 0):
+        """
+        <method Matrix.__init__>
+        Initialize matrix with given size and default value.
+
+        Example:
+        >>> a = Matrix(2, 3, 1)
+        >>> a 
+        Matrix consist of 2 rows and 3 columns
+        [1, 1, 1]
+        [1, 1, 1]
+        """
+
+        self.row, self.column = row, column
+        self.array = [[default_value for c in range(column)] for r in range(row)]
+
+    def __str__(self):
+        """
+        <method Matrix.__str__>
+        Return string representation of this matrix.
+        """
+
+        # Prefix
+        s = "Matrix consist of %d rows and %d columns\n" % (self.row, self.column)
+        
+        # Make string identifier
+        max_element_length = 0
+        for row_vector in self.array:
+            for obj in row_vector:
+                max_element_length = max(max_element_length, len(str(obj)))
+        string_format_identifier = "%%%ds" % (max_element_length,)
+
+        # Make string and return
+        def single_line(row_vector): 
+            nonlocal string_format_identifier
+            line = "["
+            line += ", ".join(string_format_identifier % (obj,) for obj in row_vector)
+            line += "]"
+            return line
+        s += "\n".join(single_line(row_vector) for row_vector in self.array)
+        return s
+
+    def __repr__(self): return str(self)
+
+    def validateIndices(self, loc: tuple):
+        """
+        <method Matrix.validateIndices>
+        Check if given indices are valid to pick element from matrix.
+
+        Example:
+        >>> a = Matrix(2, 6, 0)
+        >>> a.validateIndices((2, 7))
+        False
+        >>> a.validateIndices((0, 0))
+        True
+        """
+        if not(isinstance(loc, (list, tuple)) and len(loc) == 2): return False
+        elif not(0 <= loc[0] < self.row and 0 <= loc[1] < self.column): return False
+        else: return True
+
+    def __getitem__(self, loc: tuple):
+        """
+        <method Matrix.__getitem__>
+        Return array[row][column] where loc = (row, column).
+
+        Example:
+        >>> a = Matrix(3, 2, 7)
+        >>> a[1, 0]
+        7
+        """
+        assert self.validateIndices(loc)
+        return self.array[loc[0]][loc[1]]
+
+    def __setitem__(self, loc: tuple, value: float):
+        """
+        <method Matrix.__setitem__>
+        Set array[row][column] = value where loc = (row, column).
+
+        Example:
+        >>> a = Matrix(2, 3, 1)
+        >>> a[1, 2] = 51
+        >>> a
+        Matrix consist of 2 rows and 3 columns
+        [ 1,  1,  1]
+        [ 1,  1, 51]
+        """
+        assert self.validateIndices(loc)
+        self.array[loc[0]][loc[1]] = value
+
+    def __add__(self, another):
+        """
+        <method Matrix.__add__>
+        Return self + another.
+
+        Example:
+        >>> a = Matrix(2, 1, -4)
+        >>> b = Matrix(2, 1, 3)
+        >>> a+b
+        Matrix consist of 2 rows and 1 columns
+        [-1]
+        [-1]
+        """
+
+        # Validation
+        assert isinstance(another, Matrix)
+        assert self.row == another.row and self.column == another.column
+
+        # Add
+        result = Matrix(self.row, self.column)
+        for r in range(self.row):
+            for c in range(self.column):
+                result[r,c] = self[r,c] + another[r,c]
+        return result
+
+    def __neg__(self):
+        """
+        <method Matrix.__neg__>
+        Return -self.
+
+        Example:
+        >>> a = Matrix(2, 2, 3)
+        >>> a[0, 1] = a[1, 0] = -2
+        >>> -a
+        Matrix consist of 2 rows and 2 columns
+        [-3,  2]
+        [ 2, -3]
+        """
+
+        result = Matrix(self.row, self.column)
+        for r in range(self.row):
+            for c in range(self.column):
+                result[r,c] = -self[r,c]
+        return result
+
+    def __sub__(self, another): return self + (-another)
+
+    def __mul__(self, another):
+        """
+        <method Matrix.__mul__>
+        Return self * another.
+
+        Example:
+        >>> a = Matrix(2, 3, 1)
+        >>> a[0,2] = a[1,2] = 3
+        >>> a * -2
+        Matrix consist of 2 rows and 3 columns
+        [-2, -2, -6]
+        [-2, -2, -6]
+        """
+
+        if isinstance(another, (int, float)): # Scalar multiplication
+            result = Matrix(self.row, self.column)
+            for r in range(self.row):
+                for c in range(self.column):
+                    result[r,c] = self[r,c] * another
+            return result
+        elif isinstance(another, Matrix): # Matrix multiplication
+            assert(self.column == another.row)
+            result = Matrix(self.row, another.column)
+            for r in range(self.row):
+                for c in range(another.column):
+                    for i in range(self.column):
+                        result[r,c] += self[r,i] * another[i,c]
+            return result
+        else: raise TypeError("Unsupported type given for another (%s)" % (type(another),))
+
+    def transpose(self):
+        """
+        <method Matrix.transpose>
+        Return self^T.
+
+        Example:
+        >>> a = Matrix(2, 3)
+        >>> for r in range(2):       
+        ...     for c in range(3):
+        ...             a[r,c] = r*c
+        ... 
+        >>> a.transpose()
+        Matrix consist of 3 rows and 2 columns
+        [0, 0]
+        [0, 1]
+        [0, 2]
+        """
+
+        result = Matrix(self.column, self.row)
+        for r in range(self.row):
+            for c in range(self.column):
+                result[c,r] = self[r,c]
+        return result
+
+    def ShermanMorrison(self, u, v):
+        """
+        <method Matrix.ShermanMorrison>
+        Apply Sherman-Morrison formula in O(n^2).
+        To learn this formula, please look this: https://en.wikipedia.org/wiki/Sherman%E2%80%93Morrison_formula
+        This method returns (A + uv^T)^(-1) where A^(-1) is self. Returns None if it's impossible to calculate.
+        Warning: This method doesn't check if self is invertible. 
+            Make sure self is invertible before execute this method.
+
+        Example:
+        >>> ainv = Matrix(3, 3, 0)
+        >>> for i in range(3): ainv[i,i] = 1
+        ... 
+        >>> u = Matrix(3, 1, 0) 
+        >>> u[0,0], u[1,0], u[2,0] = 1, 2, -3
+        >>> v = Matrix(3, 1, 0)
+        >>> v[0,0], v[1,0], v[2,0] = 4, -2, 5
+        >>> ainv.ShermanMorrison(u, v)
+        Matrix consist of 3 rows and 3 columns
+        [  1.2857142857142856, -0.14285714285714285,   0.3571428571428571]
+        [  0.5714285714285714,   0.7142857142857143,   0.7142857142857142]
+        [ -0.8571428571428571,  0.42857142857142855,  -0.0714285714285714]
+        """
+
+        # Size validation
+        assert isinstance(u, Matrix) and isinstance(v, Matrix)
+        assert self.row == self.column == u.row == v.row # u, v should be column vector
+        assert u.column == v.column == 1 # u, v should be column vector
+
+        # Calculate
+        vT = v.transpose()
+        numerator_factor = (vT * self * u)[0, 0] + 1
+        if numerator_factor == 0: return None # It's not invertable
+        return self - ((self * u) * (vT * self) * (1.0 / numerator_factor))
+
+# Testing
+if __name__ == "__main__":
+
+    def test1():
+        # a^(-1)
+        ainv = Matrix(3, 3, 0)
+        for i in range(3): ainv[i,i] = 1
+        print("a^(-1) is %s" % (ainv,))
+        # u, v
+        u = Matrix(3, 1, 0)
+        u[0,0], u[1,0], u[2,0] = 1, 2, -3
+        v = Matrix(3, 1, 0)
+        v[0,0], v[1,0], v[2,0] = 4, -2, 5
+        print("u is %s" % (u,))
+        print("v is %s" % (v,))
+        print("uv^T is %s" % (u * v.transpose()))
+        # Sherman Morrison
+        print("(a + uv^T)^(-1) is %s" % (ainv.ShermanMorrison(u, v),))
+
+    def test2():
+        import doctest
+        doctest.testmod()
+
+    test2()
\ No newline at end of file

From a4ed40be86e79375ea54421fda9d860a3e0526e2 Mon Sep 17 00:00:00 2001
From: Maxwell Aladago <maxwell.aladago@gmail.com>
Date: Wed, 4 Sep 2019 16:06:44 -0400
Subject: [PATCH 202/348] changing typo (#1168)

---
 divide_and_conquer/convex_hull.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/divide_and_conquer/convex_hull.py b/divide_and_conquer/convex_hull.py
index 42219794aed1..a0c319e766da 100644
--- a/divide_and_conquer/convex_hull.py
+++ b/divide_and_conquer/convex_hull.py
@@ -7,7 +7,7 @@
 
 Two algorithms have been implemented for the convex hull problem here.
 1. A brute-force algorithm which runs in O(n^3)
-2. A divide-and-conquer algorithm which runs in O(n^3)
+2. A divide-and-conquer algorithm which runs in O(n log(n))
 
 There are other several other algorithms for the convex hull problem
 which have not been implemented here, yet.

From f31a812c468e41c3f5f7f170ae1dd5fa13bae6dd Mon Sep 17 00:00:00 2001
From: KirilBangachev <51961981+KirilBangachev@users.noreply.github.com>
Date: Thu, 5 Sep 2019 08:58:38 +0300
Subject: [PATCH 203/348] Add Binomial Heap (#1146)

* Binomial Heap

Implementation of Binomial Heap. Reference: Advanced Data Structures, Peter Brass

* Update binomial_heap.py

* Update binomial_heap.py

* Update binomial_heap.py

- Fuller documentation of binomial heap
- Update unit tests
- Replace printing method by overwriting __str__()

* Update binomial_heap.py

- Added more tests
- Added to the documentation
- Stylistic editing
- mergeHeaps now also returns a reference to the merged heap
- added a preOrder function that returns a list with the preorder of the heap

* Update binomial_heap.py

Changed the unit tests structure

* Turned the tests into doctests
---
 data_structures/heap/binomial_heap.py | 442 ++++++++++++++++++++++++++
 1 file changed, 442 insertions(+)
 create mode 100644 data_structures/heap/binomial_heap.py

diff --git a/data_structures/heap/binomial_heap.py b/data_structures/heap/binomial_heap.py
new file mode 100644
index 000000000000..bc9cb5145f2e
--- /dev/null
+++ b/data_structures/heap/binomial_heap.py
@@ -0,0 +1,442 @@
+"""
+    Binomial Heap 
+    
+    Reference: Advanced Data Structures, Peter Brass   
+"""
+
+
+class Node:
+    """
+    Node in a doubly-linked binomial tree, containing:
+        - value
+        - size of left subtree
+        - link to left, right and parent nodes    
+    """
+
+    def __init__(self, val):
+        self.val = val
+        # Number of nodes in left subtree
+        self.left_tree_size = 0
+        self.left = None
+        self.right = None
+        self.parent = None
+
+    def mergeTrees(self, other):
+        """
+            In-place merge of two binomial trees of equal size. 
+            Returns the root of the resulting tree
+        """
+        assert (
+            self.left_tree_size == other.left_tree_size
+        ), "Unequal Sizes of Blocks"
+
+        if self.val < other.val:
+            other.left = self.right
+            other.parent = None
+            if self.right:
+                self.right.parent = other
+            self.right = other
+            self.left_tree_size = (
+                self.left_tree_size * 2 + 1
+            )
+            return self
+        else:
+            self.left = other.right
+            self.parent = None
+            if other.right:
+                other.right.parent = self
+            other.right = self
+            other.left_tree_size = (
+                other.left_tree_size * 2 + 1
+            )
+            return other
+
+
+class BinomialHeap:
+    """
+        Min-oriented priority queue implemented with the Binomial Heap data 
+        structure implemented with the BinomialHeap class. It supports:
+    
+        - Insert element in a heap with n elemnts: Guaranteed logn, amoratized 1
+        - Merge (meld) heaps of size m and n: O(logn + logm)
+        - Delete Min: O(logn) 
+        - Peek (return min without deleting it): O(1)
+            
+        Example:
+            
+        Create a random permutation of 30 integers to be inserted and 
+        19 of them deleted
+        >>> import numpy as np
+        >>> permutation = np.random.permutation(list(range(30)))
+
+        Create a Heap and insert the 30 integers 
+        
+        __init__() test
+        >>> first_heap = BinomialHeap()
+
+        30 inserts - insert() test
+        >>> for number in permutation:
+        ...     first_heap.insert(number)
+        
+        Size test
+        >>> print(first_heap.size)  
+        30
+        
+        Deleting - delete() test
+        >>> for i in range(25):
+        ...     print(first_heap.deleteMin(), end=" ")
+        0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 
+
+        Create a new Heap
+        >>> second_heap = BinomialHeap()
+        >>> vals = [17, 20, 31, 34]
+        >>> for value in vals:
+        ...     second_heap.insert(value)
+        
+        
+        The heap should have the following structure:
+            
+                        17
+                       /  \
+                      #    31
+                          /  \
+                        20    34
+                       /  \  /  \
+                      #    # #   #
+        
+        preOrder() test
+        >>> print(second_heap.preOrder())
+        [(17, 0), ('#', 1), (31, 1), (20, 2), ('#', 3), ('#', 3), (34, 2), ('#', 3), ('#', 3)]
+        
+        printing Heap - __str__() test
+        >>> print(second_heap)
+        17
+        -#
+        -31
+        --20
+        ---#
+        ---#
+        --34
+        ---#
+        ---#
+
+        mergeHeaps() test
+        >>> merged = second_heap.mergeHeaps(first_heap)
+        >>> merged.peek()
+        17
+        
+        values in merged heap; (merge is inplace) 
+        >>> while not first_heap.isEmpty():
+        ...     print(first_heap.deleteMin(), end=" ")
+        17 20 25 26 27 28 29 31 34 
+        
+    """
+
+    def __init__(
+        self, bottom_root=None, min_node=None, heap_size=0
+    ):
+        self.size = heap_size
+        self.bottom_root = bottom_root
+        self.min_node = min_node
+
+    def mergeHeaps(self, other):
+        """
+            In-place merge of two binomial heaps. 
+            Both of them become the resulting merged heap
+        """
+
+        # Empty heaps corner cases
+        if other.size == 0:
+            return
+        if self.size == 0:
+            self.size = other.size
+            self.bottom_root = other.bottom_root
+            self.min_node = other.min_node
+            return
+        # Update size
+        self.size = self.size + other.size
+
+        # Update min.node
+        if self.min_node.val > other.min_node.val:
+            self.min_node = other.min_node
+        # Merge
+
+        # Order roots by left_subtree_size
+        combined_roots_list = []
+        i, j = self.bottom_root, other.bottom_root
+        while i or j:
+            if i and (
+                (not j)
+                or i.left_tree_size < j.left_tree_size
+            ):
+                combined_roots_list.append((i, True))
+                i = i.parent
+            else:
+                combined_roots_list.append((j, False))
+                j = j.parent
+        # Insert links between them
+        for i in range(len(combined_roots_list) - 1):
+            if (
+                combined_roots_list[i][1]
+                != combined_roots_list[i + 1][1]
+            ):
+                combined_roots_list[i][
+                    0
+                ].parent = combined_roots_list[i + 1][0]
+                combined_roots_list[i + 1][
+                    0
+                ].left = combined_roots_list[i][0]
+        # Consecutively merge roots with same left_tree_size
+        i = combined_roots_list[0][0]
+        while i.parent:
+            if (
+                (
+                    i.left_tree_size
+                    == i.parent.left_tree_size
+                )
+                and (not i.parent.parent)
+            ) or (
+                i.left_tree_size == i.parent.left_tree_size
+                and i.left_tree_size
+                != i.parent.parent.left_tree_size
+            ):
+
+                # Neighbouring Nodes
+                previous_node = i.left
+                next_node = i.parent.parent
+
+                # Merging trees
+                i = i.mergeTrees(i.parent)
+
+                # Updating links
+                i.left = previous_node
+                i.parent = next_node
+                if previous_node:
+                    previous_node.parent = i
+                if next_node:
+                    next_node.left = i
+            else:
+                i = i.parent
+        # Updating self.bottom_root
+        while i.left:
+            i = i.left
+        self.bottom_root = i
+
+        # Update other
+        other.size = self.size
+        other.bottom_root = self.bottom_root
+        other.min_node = self.min_node
+
+        # Return the merged heap
+        return self
+
+    def insert(self, val):
+        """
+            insert a value in the heap
+        """
+        if self.size == 0:
+            self.bottom_root = Node(val)
+            self.size = 1
+            self.min_node = self.bottom_root
+        else:
+            # Create new node
+            new_node = Node(val)
+
+            # Update size
+            self.size += 1
+
+            # update min_node
+            if val < self.min_node.val:
+                self.min_node = new_node
+            # Put new_node as a bottom_root in heap
+            self.bottom_root.left = new_node
+            new_node.parent = self.bottom_root
+            self.bottom_root = new_node
+
+            # Consecutively merge roots with same left_tree_size
+            while (
+                self.bottom_root.parent
+                and self.bottom_root.left_tree_size
+                == self.bottom_root.parent.left_tree_size
+            ):
+
+                # Next node
+                next_node = self.bottom_root.parent.parent
+
+                # Merge
+                self.bottom_root = self.bottom_root.mergeTrees(
+                    self.bottom_root.parent
+                )
+
+                # Update Links
+                self.bottom_root.parent = next_node
+                self.bottom_root.left = None
+                if next_node:
+                    next_node.left = self.bottom_root
+
+    def peek(self):
+        """
+            return min element without deleting it
+        """
+        return self.min_node.val
+
+    def isEmpty(self):
+        return self.size == 0
+
+    def deleteMin(self):
+        """
+            delete min element and return it
+        """
+        # assert not self.isEmpty(), "Empty Heap"
+
+        # Save minimal value
+        min_value = self.min_node.val
+
+        # Last element in heap corner case
+        if self.size == 1:
+            # Update size
+            self.size = 0
+
+            # Update bottom root
+            self.bottom_root = None
+
+            # Update min_node
+            self.min_node = None
+
+            return min_value
+        # No right subtree corner case
+        # The structure of the tree implies that this should be the bottom root
+        # and there is at least one other root
+        if self.min_node.right == None:
+            # Update size
+            self.size -= 1
+
+            # Update bottom root
+            self.bottom_root = self.bottom_root.parent
+            self.bottom_root.left = None
+
+            # Update min_node
+            self.min_node = self.bottom_root
+            i = self.bottom_root.parent
+            while i:
+                if i.val < self.min_node.val:
+                    self.min_node = i
+                i = i.parent
+            return min_value
+        # General case
+        # Find the BinomialHeap of the right subtree of min_node
+        bottom_of_new = self.min_node.right
+        bottom_of_new.parent = None
+        min_of_new = bottom_of_new
+        size_of_new = 1
+
+        # Size, min_node and bottom_root
+        while bottom_of_new.left:
+            size_of_new = size_of_new * 2 + 1
+            bottom_of_new = bottom_of_new.left
+            if bottom_of_new.val < min_of_new.val:
+                min_of_new = bottom_of_new
+        # Corner case of single root on top left path
+        if (not self.min_node.left) and (
+            not self.min_node.parent
+        ):
+            self.size = size_of_new
+            self.bottom_root = bottom_of_new
+            self.min_node = min_of_new
+            # print("Single root, multiple nodes case")
+            return min_value
+        # Remaining cases
+        # Construct heap of right subtree
+        newHeap = BinomialHeap(
+            bottom_root=bottom_of_new,
+            min_node=min_of_new,
+            heap_size=size_of_new,
+        )
+
+        # Update size
+        self.size = self.size - 1 - size_of_new
+
+        # Neighbour nodes
+        previous_node = self.min_node.left
+        next_node = self.min_node.parent
+
+        # Initialize new bottom_root and min_node
+        self.min_node = previous_node or next_node
+        self.bottom_root = next_node
+
+        # Update links of previous_node and search below for new min_node and
+        # bottom_root
+        if previous_node:
+            previous_node.parent = next_node
+
+            # Update bottom_root and search for min_node below
+            self.bottom_root = previous_node
+            self.min_node = previous_node
+            while self.bottom_root.left:
+                self.bottom_root = self.bottom_root.left
+                if self.bottom_root.val < self.min_node.val:
+                    self.min_node = self.bottom_root
+        if next_node:
+            next_node.left = previous_node
+
+            # Search for new min_node above min_node
+            i = next_node
+            while i:
+                if i.val < self.min_node.val:
+                    self.min_node = i
+                i = i.parent
+        # Merge heaps
+        self.mergeHeaps(newHeap)
+
+        return min_value
+
+    def preOrder(self):
+        """
+            Returns the Pre-order representation of the heap including 
+            values of nodes plus their level distance from the root;
+            Empty nodes appear as #
+        """
+        # Find top root
+        top_root = self.bottom_root
+        while top_root.parent:
+            top_root = top_root.parent
+        # preorder
+        heap_preOrder = []
+        self.__traversal(top_root, heap_preOrder)
+        return heap_preOrder
+
+    def __traversal(self, curr_node, preorder, level=0):
+        """
+            Pre-order traversal of nodes 
+        """
+        if curr_node:
+            preorder.append((curr_node.val, level))
+            self.__traversal(
+                curr_node.left, preorder, level + 1
+            )
+            self.__traversal(
+                curr_node.right, preorder, level + 1
+            )
+        else:
+            preorder.append(("#", level))
+
+    def __str__(self):
+        """
+            Overwriting str for a pre-order print of nodes in heap; 
+            Performance is poor, so use only for small examples
+        """
+        if self.isEmpty():
+            return ""
+        preorder_heap = self.preOrder()
+
+        return "\n".join(
+            ("-" * level + str(value))
+            for value, level in preorder_heap
+        )
+
+
+# Unit Tests
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()

From 2dfe01e4d8e4e84fbe3b04da08e5dfd18e17410a Mon Sep 17 00:00:00 2001
From: Maxwell Aladago <maxwell.aladago@gmail.com>
Date: Thu, 5 Sep 2019 02:22:06 -0400
Subject: [PATCH 204/348] Fully refactored the rod cutting module.  (#1169)

* changing typo

* fully refactored the rod-cutting module

* more documentations

* rewording
---
 dynamic_programming/rod_cutting.py | 230 +++++++++++++++++++++++------
 1 file changed, 183 insertions(+), 47 deletions(-)

diff --git a/dynamic_programming/rod_cutting.py b/dynamic_programming/rod_cutting.py
index c3111dcfc8a1..5b52eaca7c89 100644
--- a/dynamic_programming/rod_cutting.py
+++ b/dynamic_programming/rod_cutting.py
@@ -1,57 +1,193 @@
-from typing import List
+"""
+This module provides two implementations for the rod-cutting problem:
+1. A naive recursive implementation which has an exponential runtime
+2. Two dynamic programming implementations which have quadratic runtime
 
-def rod_cutting(prices: List[int],length: int) -> int:
+The rod-cutting problem is the problem of finding the maximum possible revenue
+obtainable from a rod of length ``n`` given a list of prices for each integral piece
+of the rod. The maximum revenue can thus be obtained by cutting the rod and selling the
+pieces separately or not cutting it at all if the price of it is the maximum obtainable.
+
+"""
+
+
+def naive_cut_rod_recursive(n: int, prices: list):
+	"""
+	Solves the rod-cutting problem via naively without using the benefit of dynamic programming.
+	The results is the same sub-problems are solved several times leading to an exponential runtime
+
+	Runtime: O(2^n)
+
+	Arguments
+	-------
+	n: int, the length of the rod
+	prices: list, the prices for each piece of rod. ``p[i-i]`` is the
+	price for a rod of length ``i``
+
+	Returns
+	-------
+	The maximum revenue obtainable for a rod of length n given the list of prices for each piece.
+
+	Examples
+	--------
+	>>> naive_cut_rod_recursive(4, [1, 5, 8, 9])
+	10
+	>>> naive_cut_rod_recursive(10, [1, 5, 8, 9, 10, 17, 17, 20, 24, 30])
+	30
+	"""
+
+	_enforce_args(n, prices)
+	if n == 0:
+		return 0
+	max_revue = float("-inf")
+	for i in range(1, n + 1):
+		max_revue = max(max_revue, prices[i - 1] + naive_cut_rod_recursive(n - i, prices))
+
+	return max_revue
+
+
+def top_down_cut_rod(n: int, prices: list):
 	"""
-	Given a rod of length n and array of prices that indicate price at each length.
-	Determine the maximum value obtainable by cutting up the rod and selling the pieces
-	
-	>>> rod_cutting([1,5,8,9],4) 
+	Constructs a top-down dynamic programming solution for the rod-cutting problem
+	via memoization. This function serves as a wrapper for _top_down_cut_rod_recursive
+
+	Runtime: O(n^2)
+
+	Arguments
+	--------
+	n: int, the length of the rod
+	prices: list, the prices for each piece of rod. ``p[i-i]`` is the
+	price for a rod of length ``i``
+
+	Note
+	----
+	For convenience and because Python's lists using 0-indexing, length(max_rev) = n + 1,
+	to accommodate for the revenue obtainable from a rod of length 0.
+
+	Returns
+	-------
+	The maximum revenue obtainable for a rod of length n given the list of prices for each piece.
+
+	Examples
+	-------
+	>>> top_down_cut_rod(4, [1, 5, 8, 9])
 	10
-	>>> rod_cutting([1,1,1],3) 
-	3
-	>>> rod_cutting([1,2,3], -1)
-	Traceback (most recent call last):
-   	ValueError: Given integer must be greater than 1, not -1
-   	>>> rod_cutting([1,2,3], 3.2)
-	Traceback (most recent call last):
-   	TypeError: Must be int, not float
-   	>>> rod_cutting([], 3)
-	Traceback (most recent call last):
-   	AssertionError: prices list is shorted than length: 3
-	
-	
-
-	Args:
-		prices: list indicating price at each length, where prices[0] = 0 indicating rod of zero length has no value
-	    length: length of rod
-
-	Returns:
-	    Maximum revenue attainable by cutting up the rod in any way. 
-	"""
-
-	prices.insert(0, 0)
-	if not isinstance(length, int):
-	    raise TypeError('Must be int, not {0}'.format(type(length).__name__))
-	if length < 0: 
-	    raise ValueError('Given integer must be greater than 1, not {0}'.format(length))
-	assert len(prices) - 1 >= length, "prices list is shorted than length: {0}".format(length) 
-
-	return rod_cutting_recursive(prices, length)
-
-def rod_cutting_recursive(prices: List[int],length: int) -> int:
-	#base case 
-	if length == 0:
+	>>> top_down_cut_rod(10, [1, 5, 8, 9, 10, 17, 17, 20, 24, 30])
+	30
+	"""
+	_enforce_args(n, prices)
+	max_rev = [float("-inf") for _ in range(n + 1)]
+	return _top_down_cut_rod_recursive(n, prices, max_rev)
+
+
+def _top_down_cut_rod_recursive(n: int, prices: list, max_rev: list):
+	"""
+	Constructs a top-down dynamic programming solution for the rod-cutting problem
+	via memoization.
+
+	Runtime: O(n^2)
+
+	Arguments
+	--------
+	n: int, the length of the rod
+	prices: list, the prices for each piece of rod. ``p[i-i]`` is the
+	price for a rod of length ``i``
+	max_rev: list, the computed maximum revenue for a piece of rod.
+	``max_rev[i]`` is the maximum revenue obtainable for a rod of length ``i``
+
+	Returns
+	-------
+	The maximum revenue obtainable for a rod of length n given the list of prices for each piece.
+	"""
+	if max_rev[n] >= 0:
+		return max_rev[n]
+	elif n == 0:
 		return 0
-	value = float('-inf')
-	for firstCutLocation in range(1,length+1):
-		value = max(value, prices[firstCutLocation]+rod_cutting_recursive(prices,length - firstCutLocation))
-	return value
+	else:
+		max_revenue = float("-inf")
+		for i in range(1, n + 1):
+			max_revenue = max(max_revenue, prices[i - 1] + _top_down_cut_rod_recursive(n - i, prices, max_rev))
+
+		max_rev[n] = max_revenue
+
+	return max_rev[n]
+
+
+def bottom_up_cut_rod(n: int, prices: list):
+	"""
+	Constructs a bottom-up dynamic programming solution for the rod-cutting problem
+
+	Runtime: O(n^2)
+
+	Arguments
+	----------
+	n: int, the maximum length of the rod.
+	prices: list, the prices for each piece of rod. ``p[i-i]`` is the
+	price for a rod of length ``i``
+
+	Returns
+	-------
+	The maximum revenue obtainable from cutting a rod of length n given
+	the prices for each piece of rod p.
+
+	Examples
+	-------
+	>>> bottom_up_cut_rod(4, [1, 5, 8, 9])
+	10
+	>>> bottom_up_cut_rod(10, [1, 5, 8, 9, 10, 17, 17, 20, 24, 30])
+	30
+	"""
+	_enforce_args(n, prices)
+
+	# length(max_rev) = n + 1, to accommodate for the revenue obtainable from a rod of length 0.
+	max_rev = [float("-inf") for _ in range(n + 1)]
+	max_rev[0] = 0
+
+	for i in range(1, n + 1):
+		max_revenue_i = max_rev[i]
+		for j in range(1, i + 1):
+			max_revenue_i = max(max_revenue_i, prices[j - 1] + max_rev[i - j])
+
+		max_rev[i] = max_revenue_i
+
+	return max_rev[n]
+
+
+def _enforce_args(n: int, prices: list):
+	"""
+	Basic checks on the arguments to the rod-cutting algorithms
+
+	n: int, the length of the rod
+	prices: list, the price list for each piece of rod.
+
+	Throws ValueError:
+
+	if n is negative or there are fewer items in the price list than the length of the rod
+	"""
+	if n < 0:
+		raise ValueError(f"n must be greater than or equal to 0. Got n = {n}")
+
+	if n > len(prices):
+		raise ValueError(f"Each integral piece of rod must have a corresponding "
+						 f"price. Got n = {n} but length of prices = {len(prices)}")
 
 
 def main():
-	assert rod_cutting([1,5,8,9,10,17,17,20,24,30],10) == 30
-	# print(rod_cutting([],0))
+	prices = [6, 10, 12, 15, 20, 23]
+	n = len(prices)
+
+	# the best revenue comes from cutting the rod into 6 pieces, each
+	# of length 1 resulting in a revenue of 6 * 6 = 36.
+	expected_max_revenue = 36
+
+	max_rev_top_down = top_down_cut_rod(n, prices)
+	max_rev_bottom_up = bottom_up_cut_rod(n, prices)
+	max_rev_naive = naive_cut_rod_recursive(n, prices)
+
+	assert expected_max_revenue == max_rev_top_down
+	assert max_rev_top_down == max_rev_bottom_up
+	assert max_rev_bottom_up == max_rev_naive
+
 
 if __name__ == '__main__':
 	main()
-

From ab25079e168aa6de61bfd082af5a056b8ee50b43 Mon Sep 17 00:00:00 2001
From: Jai Kumar Dewani <jai.dewani.99@gmail.com>
Date: Fri, 6 Sep 2019 14:32:37 +0530
Subject: [PATCH 205/348] Update DIRECTORY (#1161)

* Update DIRECTORY

* Updated DIRECTORY

* Fixed bug in directory build and re-build the directory.md

* fixed url issue

* fixed indentation in Directory.md
---
 DIRECTORY.md                  | 622 +++++++---------------------------
 scripts/build_directory_md.py |   6 +-
 2 files changed, 117 insertions(+), 511 deletions(-)

diff --git a/DIRECTORY.md b/DIRECTORY.md
index 80bf64ef4c30..248fe7b9eaa6 100644
--- a/DIRECTORY.md
+++ b/DIRECTORY.md
@@ -1,805 +1,411 @@
 ## Arithmetic Analysis
-
   * [bisection](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/bisection.py)
-
   * [in static equilibrium](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/in_static_equilibrium.py)
-
   * [intersection](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/intersection.py)
-
   * [lu decomposition](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/lu_decomposition.py)
-
   * [newton method](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/newton_method.py)
-
   * [newton raphson method](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/newton_raphson_method.py)
-
 ## Backtracking
-
   * [all combinations](https://github.com/TheAlgorithms/Python/blob/master/backtracking/all_combinations.py)
-
   * [all permutations](https://github.com/TheAlgorithms/Python/blob/master/backtracking/all_permutations.py)
-
   * [all subsequences](https://github.com/TheAlgorithms/Python/blob/master/backtracking/all_subsequences.py)
-
   * [minimax](https://github.com/TheAlgorithms/Python/blob/master/backtracking/minimax.py)
-
   * [n queens](https://github.com/TheAlgorithms/Python/blob/master/backtracking/n_queens.py)
-
   * [sudoku](https://github.com/TheAlgorithms/Python/blob/master/backtracking/sudoku.py)
-
   * [sum of subsets](https://github.com/TheAlgorithms/Python/blob/master/backtracking/sum_of_subsets.py)
-
 ## Boolean Algebra
-
   * [quine mc cluskey](https://github.com/TheAlgorithms/Python/blob/master/boolean_algebra/quine_mc_cluskey.py)
-
 ## Ciphers
-
   * [affine cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/affine_cipher.py)
-
   * [atbash](https://github.com/TheAlgorithms/Python/blob/master/ciphers/atbash.py)
-
   * [base16](https://github.com/TheAlgorithms/Python/blob/master/ciphers/base16.py)
-
   * [base32](https://github.com/TheAlgorithms/Python/blob/master/ciphers/base32.py)
-
   * [base64 cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/base64_cipher.py)
-
   * [base85](https://github.com/TheAlgorithms/Python/blob/master/ciphers/base85.py)
-
   * [brute force caesar cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/brute_force_caesar_cipher.py)
-
   * [caesar cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/caesar_cipher.py)
-
   * [cryptomath module](https://github.com/TheAlgorithms/Python/blob/master/ciphers/cryptomath_module.py)
-
   * [elgamal key generator](https://github.com/TheAlgorithms/Python/blob/master/ciphers/elgamal_key_generator.py)
-
   * [hill cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/hill_cipher.py)
-
   * [morse code implementation](https://github.com/TheAlgorithms/Python/blob/master/ciphers/morse_code_implementation.py)
-
   * [onepad cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/onepad_cipher.py)
-
   * [playfair cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/playfair_cipher.py)
-
   * [rabin miller](https://github.com/TheAlgorithms/Python/blob/master/ciphers/rabin_miller.py)
-
   * [rot13](https://github.com/TheAlgorithms/Python/blob/master/ciphers/rot13.py)
-
   * [rsa cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/rsa_cipher.py)
-
   * [rsa key generator](https://github.com/TheAlgorithms/Python/blob/master/ciphers/rsa_key_generator.py)
-
   * [simple substitution cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/simple_substitution_cipher.py)
-
   * [trafid cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/trafid_cipher.py)
-
   * [transposition cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/transposition_cipher.py)
-
   * [transposition cipher encrypt decrypt file](https://github.com/TheAlgorithms/Python/blob/master/ciphers/transposition_cipher_encrypt_decrypt_file.py)
-
   * [vigenere cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/vigenere_cipher.py)
-
   * [xor cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/xor_cipher.py)
-
 ## Compression
-
   * [burrows wheeler](https://github.com/TheAlgorithms/Python/blob/master/compression/burrows_wheeler.py)
-
   * [huffman](https://github.com/TheAlgorithms/Python/blob/master/compression/huffman.py)
-
   * [peak signal to noise ratio](https://github.com/TheAlgorithms/Python/blob/master/compression/peak_signal_to_noise_ratio.py)
-
 ## Conversions
-
   * [decimal to binary](https://github.com/TheAlgorithms/Python/blob/master/conversions/decimal_to_binary.py)
-
   * [decimal to hexadecimal](https://github.com/TheAlgorithms/Python/blob/master/conversions/decimal_to_hexadecimal.py)
-
   * [decimal to octal](https://github.com/TheAlgorithms/Python/blob/master/conversions/decimal_to_octal.py)
-
 ## Data Structures
-
   * Binary Tree
-
-    * [avl tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/avl_tree.py)
-
-    * [basic binary tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/basic_binary_tree.py)
-
-    * [binary search tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/binary_search_tree.py)
-
-    * [fenwick tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/fenwick_tree.py)
-
-    * [lazy segment tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/lazy_segment_tree.py)
-
-    * [lca](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/lca.py)
-
-    * [red black tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/red_black_tree.py)
-
-    * [segment tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/segment_tree.py)
-
-    * [treap](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/treap.py)
-
+    * [avl tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/avl_tree.py)
+    * [basic binary tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/basic_binary_tree.py)
+    * [binary search tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_search_tree.py)
+    * [fenwick tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/fenwick_tree.py)
+    * [lazy segment tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/lazy_segment_tree.py)
+    * [lca](https://github.com/TheAlgorithms/Python/blob/master/data_structures/lca.py)
+    * [red black tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/red_black_tree.py)
+    * [segment tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/segment_tree.py)
+    * [treap](https://github.com/TheAlgorithms/Python/blob/master/data_structures/treap.py)
   * Hashing
-
-    * [double hash](https://github.com/TheAlgorithms/Python/blob/master/data_structures/hashing/double_hash.py)
-
-    * [hash table](https://github.com/TheAlgorithms/Python/blob/master/data_structures/hashing/hash_table.py)
-
-    * [hash table with linked list](https://github.com/TheAlgorithms/Python/blob/master/data_structures/hashing/hash_table_with_linked_list.py)
-
-    * Number Theory
-
-      * [prime numbers](https://github.com/TheAlgorithms/Python/blob/master/data_structures/hashing/number_theory/prime_numbers.py)
-
-    * [quadratic probing](https://github.com/TheAlgorithms/Python/blob/master/data_structures/hashing/quadratic_probing.py)
-
+    * [double hash](https://github.com/TheAlgorithms/Python/blob/master/data_structures/double_hash.py)
+    * [hash table](https://github.com/TheAlgorithms/Python/blob/master/data_structures/hash_table.py)
+    * [hash table with linked list](https://github.com/TheAlgorithms/Python/blob/master/data_structures/hash_table_with_linked_list.py)
+  * Number Theory
+    * [prime numbers](https://github.com/TheAlgorithms/Python/blob/master/data_structures/prime_numbers.py)
+    * [quadratic probing](https://github.com/TheAlgorithms/Python/blob/master/data_structures/quadratic_probing.py)
   * Heap
-
-    * [heap](https://github.com/TheAlgorithms/Python/blob/master/data_structures/heap/heap.py)
-
+    * [heap](https://github.com/TheAlgorithms/Python/blob/master/data_structures/heap.py)
   * Linked List
-
-    * [doubly linked list](https://github.com/TheAlgorithms/Python/blob/master/data_structures/linked_list/doubly_linked_list.py)
-
-    * [is palindrome](https://github.com/TheAlgorithms/Python/blob/master/data_structures/linked_list/is_palindrome.py)
-
-    * [singly linked list](https://github.com/TheAlgorithms/Python/blob/master/data_structures/linked_list/singly_linked_list.py)
-
-    * [swap nodes](https://github.com/TheAlgorithms/Python/blob/master/data_structures/linked_list/swap_nodes.py)
-
+    * [doubly linked list](https://github.com/TheAlgorithms/Python/blob/master/data_structures/doubly_linked_list.py)
+    * [is palindrome](https://github.com/TheAlgorithms/Python/blob/master/data_structures/is_palindrome.py)
+    * [singly linked list](https://github.com/TheAlgorithms/Python/blob/master/data_structures/singly_linked_list.py)
+    * [swap nodes](https://github.com/TheAlgorithms/Python/blob/master/data_structures/swap_nodes.py)
   * Queue
-
-    * [double ended queue](https://github.com/TheAlgorithms/Python/blob/master/data_structures/queue/double_ended_queue.py)
-
-    * [queue on list](https://github.com/TheAlgorithms/Python/blob/master/data_structures/queue/queue_on_list.py)
-
-    * [queue on pseudo stack](https://github.com/TheAlgorithms/Python/blob/master/data_structures/queue/queue_on_pseudo_stack.py)
-
+    * [double ended queue](https://github.com/TheAlgorithms/Python/blob/master/data_structures/double_ended_queue.py)
+    * [queue on list](https://github.com/TheAlgorithms/Python/blob/master/data_structures/queue_on_list.py)
+    * [queue on pseudo stack](https://github.com/TheAlgorithms/Python/blob/master/data_structures/queue_on_pseudo_stack.py)
   * Stacks
-
-    * [balanced parentheses](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stacks/balanced_parentheses.py)
-
-    * [infix to postfix conversion](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stacks/infix_to_postfix_conversion.py)
-
-    * [infix to prefix conversion](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stacks/infix_to_prefix_conversion.py)
-
-    * [next greater element](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stacks/next_greater_element.py)
-
-    * [postfix evaluation](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stacks/postfix_evaluation.py)
-
-    * [stack](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stacks/stack.py)
-
-    * [stock span problem](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stacks/stock_span_problem.py)
-
+    * [balanced parentheses](https://github.com/TheAlgorithms/Python/blob/master/data_structures/balanced_parentheses.py)
+    * [infix to postfix conversion](https://github.com/TheAlgorithms/Python/blob/master/data_structures/infix_to_postfix_conversion.py)
+    * [infix to prefix conversion](https://github.com/TheAlgorithms/Python/blob/master/data_structures/infix_to_prefix_conversion.py)
+    * [next greater element](https://github.com/TheAlgorithms/Python/blob/master/data_structures/next_greater_element.py)
+    * [postfix evaluation](https://github.com/TheAlgorithms/Python/blob/master/data_structures/postfix_evaluation.py)
+    * [stack](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stack.py)
+    * [stock span problem](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stock_span_problem.py)
   * Trie
-
-    * [trie](https://github.com/TheAlgorithms/Python/blob/master/data_structures/trie/trie.py)
-
+    * [trie](https://github.com/TheAlgorithms/Python/blob/master/data_structures/trie.py)
 ## Digital Image Processing
-
-  * [change contrast](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/change_contrast.py)
-
+    * [change contrast](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/change_contrast.py)
   * Edge Detection
-
-    * [canny](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/edge_detection/canny.py)
-
+    * [canny](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/canny.py)
   * Filters
-
-    * [convolve](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/filters/convolve.py)
-
-    * [gaussian filter](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/filters/gaussian_filter.py)
-
-    * [median filter](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/filters/median_filter.py)
-
-    * [sobel filter](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/filters/sobel_filter.py)
-
-  * [test digital image processing](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/test_digital_image_processing.py)
-
+    * [convolve](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/convolve.py)
+    * [gaussian filter](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/gaussian_filter.py)
+    * [median filter](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/median_filter.py)
+    * [sobel filter](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/sobel_filter.py)
+    * [test digital image processing](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/test_digital_image_processing.py)
 ## Divide And Conquer
-
   * [closest pair of points](https://github.com/TheAlgorithms/Python/blob/master/divide_and_conquer/closest_pair_of_points.py)
-
+  * [convex hull](https://github.com/TheAlgorithms/Python/blob/master/divide_and_conquer/convex_hull.py)
+  * [inversions](https://github.com/TheAlgorithms/Python/blob/master/divide_and_conquer/inversions.py)
   * [max subarray sum](https://github.com/TheAlgorithms/Python/blob/master/divide_and_conquer/max_subarray_sum.py)
-
 ## Dynamic Programming
-
   * [abbreviation](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/abbreviation.py)
-
   * [bitmask](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/bitmask.py)
-
   * [climbing stairs](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/climbing_stairs.py)
-
   * [coin change](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/coin_change.py)
-
   * [edit distance](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/edit_distance.py)
-
   * [factorial](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/factorial.py)
-
   * [fast fibonacci](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/fast_fibonacci.py)
-
   * [fibonacci](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/fibonacci.py)
-
   * [floyd warshall](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/floyd_warshall.py)
-
   * [fractional knapsack](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/fractional_knapsack.py)
-
   * [integer partition](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/integer_partition.py)
-
   * [k means clustering tensorflow](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/k_means_clustering_tensorflow.py)
-
   * [knapsack](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/knapsack.py)
-
   * [longest common subsequence](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/longest_common_subsequence.py)
-
   * [longest increasing subsequence](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/longest_increasing_subsequence.py)
-
   * [longest increasing subsequence o(nlogn)](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/longest_increasing_subsequence_o(nlogn).py)
-
   * [longest sub array](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/longest_sub_array.py)
-
   * [matrix chain order](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/matrix_chain_order.py)
-
   * [max sub array](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/max_sub_array.py)
-
   * [minimum partition](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/minimum_partition.py)
-
   * [rod cutting](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/rod_cutting.py)
-
   * [subset generation](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/subset_generation.py)
-
   * [sum of subset](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/sum_of_subset.py)
-
 ## File Transfer
-
   * [recieve file](https://github.com/TheAlgorithms/Python/blob/master/file_transfer/recieve_file.py)
-
   * [send file](https://github.com/TheAlgorithms/Python/blob/master/file_transfer/send_file.py)
-
 ## Graphs
-
   * [a star](https://github.com/TheAlgorithms/Python/blob/master/graphs/a_star.py)
-
   * [articulation points](https://github.com/TheAlgorithms/Python/blob/master/graphs/articulation_points.py)
-
   * [basic graphs](https://github.com/TheAlgorithms/Python/blob/master/graphs/basic_graphs.py)
-
   * [bellman ford](https://github.com/TheAlgorithms/Python/blob/master/graphs/bellman_ford.py)
-
   * [bfs](https://github.com/TheAlgorithms/Python/blob/master/graphs/bfs.py)
-
   * [bfs shortest path](https://github.com/TheAlgorithms/Python/blob/master/graphs/bfs_shortest_path.py)
-
   * [breadth first search](https://github.com/TheAlgorithms/Python/blob/master/graphs/breadth_first_search.py)
-
   * [check bipartite graph bfs](https://github.com/TheAlgorithms/Python/blob/master/graphs/check_bipartite_graph_bfs.py)
-
   * [check bipartite graph dfs](https://github.com/TheAlgorithms/Python/blob/master/graphs/check_bipartite_graph_dfs.py)
-
   * [depth first search](https://github.com/TheAlgorithms/Python/blob/master/graphs/depth_first_search.py)
-
   * [dfs](https://github.com/TheAlgorithms/Python/blob/master/graphs/dfs.py)
-
   * [dijkstra](https://github.com/TheAlgorithms/Python/blob/master/graphs/dijkstra.py)
-
   * [dijkstra 2](https://github.com/TheAlgorithms/Python/blob/master/graphs/dijkstra_2.py)
-
   * [dijkstra algorithm](https://github.com/TheAlgorithms/Python/blob/master/graphs/dijkstra_algorithm.py)
-
   * [directed and undirected (weighted) graph](https://github.com/TheAlgorithms/Python/blob/master/graphs/directed_and_undirected_(weighted)_graph.py)
-
   * [edmonds karp multiple source and sink](https://github.com/TheAlgorithms/Python/blob/master/graphs/edmonds_karp_multiple_source_and_sink.py)
-
   * [eulerian path and circuit for undirected graph](https://github.com/TheAlgorithms/Python/blob/master/graphs/eulerian_path_and_circuit_for_undirected_graph.py)
-
   * [even tree](https://github.com/TheAlgorithms/Python/blob/master/graphs/even_tree.py)
-
   * [finding bridges](https://github.com/TheAlgorithms/Python/blob/master/graphs/finding_bridges.py)
-
   * [graph list](https://github.com/TheAlgorithms/Python/blob/master/graphs/graph_list.py)
-
   * [graph matrix](https://github.com/TheAlgorithms/Python/blob/master/graphs/graph_matrix.py)
-
   * [graphs floyd warshall](https://github.com/TheAlgorithms/Python/blob/master/graphs/graphs_floyd_warshall.py)
-
   * [kahns algorithm long](https://github.com/TheAlgorithms/Python/blob/master/graphs/kahns_algorithm_long.py)
-
   * [kahns algorithm topo](https://github.com/TheAlgorithms/Python/blob/master/graphs/kahns_algorithm_topo.py)
-
   * [minimum spanning tree kruskal](https://github.com/TheAlgorithms/Python/blob/master/graphs/minimum_spanning_tree_kruskal.py)
-
   * [minimum spanning tree prims](https://github.com/TheAlgorithms/Python/blob/master/graphs/minimum_spanning_tree_prims.py)
-
   * [multi hueristic astar](https://github.com/TheAlgorithms/Python/blob/master/graphs/multi_hueristic_astar.py)
-
   * [page rank](https://github.com/TheAlgorithms/Python/blob/master/graphs/page_rank.py)
-
   * [prim](https://github.com/TheAlgorithms/Python/blob/master/graphs/prim.py)
-
   * [scc kosaraju](https://github.com/TheAlgorithms/Python/blob/master/graphs/scc_kosaraju.py)
-
   * [tarjans scc](https://github.com/TheAlgorithms/Python/blob/master/graphs/tarjans_scc.py)
-
 ## Hashes
-
   * [chaos machine](https://github.com/TheAlgorithms/Python/blob/master/hashes/chaos_machine.py)
-
   * [enigma machine](https://github.com/TheAlgorithms/Python/blob/master/hashes/enigma_machine.py)
-
   * [md5](https://github.com/TheAlgorithms/Python/blob/master/hashes/md5.py)
-
   * [sha1](https://github.com/TheAlgorithms/Python/blob/master/hashes/sha1.py)
-
 ## Linear Algebra
-
   * Src
-
-    * [lib](https://github.com/TheAlgorithms/Python/blob/master/linear_algebra/src/lib.py)
-
-    * [python-polynom-for-points](https://github.com/TheAlgorithms/Python/blob/master/linear_algebra/src/python-polynom-for-points.py)
-
-    * [tests](https://github.com/TheAlgorithms/Python/blob/master/linear_algebra/src/tests.py)
-
+    * [lib](https://github.com/TheAlgorithms/Python/blob/master/linear_algebra/lib.py)
+    * [polynom-for-points](https://github.com/TheAlgorithms/Python/blob/master/linear_algebra/polynom-for-points.py)
+    * [tests](https://github.com/TheAlgorithms/Python/blob/master/linear_algebra/tests.py)
 ## Machine Learning
-
   * [decision tree](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/decision_tree.py)
-
   * [gradient descent](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/gradient_descent.py)
-
   * [k means clust](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/k_means_clust.py)
-
   * [knn sklearn](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/knn_sklearn.py)
-
   * [linear regression](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/linear_regression.py)
-
   * [logistic regression](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/logistic_regression.py)
-
   * [naive bayes](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/naive_bayes.ipynb)
-
   * Random Forest Classification
-
-    * [random forest classification](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/random_forest_classification/random_forest_classification.py)
-
-    * [random forest classifier](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/random_forest_classification/random_forest_classifier.ipynb)
-
+    * [random forest classification](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/random_forest_classification.py)
+    * [random forest classifier](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/random_forest_classifier.ipynb)
   * Random Forest Regression
-
-    * [random forest regression](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/random_forest_regression/random_forest_regression.ipynb)
-
-    * [random forest regression](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/random_forest_regression/random_forest_regression.py)
-
+    * [random forest regression](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/random_forest_regression.ipynb)
+    * [random forest regression](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/random_forest_regression.py)
   * [reuters one vs rest classifier](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/reuters_one_vs_rest_classifier.ipynb)
-
   * [scoring functions](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/scoring_functions.py)
-
+  * [sorted vector machines](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/sorted_vector_machines.py)
 ## Maths
-
   * [3n+1](https://github.com/TheAlgorithms/Python/blob/master/maths/3n+1.py)
-
   * [abs](https://github.com/TheAlgorithms/Python/blob/master/maths/abs.py)
-
   * [abs max](https://github.com/TheAlgorithms/Python/blob/master/maths/abs_max.py)
-
   * [abs min](https://github.com/TheAlgorithms/Python/blob/master/maths/abs_min.py)
-
   * [average mean](https://github.com/TheAlgorithms/Python/blob/master/maths/average_mean.py)
-
   * [average median](https://github.com/TheAlgorithms/Python/blob/master/maths/average_median.py)
-
   * [basic maths](https://github.com/TheAlgorithms/Python/blob/master/maths/basic_maths.py)
-
   * [binary exponentiation](https://github.com/TheAlgorithms/Python/blob/master/maths/binary_exponentiation.py)
-
   * [collatz sequence](https://github.com/TheAlgorithms/Python/blob/master/maths/collatz_sequence.py)
-
   * [extended euclidean algorithm](https://github.com/TheAlgorithms/Python/blob/master/maths/extended_euclidean_algorithm.py)
-
   * [factorial python](https://github.com/TheAlgorithms/Python/blob/master/maths/factorial_python.py)
-
   * [factorial recursive](https://github.com/TheAlgorithms/Python/blob/master/maths/factorial_recursive.py)
-
   * [fermat little theorem](https://github.com/TheAlgorithms/Python/blob/master/maths/fermat_little_theorem.py)
-
   * [fibonacci](https://github.com/TheAlgorithms/Python/blob/master/maths/fibonacci.py)
-
   * [fibonacci sequence recursion](https://github.com/TheAlgorithms/Python/blob/master/maths/fibonacci_sequence_recursion.py)
-
   * [find lcm](https://github.com/TheAlgorithms/Python/blob/master/maths/find_lcm.py)
-
   * [find max](https://github.com/TheAlgorithms/Python/blob/master/maths/find_max.py)
-
   * [find min](https://github.com/TheAlgorithms/Python/blob/master/maths/find_min.py)
-
   * [gaussian](https://github.com/TheAlgorithms/Python/blob/master/maths/gaussian.py)
-
   * [greater common divisor](https://github.com/TheAlgorithms/Python/blob/master/maths/greater_common_divisor.py)
-
   * [is square free](https://github.com/TheAlgorithms/Python/blob/master/maths/is_square_free.py)
-
   * [largest of very large numbers](https://github.com/TheAlgorithms/Python/blob/master/maths/largest_of_very_large_numbers.py)
-
   * [lucas lehmer primality test](https://github.com/TheAlgorithms/Python/blob/master/maths/lucas_lehmer_primality_test.py)
-
   * [lucas series](https://github.com/TheAlgorithms/Python/blob/master/maths/lucas_series.py)
-
   * [mobius function](https://github.com/TheAlgorithms/Python/blob/master/maths/mobius_function.py)
-
   * [modular exponential](https://github.com/TheAlgorithms/Python/blob/master/maths/modular_exponential.py)
-
   * [newton raphson](https://github.com/TheAlgorithms/Python/blob/master/maths/newton_raphson.py)
-
   * [prime check](https://github.com/TheAlgorithms/Python/blob/master/maths/prime_check.py)
-
   * [prime factors](https://github.com/TheAlgorithms/Python/blob/master/maths/prime_factors.py)
-
   * [quadratic equations complex numbers](https://github.com/TheAlgorithms/Python/blob/master/maths/quadratic_equations_complex_numbers.py)
-
   * [segmented sieve](https://github.com/TheAlgorithms/Python/blob/master/maths/segmented_sieve.py)
-
   * [sieve of eratosthenes](https://github.com/TheAlgorithms/Python/blob/master/maths/sieve_of_eratosthenes.py)
-
   * [simpson rule](https://github.com/TheAlgorithms/Python/blob/master/maths/simpson_rule.py)
-
   * [test prime check](https://github.com/TheAlgorithms/Python/blob/master/maths/test_prime_check.py)
-
   * [trapezoidal rule](https://github.com/TheAlgorithms/Python/blob/master/maths/trapezoidal_rule.py)
-
   * [volume](https://github.com/TheAlgorithms/Python/blob/master/maths/volume.py)
-
   * [zellers congruence](https://github.com/TheAlgorithms/Python/blob/master/maths/zellers_congruence.py)
-
 ## Matrix
-
   * [matrix operation](https://github.com/TheAlgorithms/Python/blob/master/matrix/matrix_operation.py)
-
   * [nth fibonacci using matrix exponentiation](https://github.com/TheAlgorithms/Python/blob/master/matrix/nth_fibonacci_using_matrix_exponentiation.py)
-
   * [rotate matrix](https://github.com/TheAlgorithms/Python/blob/master/matrix/rotate_matrix.py)
-
   * [searching in sorted matrix](https://github.com/TheAlgorithms/Python/blob/master/matrix/searching_in_sorted_matrix.py)
-
   * [spiral print](https://github.com/TheAlgorithms/Python/blob/master/matrix/spiral_print.py)
-
   * Tests
-
-    * [test matrix operation](https://github.com/TheAlgorithms/Python/blob/master/matrix/tests/test_matrix_operation.py)
-
+    * [test matrix operation](https://github.com/TheAlgorithms/Python/blob/master/matrix/test_matrix_operation.py)
 ## Networking Flow
-
   * [ford fulkerson](https://github.com/TheAlgorithms/Python/blob/master/networking_flow/ford_fulkerson.py)
-
   * [minimum cut](https://github.com/TheAlgorithms/Python/blob/master/networking_flow/minimum_cut.py)
-
 ## Neural Network
-
   * [back propagation neural network](https://github.com/TheAlgorithms/Python/blob/master/neural_network/back_propagation_neural_network.py)
-
   * [convolution neural network](https://github.com/TheAlgorithms/Python/blob/master/neural_network/convolution_neural_network.py)
-
   * [fully connected neural network](https://github.com/TheAlgorithms/Python/blob/master/neural_network/fully_connected_neural_network.ipynb)
-
   * [perceptron](https://github.com/TheAlgorithms/Python/blob/master/neural_network/perceptron.py)
-
 ## Other
-
   * [anagrams](https://github.com/TheAlgorithms/Python/blob/master/other/anagrams.py)
-
   * [binary exponentiation](https://github.com/TheAlgorithms/Python/blob/master/other/binary_exponentiation.py)
-
   * [binary exponentiation 2](https://github.com/TheAlgorithms/Python/blob/master/other/binary_exponentiation_2.py)
-
   * [detecting english programmatically](https://github.com/TheAlgorithms/Python/blob/master/other/detecting_english_programmatically.py)
-
   * [euclidean gcd](https://github.com/TheAlgorithms/Python/blob/master/other/euclidean_gcd.py)
-
   * [fischer yates shuffle](https://github.com/TheAlgorithms/Python/blob/master/other/fischer_yates_shuffle.py)
-
   * [food wastage analysis from 1961-2013 fao](https://github.com/TheAlgorithms/Python/blob/master/other/food_wastage_analysis_from_1961-2013_fao.ipynb)
-
   * [frequency finder](https://github.com/TheAlgorithms/Python/blob/master/other/frequency_finder.py)
-
   * [game of life](https://github.com/TheAlgorithms/Python/blob/master/other/game_of_life.py)
-
   * [linear congruential generator](https://github.com/TheAlgorithms/Python/blob/master/other/linear_congruential_generator.py)
-
   * [nested brackets](https://github.com/TheAlgorithms/Python/blob/master/other/nested_brackets.py)
-
   * [palindrome](https://github.com/TheAlgorithms/Python/blob/master/other/palindrome.py)
-
   * [password generator](https://github.com/TheAlgorithms/Python/blob/master/other/password_generator.py)
-
   * [primelib](https://github.com/TheAlgorithms/Python/blob/master/other/primelib.py)
-
   * [sierpinski triangle](https://github.com/TheAlgorithms/Python/blob/master/other/sierpinski_triangle.py)
-
   * [tower of hanoi](https://github.com/TheAlgorithms/Python/blob/master/other/tower_of_hanoi.py)
-
   * [two sum](https://github.com/TheAlgorithms/Python/blob/master/other/two_sum.py)
-
   * [word patterns](https://github.com/TheAlgorithms/Python/blob/master/other/word_patterns.py)
-
 ## Project Euler
-
   * Problem 01
-
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_01/sol1.py)
-
-    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_01/sol2.py)
-
-    * [sol3](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_01/sol3.py)
-
-    * [sol4](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_01/sol4.py)
-
-    * [sol5](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_01/sol5.py)
-
-    * [sol6](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_01/sol6.py)
-
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
+    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol2.py)
+    * [sol3](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol3.py)
+    * [sol4](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol4.py)
+    * [sol5](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol5.py)
+    * [sol6](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol6.py)
   * Problem 02
-
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_02/sol1.py)
-
-    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_02/sol2.py)
-
-    * [sol3](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_02/sol3.py)
-
-    * [sol4](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_02/sol4.py)
-
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
+    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol2.py)
+    * [sol3](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol3.py)
+    * [sol4](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol4.py)
   * Problem 03
-
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_03/sol1.py)
-
-    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_03/sol2.py)
-
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
+    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol2.py)
   * Problem 04
-
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_04/sol1.py)
-
-    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_04/sol2.py)
-
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
+    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol2.py)
   * Problem 05
-
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_05/sol1.py)
-
-    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_05/sol2.py)
-
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
+    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol2.py)
   * Problem 06
-
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_06/sol1.py)
-
-    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_06/sol2.py)
-
-    * [sol3](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_06/sol3.py)
-
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
+    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol2.py)
+    * [sol3](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol3.py)
   * Problem 07
-
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_07/sol1.py)
-
-    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_07/sol2.py)
-
-    * [sol3](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_07/sol3.py)
-
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
+    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol2.py)
+    * [sol3](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol3.py)
   * Problem 08
-
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_08/sol1.py)
-
-    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_08/sol2.py)
-
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
+    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol2.py)
   * Problem 09
-
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_09/sol1.py)
-
-    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_09/sol2.py)
-
-    * [sol3](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_09/sol3.py)
-
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
+    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol2.py)
+    * [sol3](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol3.py)
   * Problem 10
-
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_10/sol1.py)
-
-    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_10/sol2.py)
-
-    * [sol3](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_10/sol3.py)
-
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
+    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol2.py)
+    * [sol3](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol3.py)
   * Problem 11
-
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_11/sol1.py)
-
-    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_11/sol2.py)
-
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
+    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol2.py)
   * Problem 12
-
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_12/sol1.py)
-
-    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_12/sol2.py)
-
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
+    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol2.py)
   * Problem 13
-
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_13/sol1.py)
-
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
   * Problem 14
-
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_14/sol1.py)
-
-    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_14/sol2.py)
-
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
+    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol2.py)
   * Problem 15
-
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_15/sol1.py)
-
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
   * Problem 16
-
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_16/sol1.py)
-
-    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_16/sol2.py)
-
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
+    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol2.py)
   * Problem 17
-
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_17/sol1.py)
-
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
+  * Problem 18
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
   * Problem 19
-
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_19/sol1.py)
-
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
   * Problem 20
-
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_20/sol1.py)
-
-    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_20/sol2.py)
-
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
+    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol2.py)
   * Problem 21
-
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_21/sol1.py)
-
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
   * Problem 22
-
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_22/sol1.py)
-
-    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_22/sol2.py)
-
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
+    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol2.py)
   * Problem 234
-
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_234/sol1.py)
-
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
   * Problem 24
-
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_24/sol1.py)
-
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
   * Problem 25
-
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_25/sol1.py)
-
-    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_25/sol2.py)
-
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
+    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol2.py)
   * Problem 28
-
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_28/sol1.py)
-
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
   * Problem 29
-
-    * [solution](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_29/solution.py)
-
+    * [solution](https://github.com/TheAlgorithms/Python/blob/master/project_euler/solution.py)
   * Problem 31
-
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_31/sol1.py)
-
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
   * Problem 36
-
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_36/sol1.py)
-
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
   * Problem 40
-
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_40/sol1.py)
-
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
   * Problem 48
-
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_48/sol1.py)
-
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
   * Problem 52
-
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_52/sol1.py)
-
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
   * Problem 53
-
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_53/sol1.py)
-
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
+  * Problem 56
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
   * Problem 76
-
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_76/sol1.py)
-
+    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
 ## Searches
-
   * [binary search](https://github.com/TheAlgorithms/Python/blob/master/searches/binary_search.py)
-
   * [interpolation search](https://github.com/TheAlgorithms/Python/blob/master/searches/interpolation_search.py)
-
   * [jump search](https://github.com/TheAlgorithms/Python/blob/master/searches/jump_search.py)
-
   * [linear search](https://github.com/TheAlgorithms/Python/blob/master/searches/linear_search.py)
-
   * [quick select](https://github.com/TheAlgorithms/Python/blob/master/searches/quick_select.py)
-
   * [sentinel linear search](https://github.com/TheAlgorithms/Python/blob/master/searches/sentinel_linear_search.py)
-
   * [tabu search](https://github.com/TheAlgorithms/Python/blob/master/searches/tabu_search.py)
-
   * [ternary search](https://github.com/TheAlgorithms/Python/blob/master/searches/ternary_search.py)
-
 ## Sorts
-
   * [bitonic sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/bitonic_sort.py)
-
   * [bogo sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/bogo_sort.py)
-
   * [bubble sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/bubble_sort.py)
-
   * [bucket sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/bucket_sort.py)
-
   * [cocktail shaker sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/cocktail_shaker_sort.py)
-
   * [comb sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/comb_sort.py)
-
   * [counting sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/counting_sort.py)
-
   * [cycle sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/cycle_sort.py)
-
   * [external sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/external_sort.py)
-
   * [gnome sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/gnome_sort.py)
-
   * [heap sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/heap_sort.py)
-
   * [insertion sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/insertion_sort.py)
-
   * [merge sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/merge_sort.py)
-
   * [merge sort fastest](https://github.com/TheAlgorithms/Python/blob/master/sorts/merge_sort_fastest.py)
-
   * [odd even transposition parallel](https://github.com/TheAlgorithms/Python/blob/master/sorts/odd_even_transposition_parallel.py)
-
   * [odd even transposition single threaded](https://github.com/TheAlgorithms/Python/blob/master/sorts/odd_even_transposition_single_threaded.py)
-
   * [pancake sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/pancake_sort.py)
-
   * [pigeon sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/pigeon_sort.py)
-
   * [quick sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/quick_sort.py)
-
   * [quick sort 3 partition](https://github.com/TheAlgorithms/Python/blob/master/sorts/quick_sort_3_partition.py)
-
   * [radix sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/radix_sort.py)
-
   * [random normal distribution quicksort](https://github.com/TheAlgorithms/Python/blob/master/sorts/random_normal_distribution_quicksort.py)
-
   * [random pivot quick sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/random_pivot_quick_sort.py)
-
   * [selection sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/selection_sort.py)
-
   * [shell sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/shell_sort.py)
-
   * [tim sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/tim_sort.py)
-
   * [topological sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/topological_sort.py)
-
   * [tree sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/tree_sort.py)
-
   * [wiggle sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/wiggle_sort.py)
-
 ## Strings
-
   * [boyer moore search](https://github.com/TheAlgorithms/Python/blob/master/strings/boyer_moore_search.py)
-
   * [knuth morris pratt](https://github.com/TheAlgorithms/Python/blob/master/strings/knuth_morris_pratt.py)
-
   * [levenshtein distance](https://github.com/TheAlgorithms/Python/blob/master/strings/levenshtein_distance.py)
-
   * [manacher](https://github.com/TheAlgorithms/Python/blob/master/strings/manacher.py)
-
   * [min cost string conversion](https://github.com/TheAlgorithms/Python/blob/master/strings/min_cost_string_conversion.py)
-
   * [naive string search](https://github.com/TheAlgorithms/Python/blob/master/strings/naive_string_search.py)
-
   * [rabin karp](https://github.com/TheAlgorithms/Python/blob/master/strings/rabin_karp.py)
-
 ## Traversals
-
   * [binary tree traversals](https://github.com/TheAlgorithms/Python/blob/master/traversals/binary_tree_traversals.py)
+
diff --git a/scripts/build_directory_md.py b/scripts/build_directory_md.py
index 2ebd445b3667..b39edca6c933 100755
--- a/scripts/build_directory_md.py
+++ b/scripts/build_directory_md.py
@@ -14,7 +14,7 @@ def good_filepaths(top_dir: str = ".") -> Iterator[str]:
                 continue
             if os.path.splitext(filename)[1] in (".py", ".ipynb"):
                 yield os.path.join(dirpath, filename).lstrip("./")
-
+                
 
 def md_prefix(i):
     return f"{i * '  '}*" if i else "##"
@@ -25,7 +25,7 @@ def print_path(old_path: str, new_path: str) -> str:
     for i, new_part in enumerate(new_path.split(os.sep)):
         if i + 1 > len(old_parts) or old_parts[i] != new_part:
             if new_part:
-                print(f"{md_prefix(i)} {new_part.replace('_', ' ').title()}")
+                print(f"{md_prefix(i-1)} {new_part.replace('_', ' ').title()}")
     return new_path
 
 
@@ -36,7 +36,7 @@ def print_directory_md(top_dir: str = ".") -> None:
         if filepath != old_path:
             old_path = print_path(old_path, filepath)
         indent = (filepath.count(os.sep) + 1) if filepath else 0
-        url = "/".join((URL_BASE, filepath, filename)).replace(" ", "%20")
+        url = "/".join((URL_BASE, filepath.split(os.sep)[1], filename)).replace(" ", "%20")
         filename = os.path.splitext(filename.replace("_", " "))[0]
         print(f"{md_prefix(indent)} [{filename}]({url})")
 

From a41a14f9d89b665178f08535f128ba14652ce449 Mon Sep 17 00:00:00 2001
From: KirilBangachev <51961981+KirilBangachev@users.noreply.github.com>
Date: Fri, 6 Sep 2019 12:06:56 +0300
Subject: [PATCH 206/348] Add radix2 FFT (#1166)

* Add radix2 FFT

Created a dynamic implementation of the radix - 2 Fast Fourier Transform for fast polynomial multiplication.

Reference: https://en.wikipedia.org/wiki/Cooley%E2%80%93Tukey_FFT_algorithm#The_radix-2_DIT_case

* Rename radix2_FFT.py to radix2_fft.py

* Update radix2_fft printing

Improved the printing method with f.prefix and String.join()

* __str__ method update

* Turned the tests into doctests
---
 maths/radix2_fft.py | 222 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 222 insertions(+)
 create mode 100644 maths/radix2_fft.py

diff --git a/maths/radix2_fft.py b/maths/radix2_fft.py
new file mode 100644
index 000000000000..c7ffe96528b4
--- /dev/null
+++ b/maths/radix2_fft.py
@@ -0,0 +1,222 @@
+"""
+Fast Polynomial Multiplication using radix-2 fast Fourier Transform.
+"""
+
+import mpmath  # for roots of unity
+import numpy as np
+
+
+class FFT:
+    """
+    Fast Polynomial Multiplication using radix-2 fast Fourier Transform.
+
+    Reference:
+    https://en.wikipedia.org/wiki/Cooley%E2%80%93Tukey_FFT_algorithm#The_radix-2_DIT_case
+        
+    For polynomials of degree m and n the algorithms has complexity 
+    O(n*logn + m*logm)
+        
+    The main part of the algorithm is split in two parts:
+        1) __DFT: We compute the discrete fourier transform (DFT) of A and B using a 
+        bottom-up dynamic approach - 
+        2) __multiply: Once we obtain the DFT of A*B, we can similarly
+        invert it to obtain A*B
+
+    The class FFT takes two polynomials A and B with complex coefficients as arguments; 
+    The two polynomials should be represented as a sequence of coefficients starting
+    from the free term. Thus, for instance x + 2*x^3 could be represented as 
+    [0,1,0,2] or (0,1,0,2). The constructor adds some zeros at the end so that the 
+    polynomials have the same length which is a power of 2 at least the length of 
+    their product. 
+    
+    Example:
+     
+    Create two polynomials as sequences
+    >>> A = [0, 1, 0, 2]  # x+2x^3
+    >>> B = (2, 3, 4, 0)  # 2+3x+4x^2
+    
+    Create an FFT object with them
+    >>> x = FFT(A, B)
+    
+    Print product
+    >>> print(x.product)  # 2x + 3x^2 + 8x^3 + 4x^4 + 6x^5
+    [(-0+0j), (2+0j), (3+0j), (8+0j), (6+0j), (8+0j)]
+    
+    __str__ test
+    >>> print(x)
+    A = 0*x^0 + 1*x^1 + 2*x^0 + 3*x^2
+    B = 0*x^2 + 1*x^3 + 2*x^4
+    A*B = 0*x^(-0+0j) + 1*x^(2+0j) + 2*x^(3+0j) + 3*x^(8+0j) + 4*x^(6+0j) + 5*x^(8+0j)
+    """
+
+    def __init__(self, polyA=[0], polyB=[0]):
+        # Input as list
+        self.polyA = list(polyA)[:]
+        self.polyB = list(polyB)[:]
+
+        # Remove leading zero coefficients
+        while self.polyA[-1] == 0:
+            self.polyA.pop()
+        self.len_A = len(self.polyA)
+
+        while self.polyB[-1] == 0:
+            self.polyB.pop()
+        self.len_B = len(self.polyB)
+
+        # Add 0 to make lengths equal a power of 2
+        self.C_max_length = int(
+            2
+            ** np.ceil(
+                np.log2(
+                    len(self.polyA) + len(self.polyB) - 1
+                )
+            )
+        )
+
+        while len(self.polyA) < self.C_max_length:
+            self.polyA.append(0)
+        while len(self.polyB) < self.C_max_length:
+            self.polyB.append(0)
+        # A complex root used for the fourier transform
+        self.root = complex(
+            mpmath.root(x=1, n=self.C_max_length, k=1)
+        )
+
+        # The product
+        self.product = self.__multiply()
+
+    # Discrete fourier transform of A and B
+    def __DFT(self, which):
+        if which == "A":
+            dft = [[x] for x in self.polyA]
+        else:
+            dft = [[x] for x in self.polyB]
+        # Corner case
+        if len(dft) <= 1:
+            return dft[0]
+        #
+        next_ncol = self.C_max_length // 2
+        while next_ncol > 0:
+            new_dft = [[] for i in range(next_ncol)]
+            root = self.root ** next_ncol
+
+            # First half of next step
+            current_root = 1
+            for j in range(
+                self.C_max_length // (next_ncol * 2)
+            ):
+                for i in range(next_ncol):
+                    new_dft[i].append(
+                        dft[i][j]
+                        + current_root
+                        * dft[i + next_ncol][j]
+                    )
+                current_root *= root
+            # Second half of next step
+            current_root = 1
+            for j in range(
+                self.C_max_length // (next_ncol * 2)
+            ):
+                for i in range(next_ncol):
+                    new_dft[i].append(
+                        dft[i][j]
+                        - current_root
+                        * dft[i + next_ncol][j]
+                    )
+                current_root *= root
+            # Update
+            dft = new_dft
+            next_ncol = next_ncol // 2
+        return dft[0]
+
+    # multiply the DFTs of  A and B and find A*B
+    def __multiply(self):
+        dftA = self.__DFT("A")
+        dftB = self.__DFT("B")
+        inverseC = [
+            [
+                dftA[i] * dftB[i]
+                for i in range(self.C_max_length)
+            ]
+        ]
+        del dftA
+        del dftB
+
+        # Corner Case
+        if len(inverseC[0]) <= 1:
+            return inverseC[0]
+        # Inverse DFT
+        next_ncol = 2
+        while next_ncol <= self.C_max_length:
+            new_inverseC = [[] for i in range(next_ncol)]
+            root = self.root ** (next_ncol // 2)
+            current_root = 1
+            # First half of next step
+            for j in range(self.C_max_length // next_ncol):
+                for i in range(next_ncol // 2):
+                    # Even positions
+                    new_inverseC[i].append(
+                        (
+                            inverseC[i][j]
+                            + inverseC[i][
+                                j
+                                + self.C_max_length
+                                // next_ncol
+                            ]
+                        )
+                        / 2
+                    )
+                    # Odd positions
+                    new_inverseC[i + next_ncol // 2].append(
+                        (
+                            inverseC[i][j]
+                            - inverseC[i][
+                                j
+                                + self.C_max_length
+                                // next_ncol
+                            ]
+                        )
+                        / (2 * current_root)
+                    )
+                current_root *= root
+            # Update
+            inverseC = new_inverseC
+            next_ncol *= 2
+        # Unpack
+        inverseC = [
+            round(x[0].real, 8) + round(x[0].imag, 8) * 1j
+            for x in inverseC
+        ]
+
+        # Remove leading 0's
+        while inverseC[-1] == 0:
+            inverseC.pop()
+        return inverseC
+
+    # Overwrite __str__ for print(); Shows A, B and A*B
+    def __str__(self):
+        A = "A = " + " + ".join(
+            f"{coef}*x^{i}"
+            for coef, i in enumerate(
+                self.polyA[: self.len_A]
+            )
+        )
+        B = "B = " + " + ".join(
+            f"{coef}*x^{i}"
+            for coef, i in enumerate(
+                self.polyB[: self.len_B]
+            )
+        )
+        C = "A*B = " + " + ".join(
+            f"{coef}*x^{i}"
+            for coef, i in enumerate(self.product)
+        )
+
+        return "\n".join((A, B, C))
+
+
+# Unit tests
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()

From 5b483be73b95b9e5a39c122734ca4eff0da593cd Mon Sep 17 00:00:00 2001
From: Jasper <46252815+jasper256@users.noreply.github.com>
Date: Sun, 8 Sep 2019 01:07:14 -0400
Subject: [PATCH 207/348] Added OOP approach to matrices (#1165)

* Added OOP aproach to matrices

* created methods for minors, cofactors, and determinants and added corresponding doctests

* Added methods for adjugate, inverse, and identity (along with corresponding doctests) to matrix_class.py
A small bug persists that causes the doctest to fail.
After a couple Matrix objects are printed, the next one is printed in a different format.

* formatted matrix_class.py with python/black

* implemented negation and exponentiation as well as corresponding doctests in matrix_class.py.  Also implemented eq and ne comparison operations

* changed __str__ method in matrix_class.py to align with numpy standard and fixed bug in cofactors method

* removed property decorators from several methods in matrix_class.py
---
 matrix/matrix_class.py | 364 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 364 insertions(+)
 create mode 100644 matrix/matrix_class.py

diff --git a/matrix/matrix_class.py b/matrix/matrix_class.py
new file mode 100644
index 000000000000..2cd43fc9ca8e
--- /dev/null
+++ b/matrix/matrix_class.py
@@ -0,0 +1,364 @@
+# An OOP aproach to representing and manipulating matrices
+
+
+class Matrix:
+    """
+    Matrix object generated from a 2D array where each element is an array representing a row.
+    Rows can contain type int or float.
+    Common operations and information available.
+    >>> rows = [
+    ...     [1, 2, 3],
+    ...     [4, 5, 6],
+    ...     [7, 8, 9]
+    ... ]
+    >>> matrix = Matrix(rows)
+    >>> print(matrix)
+    [[1. 2. 3.]
+     [4. 5. 6.]
+     [7. 8. 9.]]
+    
+    Matrix rows and columns are available as 2D arrays
+    >>> print(matrix.rows)
+    [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
+    >>> print(matrix.columns())
+    [[1, 4, 7], [2, 5, 8], [3, 6, 9]]
+    
+    Order is returned as a tuple
+    >>> matrix.order
+    (3, 3)
+
+    Squareness and invertability are represented as bool
+    >>> matrix.is_square
+    True
+    >>> matrix.is_invertable()
+    False
+
+    Identity, Minors, Cofactors and Adjugate are returned as Matrices.  Inverse can be a Matrix or Nonetype
+    >>> print(matrix.identity())
+    [[1. 0. 0.]
+     [0. 1. 0.]
+     [0. 0. 1.]]
+    >>> print(matrix.minors())
+    [[-3. -6. -3.]
+     [-6. -12. -6.]
+     [-3. -6. -3.]]
+    >>> print(matrix.cofactors())
+    [[-3. 6. -3.]
+     [6. -12. 6.]
+     [-3. 6. -3.]]
+    >>> print(matrix.adjugate()) # won't be apparent due to the nature of the cofactor matrix
+    [[-3. 6. -3.]
+     [6. -12. 6.]
+     [-3. 6. -3.]]
+    >>> print(matrix.inverse())
+    None
+
+    Determinant is an int, float, or Nonetype
+    >>> matrix.determinant()
+    0
+
+    Negation, scalar multiplication, addition, subtraction, multiplication and exponentiation are available and all return a Matrix
+    >>> print(-matrix)
+    [[-1. -2. -3.]
+     [-4. -5. -6.]
+     [-7. -8. -9.]]
+    >>> matrix2 = matrix * 3
+    >>> print(matrix2)
+    [[3. 6. 9.]
+     [12. 15. 18.]
+     [21. 24. 27.]]
+    >>> print(matrix + matrix2)
+    [[4. 8. 12.]
+     [16. 20. 24.]
+     [28. 32. 36.]]
+    >>> print(matrix - matrix2)
+    [[-2. -4. -6.]
+     [-8. -10. -12.]
+     [-14. -16. -18.]]
+    >>> print(matrix ** 3)
+    [[468. 576. 684.]
+     [1062. 1305. 1548.]
+     [1656. 2034. 2412.]]
+
+    Matrices can also be modified
+    >>> matrix.add_row([10, 11, 12])
+    >>> print(matrix)
+    [[1. 2. 3.]
+     [4. 5. 6.]
+     [7. 8. 9.]
+     [10. 11. 12.]]
+    >>> matrix2.add_column([8, 16, 32])
+    >>> print(matrix2)
+    [[3. 6. 9. 8.]
+     [12. 15. 18. 16.]
+     [21. 24. 27. 32.]]
+    >>> print(matrix *  matrix2)
+    [[90. 108. 126. 136.]
+     [198. 243. 288. 304.]
+     [306. 378. 450. 472.]
+     [414. 513. 612. 640.]]
+
+    """
+
+    def __init__(self, rows):
+        error = TypeError(
+            "Matrices must be formed from a list of zero or more lists containing at least one and the same number of values, \
+                each of which must be of type int or float"
+        )
+        if len(rows) != 0:
+            cols = len(rows[0])
+            if cols == 0:
+                raise error
+            for row in rows:
+                if not len(row) == cols:
+                    raise error
+                for value in row:
+                    if not isinstance(value, (int, float)):
+                        raise error
+            self.rows = rows
+        else:
+            self.rows = []
+
+    # MATRIX INFORMATION
+    def columns(self):
+        return [[row[i] for row in self.rows] for i in range(len(self.rows[0]))]
+
+    @property
+    def num_rows(self):
+        return len(self.rows)
+
+    @property
+    def num_columns(self):
+        return len(self.rows[0])
+
+    @property
+    def order(self):
+        return (self.num_rows, self.num_columns)
+
+    @property
+    def is_square(self):
+        if self.order[0] == self.order[1]:
+            return True
+        return False
+
+    def identity(self):
+        values = [
+            [0 if column_num != row_num else 1 for column_num in range(self.num_rows)]
+            for row_num in range(self.num_rows)
+        ]
+        return Matrix(values)
+
+    def determinant(self):
+        if not self.is_square:
+            return None
+        if self.order == (0, 0):
+            return 1
+        if self.order == (1, 1):
+            return self.rows[0][0]
+        if self.order == (2, 2):
+            return (self.rows[0][0] * self.rows[1][1]) - (
+                self.rows[0][1] * self.rows[1][0]
+            )
+        else:
+            return sum(
+                [
+                    self.rows[0][column] * self.cofactors().rows[0][column]
+                    for column in range(self.num_columns)
+                ]
+            )
+
+    def is_invertable(self):
+        if self.determinant():
+            return True
+        return False
+
+    def get_minor(self, row, column):
+        values = [
+            [
+                self.rows[other_row][other_column]
+                for other_column in range(self.num_columns)
+                if other_column != column
+            ]
+            for other_row in range(self.num_rows)
+            if other_row != row
+        ]
+        return Matrix(values).determinant()
+
+    def get_cofactor(self, row, column):
+        if (row + column) % 2 == 0:
+            return self.get_minor(row, column)
+        return -1 * self.get_minor(row, column)
+
+    def minors(self):
+        return Matrix(
+            [
+                [self.get_minor(row, column) for column in range(self.num_columns)]
+                for row in range(self.num_rows)
+            ]
+        )
+
+    def cofactors(self):
+        return Matrix(
+            [
+                [
+                    self.minors().rows[row][column]
+                    if (row + column) % 2 == 0
+                    else self.minors().rows[row][column] * -1
+                    for column in range(self.minors().num_columns)
+                ]
+                for row in range(self.minors().num_rows)
+            ]
+        )
+
+    def adjugate(self):
+        values = [
+            [self.cofactors().rows[column][row] for column in range(self.num_columns)]
+            for row in range(self.num_rows)
+        ]
+        return Matrix(values)
+
+    def inverse(self):
+        if not self.is_invertable():
+            return None
+        return self.adjugate() * (1 / self.determinant())
+
+    def __repr__(self):
+        return str(self.rows)
+
+    def __str__(self):
+        if self.num_rows == 0:
+            return "[]"
+        if self.num_rows == 1:
+            return "[[" + ". ".join(self.rows[0]) + "]]"
+        return (
+            "["
+            + "\n ".join(
+                [
+                    "[" + ". ".join([str(value) for value in row]) + ".]"
+                    for row in self.rows
+                ]
+            )
+            + "]"
+        )
+
+    # MATRIX MANIPULATION
+    def add_row(self, row, position=None):
+        type_error = TypeError("Row must be a list containing all ints and/or floats")
+        if not isinstance(row, list):
+            raise type_error
+        for value in row:
+            if not isinstance(value, (int, float)):
+                raise type_error
+        if len(row) != self.num_columns:
+            raise ValueError(
+                "Row must be equal in length to the other rows in the matrix"
+            )
+        if position is None:
+            self.rows.append(row)
+        else:
+            self.rows = self.rows[0:position] + [row] + self.rows[position:]
+
+    def add_column(self, column, position=None):
+        type_error = TypeError(
+            "Column must be a list containing all ints and/or floats"
+        )
+        if not isinstance(column, list):
+            raise type_error
+        for value in column:
+            if not isinstance(value, (int, float)):
+                raise type_error
+        if len(column) != self.num_rows:
+            raise ValueError(
+                "Column must be equal in length to the other columns in the matrix"
+            )
+        if position is None:
+            self.rows = [self.rows[i] + [column[i]] for i in range(self.num_rows)]
+        else:
+            self.rows = [
+                self.rows[i][0:position] + [column[i]] + self.rows[i][position:]
+                for i in range(self.num_rows)
+            ]
+
+    # MATRIX OPERATIONS
+    def __eq__(self, other):
+        if not isinstance(other, Matrix):
+            raise TypeError("A Matrix can only be compared with another Matrix")
+        if self.rows == other.rows:
+            return True
+        return False
+
+    def __ne__(self, other):
+        if self == other:
+            return False
+        return True
+
+    def __neg__(self):
+        return self * -1
+
+    def __add__(self, other):
+        if self.order != other.order:
+            raise ValueError("Addition requires matrices of the same order")
+        return Matrix(
+            [
+                [self.rows[i][j] + other.rows[i][j] for j in range(self.num_columns)]
+                for i in range(self.num_rows)
+            ]
+        )
+
+    def __sub__(self, other):
+        if self.order != other.order:
+            raise ValueError("Subtraction requires matrices of the same order")
+        return Matrix(
+            [
+                [self.rows[i][j] - other.rows[i][j] for j in range(self.num_columns)]
+                for i in range(self.num_rows)
+            ]
+        )
+
+    def __mul__(self, other):
+        if not isinstance(other, (int, float, Matrix)):
+            raise TypeError(
+                "A Matrix can only be multiplied by an int, float, or another matrix"
+            )
+        if type(other) in (int, float):
+            return Matrix([[element * other for element in row] for row in self.rows])
+        if type(other) is Matrix:
+            if self.num_columns != other.num_rows:
+                raise ValueError(
+                    "The number of columns in the first matrix must be equal to the number of rows in the second"
+                )
+            return Matrix(
+                [
+                    [Matrix.dot_product(row, column) for column in other.columns()]
+                    for row in self.rows
+                ]
+            )
+
+    def __pow__(self, other):
+        if not isinstance(other, int):
+            raise TypeError("A Matrix can only be raised to the power of an int")
+        if not self.is_square:
+            raise ValueError("Only square matrices can be raised to a power")
+        if other == 0:
+            return self.identity()
+        if other < 0:
+            if self.is_invertable:
+                return self.inverse() ** (-other)
+            raise ValueError(
+                "Only invertable matrices can be raised to a negative power"
+            )
+        result = self
+        for i in range(other - 1):
+            result *= self
+        return result
+
+    @classmethod
+    def dot_product(cls, row, column):
+        return sum([row[i] * column[i] for i in range(len(row))])
+
+
+if __name__ == "__main__":
+    import doctest
+
+    test = doctest.testmod()
+    print(test)

From 3c3f92db530e3ae0e594cd1d5c4e034cc23defc9 Mon Sep 17 00:00:00 2001
From: Simon Landry <landry_simon@pm.me>
Date: Sun, 8 Sep 2019 04:40:07 -0400
Subject: [PATCH 208/348] Add problem 67 solution (#1170)

---
 project_euler/problem_67/__init__.py  |   0
 project_euler/problem_67/sol1.py      |  49 +++++++++++++
 project_euler/problem_67/triangle.txt | 100 ++++++++++++++++++++++++++
 3 files changed, 149 insertions(+)
 create mode 100644 project_euler/problem_67/__init__.py
 create mode 100644 project_euler/problem_67/sol1.py
 create mode 100644 project_euler/problem_67/triangle.txt

diff --git a/project_euler/problem_67/__init__.py b/project_euler/problem_67/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/project_euler/problem_67/sol1.py b/project_euler/problem_67/sol1.py
new file mode 100644
index 000000000000..2da757e303aa
--- /dev/null
+++ b/project_euler/problem_67/sol1.py
@@ -0,0 +1,49 @@
+"""
+Problem Statement:
+By starting at the top of the triangle below and moving to adjacent numbers on
+the row below, the maximum total from top to bottom is 23.
+3
+7 4
+2 4 6
+8 5 9 3
+That is, 3 + 7 + 4 + 9 = 23.
+Find the maximum total from top to bottom in triangle.txt (right click and
+'Save Link/Target As...'), a 15K text file containing a triangle with
+one-hundred rows.
+"""
+import os
+
+
+def solution():
+    """
+    Finds the maximum total in a triangle as described by the problem statement
+    above.
+
+    >>> solution()
+    7273
+    """
+    script_dir = os.path.dirname(os.path.realpath(__file__))
+    triangle = os.path.join(script_dir, 'triangle.txt')
+
+    with open(triangle, 'r') as f:
+        triangle = f.readlines()
+
+    a = map(lambda x: x.rstrip('\r\n').split(' '), triangle)
+    a = list(map(lambda x: list(map(lambda y: int(y), x)), a))
+
+    for i in range(1, len(a)):
+        for j in range(len(a[i])):
+            if j != len(a[i - 1]):
+                number1 = a[i - 1][j]
+            else:
+                number1 = 0
+            if j > 0:
+                number2 = a[i - 1][j - 1]
+            else:
+                number2 = 0
+            a[i][j] += max(number1, number2)
+    return max(a[-1])
+
+
+if __name__ == "__main__":
+    print(solution())
diff --git a/project_euler/problem_67/triangle.txt b/project_euler/problem_67/triangle.txt
new file mode 100644
index 000000000000..00aa2bc6382d
--- /dev/null
+++ b/project_euler/problem_67/triangle.txt
@@ -0,0 +1,100 @@
+59
+73 41
+52 40 09
+26 53 06 34
+10 51 87 86 81
+61 95 66 57 25 68
+90 81 80 38 92 67 73
+30 28 51 76 81 18 75 44
+84 14 95 87 62 81 17 78 58
+21 46 71 58 02 79 62 39 31 09
+56 34 35 53 78 31 81 18 90 93 15
+78 53 04 21 84 93 32 13 97 11 37 51
+45 03 81 79 05 18 78 86 13 30 63 99 95
+39 87 96 28 03 38 42 17 82 87 58 07 22 57
+06 17 51 17 07 93 09 07 75 97 95 78 87 08 53
+67 66 59 60 88 99 94 65 55 77 55 34 27 53 78 28
+76 40 41 04 87 16 09 42 75 69 23 97 30 60 10 79 87
+12 10 44 26 21 36 32 84 98 60 13 12 36 16 63 31 91 35
+70 39 06 05 55 27 38 48 28 22 34 35 62 62 15 14 94 89 86
+66 56 68 84 96 21 34 34 34 81 62 40 65 54 62 05 98 03 02 60
+38 89 46 37 99 54 34 53 36 14 70 26 02 90 45 13 31 61 83 73 47
+36 10 63 96 60 49 41 05 37 42 14 58 84 93 96 17 09 43 05 43 06 59
+66 57 87 57 61 28 37 51 84 73 79 15 39 95 88 87 43 39 11 86 77 74 18
+54 42 05 79 30 49 99 73 46 37 50 02 45 09 54 52 27 95 27 65 19 45 26 45
+71 39 17 78 76 29 52 90 18 99 78 19 35 62 71 19 23 65 93 85 49 33 75 09 02
+33 24 47 61 60 55 32 88 57 55 91 54 46 57 07 77 98 52 80 99 24 25 46 78 79 05
+92 09 13 55 10 67 26 78 76 82 63 49 51 31 24 68 05 57 07 54 69 21 67 43 17 63 12
+24 59 06 08 98 74 66 26 61 60 13 03 09 09 24 30 71 08 88 70 72 70 29 90 11 82 41 34
+66 82 67 04 36 60 92 77 91 85 62 49 59 61 30 90 29 94 26 41 89 04 53 22 83 41 09 74 90
+48 28 26 37 28 52 77 26 51 32 18 98 79 36 62 13 17 08 19 54 89 29 73 68 42 14 08 16 70 37
+37 60 69 70 72 71 09 59 13 60 38 13 57 36 09 30 43 89 30 39 15 02 44 73 05 73 26 63 56 86 12
+55 55 85 50 62 99 84 77 28 85 03 21 27 22 19 26 82 69 54 04 13 07 85 14 01 15 70 59 89 95 10 19
+04 09 31 92 91 38 92 86 98 75 21 05 64 42 62 84 36 20 73 42 21 23 22 51 51 79 25 45 85 53 03 43 22
+75 63 02 49 14 12 89 14 60 78 92 16 44 82 38 30 72 11 46 52 90 27 08 65 78 03 85 41 57 79 39 52 33 48
+78 27 56 56 39 13 19 43 86 72 58 95 39 07 04 34 21 98 39 15 39 84 89 69 84 46 37 57 59 35 59 50 26 15 93
+42 89 36 27 78 91 24 11 17 41 05 94 07 69 51 96 03 96 47 90 90 45 91 20 50 56 10 32 36 49 04 53 85 92 25 65
+52 09 61 30 61 97 66 21 96 92 98 90 06 34 96 60 32 69 68 33 75 84 18 31 71 50 84 63 03 03 19 11 28 42 75 45 45
+61 31 61 68 96 34 49 39 05 71 76 59 62 67 06 47 96 99 34 21 32 47 52 07 71 60 42 72 94 56 82 83 84 40 94 87 82 46
+01 20 60 14 17 38 26 78 66 81 45 95 18 51 98 81 48 16 53 88 37 52 69 95 72 93 22 34 98 20 54 27 73 61 56 63 60 34 63
+93 42 94 83 47 61 27 51 79 79 45 01 44 73 31 70 83 42 88 25 53 51 30 15 65 94 80 44 61 84 12 77 02 62 02 65 94 42 14 94
+32 73 09 67 68 29 74 98 10 19 85 48 38 31 85 67 53 93 93 77 47 67 39 72 94 53 18 43 77 40 78 32 29 59 24 06 02 83 50 60 66
+32 01 44 30 16 51 15 81 98 15 10 62 86 79 50 62 45 60 70 38 31 85 65 61 64 06 69 84 14 22 56 43 09 48 66 69 83 91 60 40 36 61
+92 48 22 99 15 95 64 43 01 16 94 02 99 19 17 69 11 58 97 56 89 31 77 45 67 96 12 73 08 20 36 47 81 44 50 64 68 85 40 81 85 52 09
+91 35 92 45 32 84 62 15 19 64 21 66 06 01 52 80 62 59 12 25 88 28 91 50 40 16 22 99 92 79 87 51 21 77 74 77 07 42 38 42 74 83 02 05
+46 19 77 66 24 18 05 32 02 84 31 99 92 58 96 72 91 36 62 99 55 29 53 42 12 37 26 58 89 50 66 19 82 75 12 48 24 87 91 85 02 07 03 76 86
+99 98 84 93 07 17 33 61 92 20 66 60 24 66 40 30 67 05 37 29 24 96 03 27 70 62 13 04 45 47 59 88 43 20 66 15 46 92 30 04 71 66 78 70 53 99
+67 60 38 06 88 04 17 72 10 99 71 07 42 25 54 05 26 64 91 50 45 71 06 30 67 48 69 82 08 56 80 67 18 46 66 63 01 20 08 80 47 07 91 16 03 79 87
+18 54 78 49 80 48 77 40 68 23 60 88 58 80 33 57 11 69 55 53 64 02 94 49 60 92 16 35 81 21 82 96 25 24 96 18 02 05 49 03 50 77 06 32 84 27 18 38
+68 01 50 04 03 21 42 94 53 24 89 05 92 26 52 36 68 11 85 01 04 42 02 45 15 06 50 04 53 73 25 74 81 88 98 21 67 84 79 97 99 20 95 04 40 46 02 58 87
+94 10 02 78 88 52 21 03 88 60 06 53 49 71 20 91 12 65 07 49 21 22 11 41 58 99 36 16 09 48 17 24 52 36 23 15 72 16 84 56 02 99 43 76 81 71 29 39 49 17
+64 39 59 84 86 16 17 66 03 09 43 06 64 18 63 29 68 06 23 07 87 14 26 35 17 12 98 41 53 64 78 18 98 27 28 84 80 67 75 62 10 11 76 90 54 10 05 54 41 39 66
+43 83 18 37 32 31 52 29 95 47 08 76 35 11 04 53 35 43 34 10 52 57 12 36 20 39 40 55 78 44 07 31 38 26 08 15 56 88 86 01 52 62 10 24 32 05 60 65 53 28 57 99
+03 50 03 52 07 73 49 92 66 80 01 46 08 67 25 36 73 93 07 42 25 53 13 96 76 83 87 90 54 89 78 22 78 91 73 51 69 09 79 94 83 53 09 40 69 62 10 79 49 47 03 81 30
+71 54 73 33 51 76 59 54 79 37 56 45 84 17 62 21 98 69 41 95 65 24 39 37 62 03 24 48 54 64 46 82 71 78 33 67 09 16 96 68 52 74 79 68 32 21 13 78 96 60 09 69 20 36
+73 26 21 44 46 38 17 83 65 98 07 23 52 46 61 97 33 13 60 31 70 15 36 77 31 58 56 93 75 68 21 36 69 53 90 75 25 82 39 50 65 94 29 30 11 33 11 13 96 02 56 47 07 49 02
+76 46 73 30 10 20 60 70 14 56 34 26 37 39 48 24 55 76 84 91 39 86 95 61 50 14 53 93 64 67 37 31 10 84 42 70 48 20 10 72 60 61 84 79 69 65 99 73 89 25 85 48 92 56 97 16
+03 14 80 27 22 30 44 27 67 75 79 32 51 54 81 29 65 14 19 04 13 82 04 91 43 40 12 52 29 99 07 76 60 25 01 07 61 71 37 92 40 47 99 66 57 01 43 44 22 40 53 53 09 69 26 81 07
+49 80 56 90 93 87 47 13 75 28 87 23 72 79 32 18 27 20 28 10 37 59 21 18 70 04 79 96 03 31 45 71 81 06 14 18 17 05 31 50 92 79 23 47 09 39 47 91 43 54 69 47 42 95 62 46 32 85
+37 18 62 85 87 28 64 05 77 51 47 26 30 65 05 70 65 75 59 80 42 52 25 20 44 10 92 17 71 95 52 14 77 13 24 55 11 65 26 91 01 30 63 15 49 48 41 17 67 47 03 68 20 90 98 32 04 40 68
+90 51 58 60 06 55 23 68 05 19 76 94 82 36 96 43 38 90 87 28 33 83 05 17 70 83 96 93 06 04 78 47 80 06 23 84 75 23 87 72 99 14 50 98 92 38 90 64 61 58 76 94 36 66 87 80 51 35 61 38
+57 95 64 06 53 36 82 51 40 33 47 14 07 98 78 65 39 58 53 06 50 53 04 69 40 68 36 69 75 78 75 60 03 32 39 24 74 47 26 90 13 40 44 71 90 76 51 24 36 50 25 45 70 80 61 80 61 43 90 64 11
+18 29 86 56 68 42 79 10 42 44 30 12 96 18 23 18 52 59 02 99 67 46 60 86 43 38 55 17 44 93 42 21 55 14 47 34 55 16 49 24 23 29 96 51 55 10 46 53 27 92 27 46 63 57 30 65 43 27 21 20 24 83
+81 72 93 19 69 52 48 01 13 83 92 69 20 48 69 59 20 62 05 42 28 89 90 99 32 72 84 17 08 87 36 03 60 31 36 36 81 26 97 36 48 54 56 56 27 16 91 08 23 11 87 99 33 47 02 14 44 73 70 99 43 35 33
+90 56 61 86 56 12 70 59 63 32 01 15 81 47 71 76 95 32 65 80 54 70 34 51 40 45 33 04 64 55 78 68 88 47 31 47 68 87 03 84 23 44 89 72 35 08 31 76 63 26 90 85 96 67 65 91 19 14 17 86 04 71 32 95
+37 13 04 22 64 37 37 28 56 62 86 33 07 37 10 44 52 82 52 06 19 52 57 75 90 26 91 24 06 21 14 67 76 30 46 14 35 89 89 41 03 64 56 97 87 63 22 34 03 79 17 45 11 53 25 56 96 61 23 18 63 31 37 37 47
+77 23 26 70 72 76 77 04 28 64 71 69 14 85 96 54 95 48 06 62 99 83 86 77 97 75 71 66 30 19 57 90 33 01 60 61 14 12 90 99 32 77 56 41 18 14 87 49 10 14 90 64 18 50 21 74 14 16 88 05 45 73 82 47 74 44
+22 97 41 13 34 31 54 61 56 94 03 24 59 27 98 77 04 09 37 40 12 26 87 09 71 70 07 18 64 57 80 21 12 71 83 94 60 39 73 79 73 19 97 32 64 29 41 07 48 84 85 67 12 74 95 20 24 52 41 67 56 61 29 93 35 72 69
+72 23 63 66 01 11 07 30 52 56 95 16 65 26 83 90 50 74 60 18 16 48 43 77 37 11 99 98 30 94 91 26 62 73 45 12 87 73 47 27 01 88 66 99 21 41 95 80 02 53 23 32 61 48 32 43 43 83 14 66 95 91 19 81 80 67 25 88
+08 62 32 18 92 14 83 71 37 96 11 83 39 99 05 16 23 27 10 67 02 25 44 11 55 31 46 64 41 56 44 74 26 81 51 31 45 85 87 09 81 95 22 28 76 69 46 48 64 87 67 76 27 89 31 11 74 16 62 03 60 94 42 47 09 34 94 93 72
+56 18 90 18 42 17 42 32 14 86 06 53 33 95 99 35 29 15 44 20 49 59 25 54 34 59 84 21 23 54 35 90 78 16 93 13 37 88 54 19 86 67 68 55 66 84 65 42 98 37 87 56 33 28 58 38 28 38 66 27 52 21 81 15 08 22 97 32 85 27
+91 53 40 28 13 34 91 25 01 63 50 37 22 49 71 58 32 28 30 18 68 94 23 83 63 62 94 76 80 41 90 22 82 52 29 12 18 56 10 08 35 14 37 57 23 65 67 40 72 39 93 39 70 89 40 34 07 46 94 22 20 05 53 64 56 30 05 56 61 88 27
+23 95 11 12 37 69 68 24 66 10 87 70 43 50 75 07 62 41 83 58 95 93 89 79 45 39 02 22 05 22 95 43 62 11 68 29 17 40 26 44 25 71 87 16 70 85 19 25 59 94 90 41 41 80 61 70 55 60 84 33 95 76 42 63 15 09 03 40 38 12 03 32
+09 84 56 80 61 55 85 97 16 94 82 94 98 57 84 30 84 48 93 90 71 05 95 90 73 17 30 98 40 64 65 89 07 79 09 19 56 36 42 30 23 69 73 72 07 05 27 61 24 31 43 48 71 84 21 28 26 65 65 59 65 74 77 20 10 81 61 84 95 08 52 23 70
+47 81 28 09 98 51 67 64 35 51 59 36 92 82 77 65 80 24 72 53 22 07 27 10 21 28 30 22 48 82 80 48 56 20 14 43 18 25 50 95 90 31 77 08 09 48 44 80 90 22 93 45 82 17 13 96 25 26 08 73 34 99 06 49 24 06 83 51 40 14 15 10 25 01
+54 25 10 81 30 64 24 74 75 80 36 75 82 60 22 69 72 91 45 67 03 62 79 54 89 74 44 83 64 96 66 73 44 30 74 50 37 05 09 97 70 01 60 46 37 91 39 75 75 18 58 52 72 78 51 81 86 52 08 97 01 46 43 66 98 62 81 18 70 93 73 08 32 46 34
+96 80 82 07 59 71 92 53 19 20 88 66 03 26 26 10 24 27 50 82 94 73 63 08 51 33 22 45 19 13 58 33 90 15 22 50 36 13 55 06 35 47 82 52 33 61 36 27 28 46 98 14 73 20 73 32 16 26 80 53 47 66 76 38 94 45 02 01 22 52 47 96 64 58 52 39
+88 46 23 39 74 63 81 64 20 90 33 33 76 55 58 26 10 46 42 26 74 74 12 83 32 43 09 02 73 55 86 54 85 34 28 23 29 79 91 62 47 41 82 87 99 22 48 90 20 05 96 75 95 04 43 28 81 39 81 01 28 42 78 25 39 77 90 57 58 98 17 36 73 22 63 74 51
+29 39 74 94 95 78 64 24 38 86 63 87 93 06 70 92 22 16 80 64 29 52 20 27 23 50 14 13 87 15 72 96 81 22 08 49 72 30 70 24 79 31 16 64 59 21 89 34 96 91 48 76 43 53 88 01 57 80 23 81 90 79 58 01 80 87 17 99 86 90 72 63 32 69 14 28 88 69
+37 17 71 95 56 93 71 35 43 45 04 98 92 94 84 96 11 30 31 27 31 60 92 03 48 05 98 91 86 94 35 90 90 08 48 19 33 28 68 37 59 26 65 96 50 68 22 07 09 49 34 31 77 49 43 06 75 17 81 87 61 79 52 26 27 72 29 50 07 98 86 01 17 10 46 64 24 18 56
+51 30 25 94 88 85 79 91 40 33 63 84 49 67 98 92 15 26 75 19 82 05 18 78 65 93 61 48 91 43 59 41 70 51 22 15 92 81 67 91 46 98 11 11 65 31 66 10 98 65 83 21 05 56 05 98 73 67 46 74 69 34 08 30 05 52 07 98 32 95 30 94 65 50 24 63 28 81 99 57
+19 23 61 36 09 89 71 98 65 17 30 29 89 26 79 74 94 11 44 48 97 54 81 55 39 66 69 45 28 47 13 86 15 76 74 70 84 32 36 33 79 20 78 14 41 47 89 28 81 05 99 66 81 86 38 26 06 25 13 60 54 55 23 53 27 05 89 25 23 11 13 54 59 54 56 34 16 24 53 44 06
+13 40 57 72 21 15 60 08 04 19 11 98 34 45 09 97 86 71 03 15 56 19 15 44 97 31 90 04 87 87 76 08 12 30 24 62 84 28 12 85 82 53 99 52 13 94 06 65 97 86 09 50 94 68 69 74 30 67 87 94 63 07 78 27 80 36 69 41 06 92 32 78 37 82 30 05 18 87 99 72 19 99
+44 20 55 77 69 91 27 31 28 81 80 27 02 07 97 23 95 98 12 25 75 29 47 71 07 47 78 39 41 59 27 76 13 15 66 61 68 35 69 86 16 53 67 63 99 85 41 56 08 28 33 40 94 76 90 85 31 70 24 65 84 65 99 82 19 25 54 37 21 46 33 02 52 99 51 33 26 04 87 02 08 18 96
+54 42 61 45 91 06 64 79 80 82 32 16 83 63 42 49 19 78 65 97 40 42 14 61 49 34 04 18 25 98 59 30 82 72 26 88 54 36 21 75 03 88 99 53 46 51 55 78 22 94 34 40 68 87 84 25 30 76 25 08 92 84 42 61 40 38 09 99 40 23 29 39 46 55 10 90 35 84 56 70 63 23 91 39
+52 92 03 71 89 07 09 37 68 66 58 20 44 92 51 56 13 71 79 99 26 37 02 06 16 67 36 52 58 16 79 73 56 60 59 27 44 77 94 82 20 50 98 33 09 87 94 37 40 83 64 83 58 85 17 76 53 02 83 52 22 27 39 20 48 92 45 21 09 42 24 23 12 37 52 28 50 78 79 20 86 62 73 20 59
+54 96 80 15 91 90 99 70 10 09 58 90 93 50 81 99 54 38 36 10 30 11 35 84 16 45 82 18 11 97 36 43 96 79 97 65 40 48 23 19 17 31 64 52 65 65 37 32 65 76 99 79 34 65 79 27 55 33 03 01 33 27 61 28 66 08 04 70 49 46 48 83 01 45 19 96 13 81 14 21 31 79 93 85 50 05
+92 92 48 84 59 98 31 53 23 27 15 22 79 95 24 76 05 79 16 93 97 89 38 89 42 83 02 88 94 95 82 21 01 97 48 39 31 78 09 65 50 56 97 61 01 07 65 27 21 23 14 15 80 97 44 78 49 35 33 45 81 74 34 05 31 57 09 38 94 07 69 54 69 32 65 68 46 68 78 90 24 28 49 51 45 86 35
+41 63 89 76 87 31 86 09 46 14 87 82 22 29 47 16 13 10 70 72 82 95 48 64 58 43 13 75 42 69 21 12 67 13 64 85 58 23 98 09 37 76 05 22 31 12 66 50 29 99 86 72 45 25 10 28 19 06 90 43 29 31 67 79 46 25 74 14 97 35 76 37 65 46 23 82 06 22 30 76 93 66 94 17 96 13 20 72
+63 40 78 08 52 09 90 41 70 28 36 14 46 44 85 96 24 52 58 15 87 37 05 98 99 39 13 61 76 38 44 99 83 74 90 22 53 80 56 98 30 51 63 39 44 30 91 91 04 22 27 73 17 35 53 18 35 45 54 56 27 78 48 13 69 36 44 38 71 25 30 56 15 22 73 43 32 69 59 25 93 83 45 11 34 94 44 39 92
+12 36 56 88 13 96 16 12 55 54 11 47 19 78 17 17 68 81 77 51 42 55 99 85 66 27 81 79 93 42 65 61 69 74 14 01 18 56 12 01 58 37 91 22 42 66 83 25 19 04 96 41 25 45 18 69 96 88 36 93 10 12 98 32 44 83 83 04 72 91 04 27 73 07 34 37 71 60 59 31 01 54 54 44 96 93 83 36 04 45
+30 18 22 20 42 96 65 79 17 41 55 69 94 81 29 80 91 31 85 25 47 26 43 49 02 99 34 67 99 76 16 14 15 93 08 32 99 44 61 77 67 50 43 55 87 55 53 72 17 46 62 25 50 99 73 05 93 48 17 31 70 80 59 09 44 59 45 13 74 66 58 94 87 73 16 14 85 38 74 99 64 23 79 28 71 42 20 37 82 31 23
+51 96 39 65 46 71 56 13 29 68 53 86 45 33 51 49 12 91 21 21 76 85 02 17 98 15 46 12 60 21 88 30 92 83 44 59 42 50 27 88 46 86 94 73 45 54 23 24 14 10 94 21 20 34 23 51 04 83 99 75 90 63 60 16 22 33 83 70 11 32 10 50 29 30 83 46 11 05 31 17 86 42 49 01 44 63 28 60 07 78 95 40
+44 61 89 59 04 49 51 27 69 71 46 76 44 04 09 34 56 39 15 06 94 91 75 90 65 27 56 23 74 06 23 33 36 69 14 39 05 34 35 57 33 22 76 46 56 10 61 65 98 09 16 69 04 62 65 18 99 76 49 18 72 66 73 83 82 40 76 31 89 91 27 88 17 35 41 35 32 51 32 67 52 68 74 85 80 57 07 11 62 66 47 22 67
+65 37 19 97 26 17 16 24 24 17 50 37 64 82 24 36 32 11 68 34 69 31 32 89 79 93 96 68 49 90 14 23 04 04 67 99 81 74 70 74 36 96 68 09 64 39 88 35 54 89 96 58 66 27 88 97 32 14 06 35 78 20 71 06 85 66 57 02 58 91 72 05 29 56 73 48 86 52 09 93 22 57 79 42 12 01 31 68 17 59 63 76 07 77
+73 81 14 13 17 20 11 09 01 83 08 85 91 70 84 63 62 77 37 07 47 01 59 95 39 69 39 21 99 09 87 02 97 16 92 36 74 71 90 66 33 73 73 75 52 91 11 12 26 53 05 26 26 48 61 50 90 65 01 87 42 47 74 35 22 73 24 26 56 70 52 05 48 41 31 18 83 27 21 39 80 85 26 08 44 02 71 07 63 22 05 52 19 08 20
+17 25 21 11 72 93 33 49 64 23 53 82 03 13 91 65 85 02 40 05 42 31 77 42 05 36 06 54 04 58 07 76 87 83 25 57 66 12 74 33 85 37 74 32 20 69 03 97 91 68 82 44 19 14 89 28 85 85 80 53 34 87 58 98 88 78 48 65 98 40 11 57 10 67 70 81 60 79 74 72 97 59 79 47 30 20 54 80 89 91 14 05 33 36 79 39
+60 85 59 39 60 07 57 76 77 92 06 35 15 72 23 41 45 52 95 18 64 79 86 53 56 31 69 11 91 31 84 50 44 82 22 81 41 40 30 42 30 91 48 94 74 76 64 58 74 25 96 57 14 19 03 99 28 83 15 75 99 01 89 85 79 50 03 95 32 67 44 08 07 41 62 64 29 20 14 76 26 55 48 71 69 66 19 72 44 25 14 01 48 74 12 98 07
+64 66 84 24 18 16 27 48 20 14 47 69 30 86 48 40 23 16 61 21 51 50 26 47 35 33 91 28 78 64 43 68 04 79 51 08 19 60 52 95 06 68 46 86 35 97 27 58 04 65 30 58 99 12 12 75 91 39 50 31 42 64 70 04 46 07 98 73 98 93 37 89 77 91 64 71 64 65 66 21 78 62 81 74 42 20 83 70 73 95 78 45 92 27 34 53 71 15
+30 11 85 31 34 71 13 48 05 14 44 03 19 67 23 73 19 57 06 90 94 72 57 69 81 62 59 68 88 57 55 69 49 13 07 87 97 80 89 05 71 05 05 26 38 40 16 62 45 99 18 38 98 24 21 26 62 74 69 04 85 57 77 35 58 67 91 79 79 57 86 28 66 34 72 51 76 78 36 95 63 90 08 78 47 63 45 31 22 70 52 48 79 94 15 77 61 67 68
+23 33 44 81 80 92 93 75 94 88 23 61 39 76 22 03 28 94 32 06 49 65 41 34 18 23 08 47 62 60 03 63 33 13 80 52 31 54 73 43 70 26 16 69 57 87 83 31 03 93 70 81 47 95 77 44 29 68 39 51 56 59 63 07 25 70 07 77 43 53 64 03 94 42 95 39 18 01 66 21 16 97 20 50 90 16 70 10 95 69 29 06 25 61 41 26 15 59 63 35

From 030600f9b3c4f9265fcaed97ae81b41ad2d7f7f4 Mon Sep 17 00:00:00 2001
From: Christian Clauss <cclauss@me.com>
Date: Tue, 10 Sep 2019 07:49:07 +0200
Subject: [PATCH 209/348] Update matrix_class.py (#1175)

---
 matrix/matrix_class.py | 45 +++++++++++++++---------------------------
 1 file changed, 16 insertions(+), 29 deletions(-)

diff --git a/matrix/matrix_class.py b/matrix/matrix_class.py
index 2cd43fc9ca8e..c82fb2cf6464 100644
--- a/matrix/matrix_class.py
+++ b/matrix/matrix_class.py
@@ -102,15 +102,15 @@ class Matrix:
 
     def __init__(self, rows):
         error = TypeError(
-            "Matrices must be formed from a list of zero or more lists containing at least one and the same number of values, \
-                each of which must be of type int or float"
+            "Matrices must be formed from a list of zero or more lists containing at least "
+            "one and the same number of values, each of which must be of type int or float."
         )
         if len(rows) != 0:
             cols = len(rows[0])
             if cols == 0:
                 raise error
             for row in rows:
-                if not len(row) == cols:
+                if len(row) != cols:
                     raise error
                 for value in row:
                     if not isinstance(value, (int, float)):
@@ -137,9 +137,7 @@ def order(self):
 
     @property
     def is_square(self):
-        if self.order[0] == self.order[1]:
-            return True
-        return False
+        return self.order[0] == self.order[1]
 
     def identity(self):
         values = [
@@ -168,9 +166,7 @@ def determinant(self):
             )
 
     def is_invertable(self):
-        if self.determinant():
-            return True
-        return False
+        return bool(self.determinant())
 
     def get_minor(self, row, column):
         values = [
@@ -218,9 +214,8 @@ def adjugate(self):
         return Matrix(values)
 
     def inverse(self):
-        if not self.is_invertable():
-            return None
-        return self.adjugate() * (1 / self.determinant())
+        determinant = self.determinant()
+        return None if not determinant else self.adjugate() * (1 / determinant)
 
     def __repr__(self):
         return str(self.rows)
@@ -283,14 +278,10 @@ def add_column(self, column, position=None):
     def __eq__(self, other):
         if not isinstance(other, Matrix):
             raise TypeError("A Matrix can only be compared with another Matrix")
-        if self.rows == other.rows:
-            return True
-        return False
+        return self.rows == other.rows
 
     def __ne__(self, other):
-        if self == other:
-            return False
-        return True
+        return not self == other
 
     def __neg__(self):
         return self * -1
@@ -316,23 +307,20 @@ def __sub__(self, other):
         )
 
     def __mul__(self, other):
-        if not isinstance(other, (int, float, Matrix)):
-            raise TypeError(
-                "A Matrix can only be multiplied by an int, float, or another matrix"
-            )
-        if type(other) in (int, float):
+        if isinstance(other, (int, float)):
             return Matrix([[element * other for element in row] for row in self.rows])
-        if type(other) is Matrix:
+        elif isinstance(other, Matrix):
             if self.num_columns != other.num_rows:
-                raise ValueError(
-                    "The number of columns in the first matrix must be equal to the number of rows in the second"
-                )
+                raise ValueError("The number of columns in the first matrix must "
+                                 "be equal to the number of rows in the second")
             return Matrix(
                 [
                     [Matrix.dot_product(row, column) for column in other.columns()]
                     for row in self.rows
                 ]
             )
+        else:
+            raise TypeError("A Matrix can only be multiplied by an int, float, or another matrix")
 
     def __pow__(self, other):
         if not isinstance(other, int):
@@ -360,5 +348,4 @@ def dot_product(cls, row, column):
 if __name__ == "__main__":
     import doctest
 
-    test = doctest.testmod()
-    print(test)
+    doctest.testmod()

From 47d17951b830f23fe7cddffa9c24431c29cfea74 Mon Sep 17 00:00:00 2001
From: Kiril Bangachev <51961981+KirilBangachev@users.noreply.github.com>
Date: Fri, 13 Sep 2019 07:13:55 -0400
Subject: [PATCH 210/348] Add Kth lexicographic permutation (#1179)

* Add Kth lexicographic permutation

Function that computes the kth lexicographic permtation of 0,1,2,...,n-1 in O(n^2) time

* Update kth_lexicographic_permutation.py

Addressed requested changes
---
 maths/kth_lexicographic_permutation.py | 40 ++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)
 create mode 100644 maths/kth_lexicographic_permutation.py

diff --git a/maths/kth_lexicographic_permutation.py b/maths/kth_lexicographic_permutation.py
new file mode 100644
index 000000000000..1820be7274e3
--- /dev/null
+++ b/maths/kth_lexicographic_permutation.py
@@ -0,0 +1,40 @@
+def kthPermutation(k, n):
+    """
+        Finds k'th lexicographic permutation (in increasing order) of 
+        0,1,2,...n-1 in O(n^2) time.
+        
+        Examples:
+        First permutation is always 0,1,2,...n
+        >>> kthPermutation(0,5)
+        [0, 1, 2, 3, 4]
+        
+        The order of permutation of 0,1,2,3 is [0,1,2,3], [0,1,3,2], [0,2,1,3],
+        [0,2,3,1], [0,3,1,2], [0,3,2,1], [1,0,2,3], [1,0,3,2], [1,2,0,3], 
+        [1,2,3,0], [1,3,0,2]
+        >>> kthPermutation(10,4)
+        [1, 3, 0, 2]
+    """
+    # Factorails from 1! to (n-1)!
+    factorials = [1]
+    for i in range(2, n):
+        factorials.append(factorials[-1] * i)
+    assert 0 <= k < factorials[-1] * n, "k out of bounds"
+
+    permutation = []
+    elements = list(range(n))
+
+    # Find permutation
+    while factorials:
+        factorial = factorials.pop()
+        number, k = divmod(k, factorial)
+        permutation.append(elements[number])
+        elements.remove(elements[number])
+    permutation.append(elements[0])
+
+    return permutation
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()

From f8e30cfab1863b4f76415956ee1f10d606c50674 Mon Sep 17 00:00:00 2001
From: "Marvin M. Michum" <mrvnmchm@gmail.com>
Date: Fri, 13 Sep 2019 07:40:14 -0400
Subject: [PATCH 211/348] Digital Image Processing Tests (#1178)

* add version of smaller image

* swap image in tests

* edits for image src
---
 .../image_data/lena_small.jpg                    | Bin 0 -> 6971 bytes
 .../test_digital_image_processing.py             |   8 ++++----
 2 files changed, 4 insertions(+), 4 deletions(-)
 create mode 100644 digital_image_processing/image_data/lena_small.jpg

diff --git a/digital_image_processing/image_data/lena_small.jpg b/digital_image_processing/image_data/lena_small.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..b85144e9f65ca0c115c41e79a6c29c24aa9a322d
GIT binary patch
literal 6971
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
Hxt{+YSh(6Q

literal 0
HcmV?d00001

diff --git a/digital_image_processing/test_digital_image_processing.py b/digital_image_processing/test_digital_image_processing.py
index 0ff9e3333ca8..02c1a2d3a663 100644
--- a/digital_image_processing/test_digital_image_processing.py
+++ b/digital_image_processing/test_digital_image_processing.py
@@ -12,15 +12,15 @@
 from numpy import array, uint8
 from PIL import Image
 
-img = imread(r"digital_image_processing/image_data/lena.jpg")
+img = imread(r"digital_image_processing/image_data/lena_small.jpg")
 gray = cvtColor(img, COLOR_BGR2GRAY)
 
 # Test: change_contrast()
 def test_change_contrast():
-    with Image.open("digital_image_processing/image_data/lena.jpg") as img:
+    with Image.open("digital_image_processing/image_data/lena_small.jpg") as img:
         # Work around assertion for response
         assert str(cc.change_contrast(img, 110)).startswith(
-            "<PIL.Image.Image image mode=RGB size=512x512 at"
+            "<PIL.Image.Image image mode=RGB size=100x100 at"
         )
 
 
@@ -33,7 +33,7 @@ def test_gen_gaussian_kernel():
 
 # canny.py
 def test_canny():
-    canny_img = imread("digital_image_processing/image_data/lena.jpg", 0)
+    canny_img = imread("digital_image_processing/image_data/lena_small.jpg", 0)
     # assert ambiguos array for all == True
     assert canny_img.all()
     canny_array = canny.canny(canny_img)

From 6fa3c0b1701bc4b4a594e6b2ada335acefc12076 Mon Sep 17 00:00:00 2001
From: PatOnTheBack <51241310+PatOnTheBack@users.noreply.github.com>
Date: Fri, 13 Sep 2019 12:07:24 +0000
Subject: [PATCH 212/348] Add Flake8 F4 Tests to .travis.yml (#974)

* Add Flake8 F4 Tests to .travis.yml

F4 tests check for import errors. Implements issue #973

* Remove wildcard imports
---
 .travis.yml                 | 2 +-
 linear_algebra/src/tests.py | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index f7a9264803f8..be227df1fdbd 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -6,7 +6,7 @@ before_install: pip install --upgrade pip setuptools
 install: pip install -r requirements.txt
 before_script:
   - black --check . || true
-  - flake8 . --count --select=E9,F401,F63,F7,F82 --show-source --statistics
+  - flake8 . --count --select=E9,F4,F63,F7,F82 --show-source --statistics
 script:
   - scripts/validate_filenames.py  # no uppercase, no spaces, in a directory
   - mypy --ignore-missing-imports .
diff --git a/linear_algebra/src/tests.py b/linear_algebra/src/tests.py
index a26eb92653e2..afca4ce87117 100644
--- a/linear_algebra/src/tests.py
+++ b/linear_algebra/src/tests.py
@@ -9,7 +9,7 @@
 """
 
 import unittest
-from lib import *
+from lib import Matrix, Vector, axpy, squareZeroMatrix, unitBasisVector, zeroVector
 
 class Test(unittest.TestCase):
     def test_component(self):

From 768700b91f85b21fbb422d9deba6bb69d320e18d Mon Sep 17 00:00:00 2001
From: Sangeet K <sangeethk.137@gmail.com>
Date: Fri, 13 Sep 2019 13:24:25 -0700
Subject: [PATCH 213/348] Add delete to trie.py + tests (#1177)

* Add delete to trie.py + tests

* Minor fixes + tests

* Remove noqa comments + modify tests for Travis CI to detect

* Minor improvement
---
 data_structures/trie/trie.py | 84 +++++++++++++++++++++++++++++-------
 1 file changed, 68 insertions(+), 16 deletions(-)

diff --git a/data_structures/trie/trie.py b/data_structures/trie/trie.py
index b6234c6704c6..5a560b97c293 100644
--- a/data_structures/trie/trie.py
+++ b/data_structures/trie/trie.py
@@ -1,9 +1,8 @@
 """
 A Trie/Prefix Tree is a kind of search tree used to provide quick lookup
 of words/patterns in a set of words. A basic Trie however has O(n^2) space complexity
-making it impractical in practice. It however provides O(max(search_string, length of longest word)) lookup
-time making it an optimal approach when space is not an issue.
-
+making it impractical in practice. It however provides O(max(search_string, length of longest word)) 
+lookup time making it an optimal approach when space is not an issue.
 """
 
 
@@ -12,7 +11,7 @@ def __init__(self):
         self.nodes = dict()  # Mapping from char to TrieNode
         self.is_leaf = False
 
-    def insert_many(self, words: [str]):  # noqa: E999 This syntax is Python 3 only
+    def insert_many(self, words: [str]):
         """
         Inserts a list of words into the Trie
         :param words: list of string words
@@ -21,7 +20,7 @@ def insert_many(self, words: [str]):  # noqa: E999 This syntax is Python 3 only
         for word in words:
             self.insert(word)
 
-    def insert(self, word: str):  # noqa: E999 This syntax is Python 3 only
+    def insert(self, word: str):
         """
         Inserts a word into the Trie
         :param word: word to be inserted
@@ -34,7 +33,7 @@ def insert(self, word: str):  # noqa: E999 This syntax is Python 3 only
             curr = curr.nodes[char]
         curr.is_leaf = True
 
-    def find(self, word: str) -> bool:  # noqa: E999 This syntax is Python 3 only
+    def find(self, word: str) -> bool:
         """
         Tries to find word in a Trie
         :param word: word to look for
@@ -47,8 +46,36 @@ def find(self, word: str) -> bool:  # noqa: E999 This syntax is Python 3 only
             curr = curr.nodes[char]
         return curr.is_leaf
 
+    def delete(self, word: str):
+        """
+        Deletes a word in a Trie
+        :param word: word to delete
+        :return: None
+        """
 
-def print_words(node: TrieNode, word: str):  # noqa: E999 This syntax is Python 3 only
+        def _delete(curr: TrieNode, word: str, index: int):
+            if index == len(word):
+                # If word does not exist
+                if not curr.is_leaf:
+                    return False
+                curr.is_leaf = False
+                return len(curr.nodes) == 0
+            char = word[index]
+            char_node = curr.nodes.get(char)
+            # If char not in current trie node
+            if not char_node:
+                return False
+            # Flag to check if node can be deleted
+            delete_curr = _delete(char_node, word, index + 1)
+            if delete_curr:
+                del curr.nodes[char]
+                return len(curr.nodes) == 0
+            return delete_curr
+
+        _delete(self, word, 0)
+
+
+def print_words(node: TrieNode, word: str):
     """
     Prints all the words in a Trie
     :param node: root node of Trie
@@ -56,20 +83,45 @@ def print_words(node: TrieNode, word: str):  # noqa: E999 This syntax is Python
     :return: None
     """
     if node.is_leaf:
-        print(word, end=' ')
+        print(word, end=" ")
 
     for key, value in node.nodes.items():
         print_words(value, word + key)
 
 
-def test():
-    words = ['banana', 'bananas', 'bandana', 'band', 'apple', 'all', 'beast']
+def test_trie():
+    words = "banana bananas bandana band apple all beast".split()
     root = TrieNode()
     root.insert_many(words)
-    # print_words(root, '')
-    assert root.find('banana')
-    assert not root.find('bandanas')
-    assert not root.find('apps')
-    assert root.find('apple')
+    # print_words(root, "")
+    assert all(root.find(word) for word in words)
+    assert root.find("banana")
+    assert not root.find("bandanas")
+    assert not root.find("apps")
+    assert root.find("apple")
+    assert root.find("all")
+    root.delete("all")
+    assert not root.find("all")
+    root.delete("banana")
+    assert not root.find("banana")
+    assert root.find("bananas")
+    return True
+
+
+def print_results(msg: str, passes: bool) -> None:
+    print(str(msg), "works!" if passes else "doesn't work :(")
+
+
+def pytests():
+    assert test_trie()
+
+
+def main():
+    """
+    >>> pytests()
+    """
+    print_results("Testing trie functionality", test_trie())
+
 
-test()
+if __name__ == "__main__":
+    main()

From a2b5a90c11ad07f82432fe4b96f6f17bed40e6c8 Mon Sep 17 00:00:00 2001
From: BAKEZQ <zhongquan789@gmail.com>
Date: Wed, 18 Sep 2019 22:01:05 +0800
Subject: [PATCH 214/348] Added sequential minimum optimization algorithm for
 SVM (#508)

* Implementation of sequential minimal optimization algorithm

* Update smo.py

* Add demonstration of svm partition boundary

1:Use matplotlib show svm's partition boundary
2:Automatically download test dataset

* Update smo.py

* Update smo.py

* Rename smo.py to sequential_minimum_optimization.py

* Update doc and simplify the code.

Fix filename typo error in doc.
Use ternary conditional operator in predict()

* Update doc.
---
 .../sequential_minimum_optimization.py        | 526 ++++++++++++++++++
 1 file changed, 526 insertions(+)
 create mode 100644 machine_learning/sequential_minimum_optimization.py

diff --git a/machine_learning/sequential_minimum_optimization.py b/machine_learning/sequential_minimum_optimization.py
new file mode 100644
index 000000000000..0b5d788e92e1
--- /dev/null
+++ b/machine_learning/sequential_minimum_optimization.py
@@ -0,0 +1,526 @@
+# coding: utf-8
+"""
+    Implementation of sequential minimal optimization(SMO) for support vector machines(SVM).
+
+    Sequential minimal optimization (SMO) is an algorithm for solving the quadratic programming (QP) problem
+    that arises during the training of support vector machines.
+    It was invented by John Platt in 1998.
+
+Input:
+    0: type: numpy.ndarray.
+    1: first column of ndarray must be tags of samples, must be 1 or -1.
+    2: rows of ndarray represent samples.
+
+Usage:
+    Command:
+        python3 sequential_minimum_optimization.py
+    Code:
+        from sequential_minimum_optimization import SmoSVM, Kernel
+
+        kernel = Kernel(kernel='poly', degree=3., coef0=1., gamma=0.5)
+        init_alphas = np.zeros(train.shape[0])
+        SVM = SmoSVM(train=train, alpha_list=init_alphas, kernel_func=kernel, cost=0.4, b=0.0, tolerance=0.001)
+        SVM.fit()
+        predict = SVM.predict(test_samples)
+
+Reference:
+    https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/smo-book.pdf
+    https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/tr-98-14.pdf
+    http://web.cs.iastate.edu/~honavar/smo-svm.pdf
+"""
+
+from __future__ import division
+
+import os
+import sys
+import urllib.request
+
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+from sklearn.datasets import make_blobs, make_circles
+from sklearn.preprocessing import StandardScaler
+
+CANCER_DATASET_URL = 'http://archive.ics.uci.edu/ml/machine-learning-databases/breast-cancer-wisconsin/wdbc.data'
+
+
+class SmoSVM(object):
+    def __init__(self, train, kernel_func, alpha_list=None, cost=0.4, b=0.0, tolerance=0.001, auto_norm=True):
+        self._init = True
+        self._auto_norm = auto_norm
+        self._c = np.float64(cost)
+        self._b = np.float64(b)
+        self._tol = np.float64(tolerance) if tolerance > 0.0001 else np.float64(0.001)
+
+        self.tags = train[:, 0]
+        self.samples = self._norm(train[:, 1:]) if self._auto_norm else train[:, 1:]
+        self.alphas = alpha_list if alpha_list is not None else np.zeros(train.shape[0])
+        self.Kernel = kernel_func
+
+        self._eps = 0.001
+        self._all_samples = list(range(self.length))
+        self._K_matrix = self._calculate_k_matrix()
+        self._error = np.zeros(self.length)
+        self._unbound = []
+
+        self.choose_alpha = self._choose_alphas()
+
+    # Calculate alphas using SMO algorithsm
+    def fit(self):
+        K = self._k
+        state = None
+        while True:
+
+            # 1: Find alpha1, alpha2
+            try:
+                i1, i2 = self.choose_alpha.send(state)
+                state = None
+            except StopIteration:
+                print("Optimization done!\r\nEvery sample satisfy the KKT condition!")
+                break
+
+            # 2: calculate new alpha2 and new alpha1
+            y1, y2 = self.tags[i1], self.tags[i2]
+            a1, a2 = self.alphas[i1].copy(), self.alphas[i2].copy()
+            e1, e2 = self._e(i1), self._e(i2)
+            args = (i1, i2, a1, a2, e1, e2, y1, y2)
+            a1_new, a2_new = self._get_new_alpha(*args)
+            if not a1_new and not a2_new:
+                state = False
+                continue
+            self.alphas[i1], self.alphas[i2] = a1_new, a2_new
+
+            # 3: update threshold(b)
+            b1_new = np.float64(-e1 - y1 * K(i1, i1) * (a1_new - a1) - y2 * K(i2, i1) * (a2_new - a2) + self._b)
+            b2_new = np.float64(-e2 - y2 * K(i2, i2) * (a2_new - a2) - y1 * K(i1, i2) * (a1_new - a1) + self._b)
+            if 0.0 < a1_new < self._c:
+                b = b1_new
+            if 0.0 < a2_new < self._c:
+                b = b2_new
+            if not (np.float64(0) < a2_new < self._c) and not (np.float64(0) < a1_new < self._c):
+                b = (b1_new + b2_new) / 2.0
+            b_old = self._b
+            self._b = b
+
+            # 4:  update error value,here we only calculate those non-bound samples' error
+            self._unbound = [i for i in self._all_samples if self._is_unbound(i)]
+            for s in self.unbound:
+                if s == i1 or s == i2:
+                    continue
+                self._error[s] += y1 * (a1_new - a1) * K(i1, s) + y2 * (a2_new - a2) * K(i2, s) + (self._b - b_old)
+
+            # if i1 or i2 is non-bound,update there error value to zero
+            if self._is_unbound(i1):
+                self._error[i1] = 0
+            if self._is_unbound(i2):
+                self._error[i2] = 0
+
+    # Predict test samles
+    def predict(self, test_samples, classify=True):
+
+        if test_samples.shape[1] > self.samples.shape[1]:
+            raise ValueError("Test samples' feature length does not equal to that of train samples")
+
+        if self._auto_norm:
+            test_samples = self._norm(test_samples)
+
+        results = []
+        for test_sample in test_samples:
+            result = self._predict(test_sample)
+            if classify:
+                results.append(1 if result > 0 else -1)
+            else:
+                results.append(result)
+        return np.array(results)
+
+    # Check if alpha violate KKT condition
+    def _check_obey_kkt(self, index):
+        alphas = self.alphas
+        tol = self._tol
+        r = self._e(index) * self.tags[index]
+        c = self._c
+
+        return (r < -tol and alphas[index] < c) or (r > tol and alphas[index] > 0.0)
+
+    # Get value calculated from kernel function
+    def _k(self, i1, i2):
+        # for test samples,use Kernel function
+        if isinstance(i2, np.ndarray):
+            return self.Kernel(self.samples[i1], i2)
+        # for train samples,Kernel values have been saved in matrix
+        else:
+            return self._K_matrix[i1, i2]
+
+    # Get sample's error
+    def _e(self, index):
+        """
+        Two cases:
+            1:Sample[index] is non-bound,Fetch error from list: _error
+            2:sample[index] is bound,Use predicted value deduct true value: g(xi) - yi
+
+        """
+        # get from error data
+        if self._is_unbound(index):
+            return self._error[index]
+        # get by g(xi) - yi
+        else:
+            gx = np.dot(self.alphas * self.tags, self._K_matrix[:, index]) + self._b
+            yi = self.tags[index]
+            return gx - yi
+
+    # Calculate Kernel matrix of all possible i1,i2 ,saving time
+    def _calculate_k_matrix(self):
+        k_matrix = np.zeros([self.length, self.length])
+        for i in self._all_samples:
+            for j in self._all_samples:
+                k_matrix[i, j] = np.float64(self.Kernel(self.samples[i, :], self.samples[j, :]))
+        return k_matrix
+
+    # Predict test sample's tag
+    def _predict(self, sample):
+        k = self._k
+        predicted_value = np.sum(
+            [self.alphas[i1] * self.tags[i1] * k(i1, sample) for i1 in self._all_samples]) + self._b
+        return predicted_value
+
+    # Choose alpha1 and alpha2
+    def _choose_alphas(self):
+        locis = yield from self._choose_a1()
+        if not locis:
+            return
+        return locis
+
+    def _choose_a1(self):
+        """
+        Choose first alpha ;steps:
+           1:Fisrt loop over all sample
+           2:Second loop over all non-bound samples till all non-bound samples does not voilate kkt condition.
+           3:Repeat this two process endlessly,till all samples does not voilate kkt condition samples after first loop.
+        """
+        while True:
+            all_not_obey = True
+            # all sample
+            print('scanning all sample!')
+            for i1 in [i for i in self._all_samples if self._check_obey_kkt(i)]:
+                all_not_obey = False
+                yield from self._choose_a2(i1)
+
+            # non-bound sample
+            print('scanning non-bound sample!')
+            while True:
+                not_obey = True
+                for i1 in [i for i in self._all_samples if self._check_obey_kkt(i) and self._is_unbound(i)]:
+                    not_obey = False
+                    yield from self._choose_a2(i1)
+                if not_obey:
+                    print('all non-bound samples fit the KKT condition!')
+                    break
+            if all_not_obey:
+                print('all samples fit the KKT condition! Optimization done!')
+                break
+        return False
+
+    def _choose_a2(self, i1):
+        """
+        Choose the second alpha by using heuristic algorithm ;steps:
+           1:Choosed alpha2 which get the maximum step size (|E1 - E2|).
+           2:Start in a random point,loop over all non-bound samples till alpha1 and alpha2 are optimized.
+           3:Start in a random point,loop over all samples till alpha1 and alpha2 are optimized.
+        """
+        self._unbound = [i for i in self._all_samples if self._is_unbound(i)]
+
+        if len(self.unbound) > 0:
+            tmp_error = self._error.copy().tolist()
+            tmp_error_dict = {index: value for index, value in enumerate(tmp_error) if self._is_unbound(index)}
+            if self._e(i1) >= 0:
+                i2 = min(tmp_error_dict, key=lambda index: tmp_error_dict[index])
+            else:
+                i2 = max(tmp_error_dict, key=lambda index: tmp_error_dict[index])
+            cmd = yield i1, i2
+            if cmd is None:
+                return
+
+        for i2 in np.roll(self.unbound, np.random.choice(self.length)):
+            cmd = yield i1, i2
+            if cmd is None:
+                return
+
+        for i2 in np.roll(self._all_samples, np.random.choice(self.length)):
+            cmd = yield i1, i2
+            if cmd is None:
+                return
+
+    # Get the new alpha2 and new alpha1
+    def _get_new_alpha(self, i1, i2, a1, a2, e1, e2, y1, y2):
+        K = self._k
+        if i1 == i2:
+            return None, None
+
+        # calculate L and H  which bound the new alpha2
+        s = y1 * y2
+        if s == -1:
+            L, H = max(0.0, a2 - a1), min(self._c, self._c + a2 - a1)
+        else:
+            L, H = max(0.0, a2 + a1 - self._c), min(self._c, a2 + a1)
+        if L == H:
+            return None, None
+
+        # calculate eta
+        k11 = K(i1, i1)
+        k22 = K(i2, i2)
+        k12 = K(i1, i2)
+        eta = k11 + k22 - 2.0 * k12
+
+        # select the new alpha2 which could get the minimal objectives
+        if eta > 0.0:
+            a2_new_unc = a2 + (y2 * (e1 - e2)) / eta
+            # a2_new has a boundry
+            if a2_new_unc >= H:
+                a2_new = H
+            elif a2_new_unc <= L:
+                a2_new = L
+            else:
+                a2_new = a2_new_unc
+        else:
+            b = self._b
+            l1 = a1 + s * (a2 - L)
+            h1 = a1 + s * (a2 - H)
+
+            # way 1
+            f1 = y1 * (e1 + b) - a1 * K(i1, i1) - s * a2 * K(i1, i2)
+            f2 = y2 * (e2 + b) - a2 * K(i2, i2) - s * a1 * K(i1, i2)
+            ol = l1 * f1 + L * f2 + 1 / 2 * l1 ** 2 * K(i1, i1) + 1 / 2 * L ** 2 * K(i2, i2) + s * L * l1 * K(i1, i2)
+            oh = h1 * f1 + H * f2 + 1 / 2 * h1 ** 2 * K(i1, i1) + 1 / 2 * H ** 2 * K(i2, i2) + s * H * h1 * K(i1, i2)
+            """
+            # way 2
+            Use objective function check which alpha2 new could get the minimal objectives
+
+            """
+            if ol < (oh - self._eps):
+                a2_new = L
+            elif ol > oh + self._eps:
+                a2_new = H
+            else:
+                a2_new = a2
+
+        # a1_new has a boundry too
+        a1_new = a1 + s * (a2 - a2_new)
+        if a1_new < 0:
+            a2_new += s * a1_new
+            a1_new = 0
+        if a1_new > self._c:
+            a2_new += s * (a1_new - self._c)
+            a1_new = self._c
+
+        return a1_new, a2_new
+
+    # Normalise data using min_max way
+    def _norm(self, data):
+        if self._init:
+            self._min = np.min(data, axis=0)
+            self._max = np.max(data, axis=0)
+            self._init = False
+            return (data - self._min) / (self._max - self._min)
+        else:
+            return (data - self._min) / (self._max - self._min)
+
+    def _is_unbound(self, index):
+        if 0.0 < self.alphas[index] < self._c:
+            return True
+        else:
+            return False
+
+    def _is_support(self, index):
+        if self.alphas[index] > 0:
+            return True
+        else:
+            return False
+
+    @property
+    def unbound(self):
+        return self._unbound
+
+    @property
+    def support(self):
+        return [i for i in range(self.length) if self._is_support(i)]
+
+    @property
+    def length(self):
+        return self.samples.shape[0]
+
+
+class Kernel(object):
+    def __init__(self, kernel, degree=1.0, coef0=0.0, gamma=1.0):
+        self.degree = np.float64(degree)
+        self.coef0 = np.float64(coef0)
+        self.gamma = np.float64(gamma)
+        self._kernel_name = kernel
+        self._kernel = self._get_kernel(kernel_name=kernel)
+        self._check()
+
+    def _polynomial(self, v1, v2):
+        return (self.gamma * np.inner(v1, v2) + self.coef0) ** self.degree
+
+    def _linear(self, v1, v2):
+        return np.inner(v1, v2) + self.coef0
+
+    def _rbf(self, v1, v2):
+        return np.exp(-1 * (self.gamma * np.linalg.norm(v1 - v2) ** 2))
+
+    def _check(self):
+        if self._kernel == self._rbf:
+            if self.gamma < 0:
+                raise ValueError('gamma value must greater than 0')
+
+    def _get_kernel(self, kernel_name):
+        maps = {
+            'linear': self._linear,
+            'poly': self._polynomial,
+            'rbf': self._rbf
+        }
+        return maps[kernel_name]
+
+    def __call__(self, v1, v2):
+        return self._kernel(v1, v2)
+
+    def __repr__(self):
+        return self._kernel_name
+
+
+def count_time(func):
+    def call_func(*args, **kwargs):
+        import time
+        start_time = time.time()
+        func(*args, **kwargs)
+        end_time = time.time()
+        print('smo algorithm cost {} seconds'.format(end_time - start_time))
+
+    return call_func
+
+
+@count_time
+def test_cancel_data():
+    print('Hello!\r\nStart test svm by smo algorithm!')
+    # 0: download dataset and load into pandas' dataframe
+    if not os.path.exists(r'cancel_data.csv'):
+        request = urllib.request.Request(
+            CANCER_DATASET_URL,
+            headers={'User-Agent': 'Mozilla/4.0 (compatible; MSIE 5.5; Windows NT)'}
+        )
+        response = urllib.request.urlopen(request)
+        content = response.read().decode('utf-8')
+        with open(r'cancel_data.csv', 'w') as f:
+            f.write(content)
+
+    data = pd.read_csv(r'cancel_data.csv', header=None)
+
+    # 1: pre-processing data
+    del data[data.columns.tolist()[0]]
+    data = data.dropna(axis=0)
+    data = data.replace({'M': np.float64(1), 'B': np.float64(-1)})
+    samples = np.array(data)[:, :]
+
+    # 2: deviding data into train_data data and test_data data
+    train_data, test_data = samples[:328, :], samples[328:, :]
+    test_tags, test_samples = test_data[:, 0], test_data[:, 1:]
+
+    # 3: choose kernel function,and set initial alphas to zero(optional)
+    mykernel = Kernel(kernel='rbf', degree=5, coef0=1, gamma=0.5)
+    al = np.zeros(train_data.shape[0])
+
+    # 4: calculating best alphas using SMO algorithm and predict test_data samples
+    mysvm = SmoSVM(train=train_data, kernel_func=mykernel, alpha_list=al, cost=0.4, b=0.0, tolerance=0.001)
+    mysvm.fit()
+    predict = mysvm.predict(test_samples)
+
+    # 5: check accuracy
+    score = 0
+    test_num = test_tags.shape[0]
+    for i in range(test_tags.shape[0]):
+        if test_tags[i] == predict[i]:
+            score += 1
+    print('\r\nall: {}\r\nright: {}\r\nfalse: {}'.format(test_num, score, test_num - score))
+    print("Rough Accuracy: {}".format(score / test_tags.shape[0]))
+
+
+def test_demonstration():
+    # change stdout
+    print('\r\nStart plot,please wait!!!')
+    sys.stdout = open(os.devnull, 'w')
+
+    ax1 = plt.subplot2grid((2, 2), (0, 0))
+    ax2 = plt.subplot2grid((2, 2), (0, 1))
+    ax3 = plt.subplot2grid((2, 2), (1, 0))
+    ax4 = plt.subplot2grid((2, 2), (1, 1))
+    ax1.set_title("linear svm,cost:0.1")
+    test_linear_kernel(ax1, cost=0.1)
+    ax2.set_title("linear svm,cost:500")
+    test_linear_kernel(ax2, cost=500)
+    ax3.set_title("rbf kernel svm,cost:0.1")
+    test_rbf_kernel(ax3, cost=0.1)
+    ax4.set_title("rbf kernel svm,cost:500")
+    test_rbf_kernel(ax4, cost=500)
+
+    sys.stdout = sys.__stdout__
+    print("Plot done!!!")
+
+def test_linear_kernel(ax, cost):
+    train_x, train_y = make_blobs(n_samples=500, centers=2,
+                                  n_features=2, random_state=1)
+    train_y[train_y == 0] = -1
+    scaler = StandardScaler()
+    train_x_scaled = scaler.fit_transform(train_x, train_y)
+    train_data = np.hstack((train_y.reshape(500, 1), train_x_scaled))
+    mykernel = Kernel(kernel='linear', degree=5, coef0=1, gamma=0.5)
+    mysvm = SmoSVM(train=train_data, kernel_func=mykernel, cost=cost, tolerance=0.001, auto_norm=False)
+    mysvm.fit()
+    plot_partition_boundary(mysvm, train_data, ax=ax)
+
+
+def test_rbf_kernel(ax, cost):
+    train_x, train_y = make_circles(n_samples=500, noise=0.1, factor=0.1, random_state=1)
+    train_y[train_y == 0] = -1
+    scaler = StandardScaler()
+    train_x_scaled = scaler.fit_transform(train_x, train_y)
+    train_data = np.hstack((train_y.reshape(500, 1), train_x_scaled))
+    mykernel = Kernel(kernel='rbf', degree=5, coef0=1, gamma=0.5)
+    mysvm = SmoSVM(train=train_data, kernel_func=mykernel, cost=cost, tolerance=0.001, auto_norm=False)
+    mysvm.fit()
+    plot_partition_boundary(mysvm, train_data, ax=ax)
+
+
+def plot_partition_boundary(model, train_data, ax, resolution=100, colors=('b', 'k', 'r')):
+    """
+    We can not get the optimum w of our kernel svm model which is different from linear svm.
+    For this reason, we generate randomly destributed points with high desity and prediced values of these points are
+    calculated by using our tained model. Then we could use this prediced values to draw contour map.
+    And this contour map can represent svm's partition boundary.
+
+    """
+    train_data_x = train_data[:, 1]
+    train_data_y = train_data[:, 2]
+    train_data_tags = train_data[:, 0]
+    xrange = np.linspace(train_data_x.min(), train_data_x.max(), resolution)
+    yrange = np.linspace(train_data_y.min(), train_data_y.max(), resolution)
+    test_samples = np.array([(x, y) for x in xrange for y in yrange]).reshape(resolution * resolution, 2)
+
+    test_tags = model.predict(test_samples, classify=False)
+    grid = test_tags.reshape((len(xrange), len(yrange)))
+
+    # Plot contour map which represents the partition boundary
+    ax.contour(xrange, yrange, np.mat(grid).T, levels=(-1, 0, 1), linestyles=('--', '-', '--'),
+               linewidths=(1, 1, 1),
+               colors=colors)
+    # Plot all train samples
+    ax.scatter(train_data_x, train_data_y, c=train_data_tags, cmap=plt.cm.Dark2, lw=0, alpha=0.5)
+
+    # Plot support vectors
+    support = model.support
+    ax.scatter(train_data_x[support], train_data_y[support], c=train_data_tags[support], cmap=plt.cm.Dark2)
+
+
+if __name__ == '__main__':
+    test_cancel_data()
+    test_demonstration()
+    plt.show()
+

From 04962c0d17b82f349e0453b06b76d9f594e2b024 Mon Sep 17 00:00:00 2001
From: Denis Trofimov <silaradost@yandex.ru>
Date: Sat, 21 Sep 2019 17:23:34 +0300
Subject: [PATCH 215/348] Fix lgtm error display #1024 (#1190)

* fix: Syntax Error lgtm display in matrix/matrix_operation.py.

* Testing for None should use the 'is' operator.

* fix: Too many arguments for string format.

* fix: supress lgtm alert as false positive.

* style: Unnecessary 'pass' statement.

* Revert "fix: Syntax Error lgtm display in matrix/matrix_operation.py."

This reverts commit 4c629b4ce16a32b99a8127f5553cdb9015bf5e80.
---
 data_structures/heap/binomial_heap.py        | 2 +-
 divide_and_conquer/convex_hull.py            | 2 +-
 neural_network/convolution_neural_network.py | 3 +--
 strings/boyer_moore_search.py                | 2 +-
 4 files changed, 4 insertions(+), 5 deletions(-)

diff --git a/data_structures/heap/binomial_heap.py b/data_structures/heap/binomial_heap.py
index bc9cb5145f2e..0154390d7707 100644
--- a/data_structures/heap/binomial_heap.py
+++ b/data_structures/heap/binomial_heap.py
@@ -307,7 +307,7 @@ def deleteMin(self):
         # No right subtree corner case
         # The structure of the tree implies that this should be the bottom root
         # and there is at least one other root
-        if self.min_node.right == None:
+        if self.min_node.right is None:
             # Update size
             self.size -= 1
 
diff --git a/divide_and_conquer/convex_hull.py b/divide_and_conquer/convex_hull.py
index a0c319e766da..534ebda2c780 100644
--- a/divide_and_conquer/convex_hull.py
+++ b/divide_and_conquer/convex_hull.py
@@ -191,7 +191,7 @@ def _validate_input(points):
             else:
                 raise ValueError("Expecting an iterable of type Point, list or tuple. "
                                  "Found objects of type {} instead"
-                                 .format(["point", "list", "tuple"], type(points[0])))
+                                 .format(type(points[0])))
         elif not hasattr(points, "__iter__"):
             raise ValueError("Expecting an iterable object "
                              "but got an non-iterable type {}".format(points))
diff --git a/neural_network/convolution_neural_network.py b/neural_network/convolution_neural_network.py
index e4dd0a11db9d..786992c054a0 100644
--- a/neural_network/convolution_neural_network.py
+++ b/neural_network/convolution_neural_network.py
@@ -297,7 +297,6 @@ def convolution(self, data):
 
 
 if __name__ == '__main__':
-    pass
     '''
     I will put the example on other file
-'''
+    '''
diff --git a/strings/boyer_moore_search.py b/strings/boyer_moore_search.py
index 781ff0ca6106..2d67043dc028 100644
--- a/strings/boyer_moore_search.py
+++ b/strings/boyer_moore_search.py
@@ -70,7 +70,7 @@ def bad_character_heuristic(self):
                 positions.append(i)
             else:
                 match_index = self.match_in_pattern(self.text[mismatch_index])
-                i = mismatch_index - match_index   #shifting index
+                i = mismatch_index - match_index   #shifting index lgtm [py/multiple-definition]
         return positions
 
  

From 837bfffd991cddb3113139a3d13292b58529f05f Mon Sep 17 00:00:00 2001
From: Holden-Lin <mimaixs@126.com>
Date: Sun, 22 Sep 2019 22:56:32 +0800
Subject: [PATCH 216/348] Rename sorted_vector_machines.py to
 support_vector_machines.py (#1195)

SVM stands for support vector machines. Intuitively, a support vector is the vector right near the decision boundary.
---
 .../{sorted_vector_machines.py => support_vector_machines.py}     | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename machine_learning/{sorted_vector_machines.py => support_vector_machines.py} (100%)

diff --git a/machine_learning/sorted_vector_machines.py b/machine_learning/support_vector_machines.py
similarity index 100%
rename from machine_learning/sorted_vector_machines.py
rename to machine_learning/support_vector_machines.py

From 01601e6382e92b5a3806fb3a44357460dff97ee7 Mon Sep 17 00:00:00 2001
From: luoheng <1301089462@qq.com>
Date: Mon, 23 Sep 2019 11:08:20 +0800
Subject: [PATCH 217/348] Add disjoint set (#1194)

* Add disjoint set

* disjoint set: add doctest, make code more Pythonic

* disjoint set: replace x.p with x.parent

* disjoint set: add test and refercence
---
 data_structures/disjoint_set/disjoint_set.py | 79 ++++++++++++++++++++
 1 file changed, 79 insertions(+)
 create mode 100644 data_structures/disjoint_set/disjoint_set.py

diff --git a/data_structures/disjoint_set/disjoint_set.py b/data_structures/disjoint_set/disjoint_set.py
new file mode 100644
index 000000000000..a93b89621c4a
--- /dev/null
+++ b/data_structures/disjoint_set/disjoint_set.py
@@ -0,0 +1,79 @@
+"""
+    disjoint set
+    Reference: https://en.wikipedia.org/wiki/Disjoint-set_data_structure
+"""
+
+
+class Node:
+    def __init__(self, data):
+        self.data = data
+
+
+def make_set(x):
+    """
+    make x as a set.
+    """
+    # rank is the distance from x to its' parent
+    # root's rank is 0
+    x.rank = 0
+    x.parent = x
+
+
+def union_set(x, y):
+    """
+    union two sets.
+    set with bigger rank should be parent, so that the
+    disjoint set tree will be more flat.
+    """
+    x, y = find_set(x), find_set(y)
+    if x.rank > y.rank:
+        y.parent = x
+    else:
+        x.parent = y
+        if x.rank == y.rank:
+            y.rank += 1
+
+
+def find_set(x):
+    """
+    return the parent of x
+    """
+    if x != x.parent:
+        x.parent = find_set(x.parent)
+    return x.parent
+
+
+def find_python_set(node: Node) -> set:
+    """
+    Return a Python Standard Library set that contains i.
+    """
+    sets = ({0, 1, 2}, {3, 4, 5})
+    for s in sets:
+        if node.data in s:
+            return s
+    raise ValueError(f"{node.data} is not in {sets}")
+
+
+def test_disjoint_set():
+    """
+    >>> test_disjoint_set()
+    """
+    vertex = [Node(i) for i in range(6)]
+    for v in vertex:
+        make_set(v)
+
+    union_set(vertex[0], vertex[1])
+    union_set(vertex[1], vertex[2])
+    union_set(vertex[3], vertex[4])
+    union_set(vertex[3], vertex[5])
+
+    for node0 in vertex:
+        for node1 in vertex:
+            if find_python_set(node0).isdisjoint(find_python_set(node1)):
+                assert find_set(node0) != find_set(node1)
+            else:
+                assert find_set(node0) == find_set(node1)
+
+
+if __name__ == "__main__":
+    test_disjoint_set()

From e40d4a25f9b7a58d08fdc5d247a25cb226a46d21 Mon Sep 17 00:00:00 2001
From: Aniruddha Bhattacharjee <aniruddha97bhatt@gmail.com>
Date: Wed, 25 Sep 2019 23:38:45 +0530
Subject: [PATCH 218/348] Added Matrix Exponentiation (#1203)

* Added the matrix_exponentiation.py file in maths directory

* Implemented the requested changes

* Update matrix_exponentiation.py
---
 maths/matrix_exponentiation.py | 99 ++++++++++++++++++++++++++++++++++
 1 file changed, 99 insertions(+)
 create mode 100644 maths/matrix_exponentiation.py

diff --git a/maths/matrix_exponentiation.py b/maths/matrix_exponentiation.py
new file mode 100644
index 000000000000..ee9e1757687c
--- /dev/null
+++ b/maths/matrix_exponentiation.py
@@ -0,0 +1,99 @@
+"""Matrix Exponentiation"""
+
+import timeit
+
+"""
+Matrix Exponentiation is a technique to solve linear recurrences in logarithmic time.
+You read more about it here: 
+http://zobayer.blogspot.com/2010/11/matrix-exponentiation.html
+https://www.hackerearth.com/practice/notes/matrix-exponentiation-1/
+"""
+
+
+class Matrix(object):
+    def __init__(self, arg):
+        if isinstance(arg, list):  # Initialzes a matrix identical to the one provided.
+            self.t = arg
+            self.n = len(arg)
+        else:  # Initializes a square matrix of the given size and set the values to zero.
+            self.n = arg
+            self.t = [[0 for _ in range(self.n)] for _ in range(self.n)]
+
+    def __mul__(self, b):
+        matrix = Matrix(self.n)
+        for i in range(self.n):
+            for j in range(self.n):
+                for k in range(self.n):
+                    matrix.t[i][j] += self.t[i][k] * b.t[k][j]
+        return matrix
+
+
+def modular_exponentiation(a, b):
+    matrix = Matrix([[1, 0], [0, 1]])
+    while b > 0:
+        if b & 1:
+            matrix *= a
+        a *= a
+        b >>= 1
+    return matrix
+
+
+def fibonacci_with_matrix_exponentiation(n, f1, f2):
+    # Trivial Cases
+    if n == 1:
+        return f1
+    elif n == 2:
+        return f2
+    matrix = Matrix([[1, 1], [1, 0]])
+    matrix = modular_exponentiation(matrix, n - 2)
+    return f2 * matrix.t[0][0] + f1 * matrix.t[0][1]
+
+
+def simple_fibonacci(n, f1, f2):
+    # Trival Cases
+    if n == 1:
+        return f1
+    elif n == 2:
+        return f2
+
+    fn_1 = f1
+    fn_2 = f2
+    n -= 2
+
+    while n > 0:
+        fn_1, fn_2 = fn_1 + fn_2, fn_1
+        n -= 1
+
+    return fn
+
+
+def matrix_exponentiation_time():
+    setup = """
+from random import randint
+from __main__ import fibonacci_with_matrix_exponentiation
+"""
+    code = "fibonacci_with_matrix_exponentiation(randint(1,70000), 1, 1)"
+    exec_time = timeit.timeit(setup=setup, stmt=code, number=100)
+    print("With matrix exponentiation the average execution time is ", exec_time / 100)
+    return exec_time
+
+
+def simple_fibonacci_time():
+    setup = """
+from random import randint
+from __main__ import simple_fibonacci
+"""
+    code = "simple_fibonacci(randint(1,70000), 1, 1)"
+    exec_time = timeit.timeit(setup=setup, stmt=code, number=100)
+    print("Without matrix exponentiation the average execution time is ",
+          exec_time / 100)
+    return exec_time
+
+
+def main():
+    matrix_exponentiation_time()
+    simple_fibonacci_time()
+
+
+if __name__ == "__main__":
+    main()

From 6ac7b1387f9b2c2fa428bbe2bd26d3e087e41b23 Mon Sep 17 00:00:00 2001
From: Raj <raj1998211@gmail.com>
Date: Wed, 25 Sep 2019 15:03:31 -0700
Subject: [PATCH 219/348] Min head with decrease key functionality (#1202)

* Min head with decrease key functionality

* doctest added

* __str__ changed as per Python convention

* edits in doctest

* get_value by key added

* __getitem__ added
---
 data_structures/heap/min_heap.py | 169 +++++++++++++++++++++++++++++++
 1 file changed, 169 insertions(+)
 create mode 100644 data_structures/heap/min_heap.py

diff --git a/data_structures/heap/min_heap.py b/data_structures/heap/min_heap.py
new file mode 100644
index 000000000000..6184d83be774
--- /dev/null
+++ b/data_structures/heap/min_heap.py
@@ -0,0 +1,169 @@
+# Min head data structure
+# with decrease key functionality - in O(log(n)) time
+
+
+class Node:
+    def __init__(self, name, val):
+        self.name = name
+        self.val = val
+
+    def __str__(self):
+        return f"{self.__class__.__name__}({self.name}, {self.val})"
+
+    def __lt__(self, other):
+        return self.val < other.val
+
+
+class MinHeap:
+    """
+    >>> r = Node("R", -1)
+    >>> b = Node("B", 6)
+    >>> a = Node("A", 3)
+    >>> x = Node("X", 1)
+    >>> e = Node("E", 4)
+    >>> print(b)
+    Node(B, 6)
+    >>> myMinHeap = MinHeap([r, b, a, x, e])
+    >>> myMinHeap.decrease_key(b, -17)
+    >>> print(b)
+    Node(B, -17)
+    >>> print(myMinHeap["B"])
+    -17
+    """
+
+    def __init__(self, array):
+        self.idx_of_element = {}
+        self.heap_dict = {}
+        self.heap = self.build_heap(array)
+
+    def __getitem__(self, key):
+        return self.get_value(key)
+
+    def get_parent_idx(self, idx):
+        return (idx - 1) // 2
+
+    def get_left_child_idx(self, idx):
+        return idx * 2 + 1
+
+    def get_right_child_idx(self, idx):
+        return idx * 2 + 2
+
+    def get_value(self, key):
+        return self.heap_dict[key]
+
+    def build_heap(self, array):
+        lastIdx = len(array) - 1
+        startFrom = self.get_parent_idx(lastIdx)
+
+        for idx, i in enumerate(array):
+            self.idx_of_element[i] = idx
+            self.heap_dict[i.name] = i.val
+
+        for i in range(startFrom, -1, -1):
+            self.sift_down(i, array)
+        return array
+
+    # this is min-heapify method
+    def sift_down(self, idx, array):
+        while True:
+            l = self.get_left_child_idx(idx)
+            r = self.get_right_child_idx(idx)
+
+            smallest = idx
+            if l < len(array) and array[l] < array[idx]:
+                smallest = l
+            if r < len(array) and array[r] < array[smallest]:
+                smallest = r
+
+            if smallest != idx:
+                array[idx], array[smallest] = array[smallest], array[idx]
+                self.idx_of_element[array[idx]], self.idx_of_element[
+                    array[smallest]
+                ] = (
+                    self.idx_of_element[array[smallest]],
+                    self.idx_of_element[array[idx]],
+                )
+                idx = smallest
+            else:
+                break
+
+    def sift_up(self, idx):
+        p = self.get_parent_idx(idx)
+        while p >= 0 and self.heap[p] > self.heap[idx]:
+            self.heap[p], self.heap[idx] = self.heap[idx], self.heap[p]
+            self.idx_of_element[self.heap[p]], self.idx_of_element[self.heap[idx]] = (
+                self.idx_of_element[self.heap[idx]],
+                self.idx_of_element[self.heap[p]],
+            )
+            idx = p
+            p = self.get_parent_idx(idx)
+
+    def peek(self):
+        return self.heap[0]
+
+    def remove(self):
+        self.heap[0], self.heap[-1] = self.heap[-1], self.heap[0]
+        self.idx_of_element[self.heap[0]], self.idx_of_element[self.heap[-1]] = (
+            self.idx_of_element[self.heap[-1]],
+            self.idx_of_element[self.heap[0]],
+        )
+
+        x = self.heap.pop()
+        del self.idx_of_element[x]
+        self.sift_down(0, self.heap)
+        return x
+
+    def insert(self, node):
+        self.heap.append(node)
+        self.idx_of_element[node] = len(self.heap) - 1
+        self.heap_dict[node.name] = node.val
+        self.sift_up(len(self.heap) - 1)
+
+    def is_empty(self):
+        return True if len(self.heap) == 0 else False
+
+    def decrease_key(self, node, newValue):
+        assert (
+            self.heap[self.idx_of_element[node]].val > newValue
+        ), "newValue must be less that current value"
+        node.val = newValue
+        self.heap_dict[node.name] = newValue
+        self.sift_up(self.idx_of_element[node])
+
+
+## USAGE
+
+r = Node("R", -1)
+b = Node("B", 6)
+a = Node("A", 3)
+x = Node("X", 1)
+e = Node("E", 4)
+
+# Use one of these two ways to generate Min-Heap
+
+# Generating Min-Heap from array
+myMinHeap = MinHeap([r, b, a, x, e])
+
+# Generating Min-Heap by Insert method
+# myMinHeap.insert(a)
+# myMinHeap.insert(b)
+# myMinHeap.insert(x)
+# myMinHeap.insert(r)
+# myMinHeap.insert(e)
+
+# Before
+print("Min Heap - before decrease key")
+for i in myMinHeap.heap:
+    print(i)
+
+print("Min Heap - After decrease key of node [B -> -17]")
+myMinHeap.decrease_key(b, -17)
+
+# After
+for i in myMinHeap.heap:
+    print(i)
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()

From 2375bfbee59f091435818d850e5057fdd50ffe19 Mon Sep 17 00:00:00 2001
From: Charitoc <37042130+Charitoc@users.noreply.github.com>
Date: Thu, 26 Sep 2019 18:19:01 +0300
Subject: [PATCH 220/348] Adding stooge sort (#1206)

* Adding stooge sort

* Updated doctest

* Just added underscore in the name
---
 sorts/stooge_sort.py | 34 ++++++++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 sorts/stooge_sort.py

diff --git a/sorts/stooge_sort.py b/sorts/stooge_sort.py
new file mode 100644
index 000000000000..d2325abc9b38
--- /dev/null
+++ b/sorts/stooge_sort.py
@@ -0,0 +1,34 @@
+def stooge_sort(arr):
+    """
+    >>> arr = [2, 4, 5, 3, 1]
+    >>> stooge_sort(arr)
+    >>> print(arr)
+    [1, 2, 3, 4, 5]
+    """
+    stooge(arr,0,len(arr)-1)
+
+    
+def stooge(arr, i, h):
+
+
+    if i >= h:
+        return
+  
+    # If first element is smaller than the last then swap them
+    if arr[i]>arr[h]:
+        arr[i], arr[h] = arr[h], arr[i]
+  
+    # If there are more than 2 elements in the array
+    if h-i+1 > 2: 
+        t = (int)((h-i+1)/3)
+  
+        # Recursively sort first 2/3 elements
+        stooge(arr, i, (h-t))
+  
+        # Recursively sort last 2/3 elements
+        stooge(arr, i+t, (h))
+  
+        # Recursively sort first 2/3 elements
+        stooge(arr, i, (h-t))
+
+        

From a79fc2b92ad2c36e77d1c1696a2a0bc746ef9fea Mon Sep 17 00:00:00 2001
From: Christian Clauss <cclauss@me.com>
Date: Thu, 26 Sep 2019 17:32:04 +0200
Subject: [PATCH 221/348] Fix the build typo: fn --> fn1 (#1205)

---
 maths/matrix_exponentiation.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/maths/matrix_exponentiation.py b/maths/matrix_exponentiation.py
index ee9e1757687c..f80f6c3cad5e 100644
--- a/maths/matrix_exponentiation.py
+++ b/maths/matrix_exponentiation.py
@@ -64,7 +64,7 @@ def simple_fibonacci(n, f1, f2):
         fn_1, fn_2 = fn_1 + fn_2, fn_1
         n -= 1
 
-    return fn
+    return fn_1
 
 
 def matrix_exponentiation_time():

From 4617aa78b2a61fcfebc136f7fc217ea980205067 Mon Sep 17 00:00:00 2001
From: Kaushik Amar Das <cozek@users.noreply.github.com>
Date: Sun, 29 Sep 2019 14:14:41 +0530
Subject: [PATCH 222/348] DBSCAN algorithm (#1207)

* Added dbscan in two formats. A jupyter notebook file for the
storytelling and a .py file for people that just want to look at the
code. The code in both is essentially the same. With a few things
different in the .py file for plotting the clusters.

* fixed LGTM problems

* Some requested changes implemented.
Still need to do docstring

* implememted all changes as requested
---
 machine_learning/dbscan/dbscan.ipynb | 376 +++++++++++++++++++++++++++
 machine_learning/dbscan/dbscan.py    | 271 +++++++++++++++++++
 2 files changed, 647 insertions(+)
 create mode 100644 machine_learning/dbscan/dbscan.ipynb
 create mode 100644 machine_learning/dbscan/dbscan.py

diff --git a/machine_learning/dbscan/dbscan.ipynb b/machine_learning/dbscan/dbscan.ipynb
new file mode 100644
index 000000000000..603a4cd405b9
--- /dev/null
+++ b/machine_learning/dbscan/dbscan.ipynb
@@ -0,0 +1,376 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## DBSCAN\n",
+    "This implementation and notebook is inspired from the original DBSCAN algorithm and article as given in \n",
+    "[DBSCAN Wikipedia](https://en.wikipedia.org/wiki/DBSCAN).\n",
+    "\n",
+    "Stands for __Density-based spatial clustering of applications with noise__ . \n",
+    "\n",
+    "DBSCAN is clustering algorithm that tries to captures the intuition that if two points belong to the same cluster they should be close to one another. It does so by finding regions that are densely packed together, i.e, the points that have many close neighbours.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### When to use ?\n",
+    "\n",
+    "1. You need a robust clustering algorithm.\n",
+    "2. You don't know how many clusters there are in the dataset\n",
+    "3. You find it difficult to guess the number of clusters there are just by eyeballing the dataset.\n",
+    "4. The clusters are of arbitrary shapes.\n",
+    "5. You want to detect outliers/noise."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Why DBSCAN ? \n",
+    "\n",
+    "This algorithm is way better than other clustering algorithms such as [k-means](https://en.wikipedia.org/wiki/K-means_clustering) whose only job is to find circular blobs. It is smart enough to figure out the number of clusters in the dataset on its own, unlike k-means where you need to specify 'k'.  It can also find clusters of arbitrary shapes, not just circular blobs.  Its too robust to be affected by outliers (the noise points) and isn't fooled by them, unlike k-means where the entire centroid get pulled thanks to pesky outliers. Plus, you can fine-tune its parameters depending on what you are clustering.\n",
+    "\n",
+    "#### Have a look at these [neat animations](https://www.naftaliharris.com/blog/visualizing-dbscan-clustering/) of DBSCAN to see for yourself."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "\n",
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## First lets grab a dataset\n",
+    "We will take the moons dataset which is pretty good at showing the power of DBSCAN. \n",
+    "\n",
+    "Lets generate 200 random points in the shape of two moons"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from sklearn.datasets import make_moons\n",
+    "\n",
+    "x, label = make_moons(n_samples=200, noise=0.1, random_state=19)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Visualize the dataset using matplotlib\n",
+    "You will observe that the points are in the shape of two crescent moons. \n",
+    "\n",
+    "The challenge here is to cluster the two moons. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x11a00e588>]"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.plot(x[:,0], x[:,1],'ro')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Abstract of the Algorithm\n",
+    "The DBSCAN algorithm can be abstracted into the following steps:\n",
+    "\n",
+    "- Find the points in the $ε$ (eps) neighborhood of every point, and identify the core points with more than <b>min_pts</b> neighbors.\n",
+    "- Find the connected components of core points on the neighbor graph, ignoring all non-core points.\n",
+    "- Assign each non-core point to a nearby cluster if the cluster is an $ε$ (eps) neighbor, otherwise assign it to noise.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Preparing the points\n",
+    "Initially we label all the points in the dataset as __undefined__ .\n",
+    "\n",
+    "__points__ is our database of all points in the dataset."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "points = { (point[0],point[1]):{'label':'undefined'} for point in x }"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Helper functions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def euclidean_distance(q, p):\n",
+    "    \"\"\"\n",
+    "        Calculates the Euclidean distance\n",
+    "        between points P and Q\n",
+    "    \"\"\"\n",
+    "    a = pow((q[0] - p[0]), 2)\n",
+    "    b = pow((q[1] - p[1]), 2)\n",
+    "    return pow((a + b), 0.5)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def find_neighbors(db, q, eps):\n",
+    "    \"\"\"\n",
+    "        Finds all points in the DB that\n",
+    "        are within a distance of eps from Q\n",
+    "    \"\"\"\n",
+    "    return [p for p in db if euclidean_distance(q, p) <= eps]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def plot_cluster(db, clusters):\n",
+    "    \"\"\"\n",
+    "        Extracts all the points in the DB and puts them together\n",
+    "        as seperate clusters and finally plots them\n",
+    "    \"\"\"\n",
+    "    temp = []\n",
+    "    noise = []\n",
+    "    for i in clusters:\n",
+    "        stack = []\n",
+    "        for k, v in db.items():\n",
+    "            if v[\"label\"] == i:\n",
+    "                stack.append(k)\n",
+    "            elif v[\"label\"] == \"noise\":\n",
+    "                noise.append(k)\n",
+    "        temp.append(stack)\n",
+    "\n",
+    "    color = iter(plt.cm.rainbow(np.linspace(0, 1, len(clusters))))\n",
+    "    for i in range(0, len(temp)):\n",
+    "        c = next(color)\n",
+    "        x = [l[0] for l in temp[i]]\n",
+    "        y = [l[1] for l in temp[i]]\n",
+    "        plt.plot(x, y, \"ro\", c=c)\n",
+    "\n",
+    "    x = [l[0] for l in noise]\n",
+    "    y = [l[1] for l in noise]\n",
+    "    plt.plot(x, y, \"ro\", c=\"0\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Implementation of DBSCAN\n",
+    "\n",
+    "Initialize an empty list, clusters = $[ ]$ and cluster identifier, c = 0\n",
+    "\n",
+    "1. For each point  p in our database/dict  db :\n",
+    "\n",
+    "    1.1 Check if p is already labelled. If it's already labelled (means it already been associated to a cluster), continue to the next point,i.e, go to step 1\n",
+    "    \n",
+    "    1.2. Find the list of neighbors of p , i.e, points that are within a distance of eps from p\n",
+    "    \n",
+    "    1.3. If p does not have atleast min_pts neighbours, we label it as noise and go back to step 1\n",
+    "    \n",
+    "    1.4. Initialize the cluster, by incrementing c by 1\n",
+    "    \n",
+    "    1.5. Append the cluster identifier c to clusters\n",
+    "    \n",
+    "    1.6. Label p with the cluster identifier c\n",
+    "    \n",
+    "    1.7 Remove p from the list of neighbors (p will be detected as its own neighbor because it is within eps of itself)\n",
+    "    \n",
+    "    1.8. Initialize the seed_set as a copy of neighbors\n",
+    "   \n",
+    "    1.9. While the seed_set is not empty:\n",
+    "        1.9.1. Removing the 1st point from seed_set and initialise it as q\n",
+    "        1.9.2. If it's label is noise, label it with c\n",
+    "        1.9.3. If it's not unlabelled, go back to step 1.9\n",
+    "        1.9.4. Label q with c\n",
+    "        1.9.5. Find the neighbours of q \n",
+    "        1.9.6. If there are atleast min_pts neighbors, append them to the seed_set"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def dbscan(db,eps,min_pts):\n",
+    "    '''\n",
+    "        Implementation of the DBSCAN algorithm\n",
+    "    '''\n",
+    "    clusters = []\n",
+    "    c = 0\n",
+    "    for p in db:\n",
+    "        if db[p][\"label\"] != \"undefined\":\n",
+    "            continue\n",
+    "        neighbors = find_neighbors(db, p, eps)\n",
+    "        if len(neighbors) < min_pts:\n",
+    "            db[p][\"label\"] = \"noise\"\n",
+    "            continue\n",
+    "        c += 1\n",
+    "        clusters.append(c)\n",
+    "        db[p][\"label\"] = c\n",
+    "        neighbors.remove(p)\n",
+    "        seed_set = neighbors.copy()\n",
+    "        while seed_set != []:\n",
+    "            q = seed_set.pop(0)\n",
+    "            if db[q][\"label\"] == \"noise\":\n",
+    "                db[q][\"label\"] = c\n",
+    "            if db[q][\"label\"] != \"undefined\":\n",
+    "                continue\n",
+    "            db[q][\"label\"] = c\n",
+    "            neighbors_n = find_neighbors(db, q, eps)\n",
+    "            if len(neighbors_n) >= min_pts:\n",
+    "                seed_set = seed_set + neighbors_n\n",
+    "    return db, clusters\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Lets run it!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "eps = 0.25\n",
+    "min_pts = 12\n",
+    "\n",
+    "db,clusters = dbscan(points,eps,min_pts)\n",
+    "\n",
+    "plot_cluster(db,clusters)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "I encourage you to try with different datasets and playing with the values of eps and min_pts.\n",
+    "\n",
+    "Also, try kmeans on this dataset and see how it compares to dbscan. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "I hope by now you are convinced about about how cool dbscan is. But it has its pitfalls.\n",
+    "### When NOT to use ?\n",
+    "\n",
+    "1. You have a high dimentional dataset. Euclidean distance will fail thanks to '[curse of dimentionality](https://en.wikipedia.org/wiki/Curse_of_dimensionality#Distance_functions)'.\n",
+    "2. We have used a dict to store the points. So we can't do anything about the order in which the points will be processed. So it's not entirely deterministic.\n",
+    "3. Won't work well if there are large differences in density. Finding the min_pts and $ε$ combination will be difficult.\n",
+    "4. Choosing the $ε$ without understanding the data and its scale, might result is poor clustering performance."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/machine_learning/dbscan/dbscan.py b/machine_learning/dbscan/dbscan.py
new file mode 100644
index 000000000000..04fb5f0186e1
--- /dev/null
+++ b/machine_learning/dbscan/dbscan.py
@@ -0,0 +1,271 @@
+import matplotlib.pyplot as plt
+import numpy as np
+from sklearn.datasets import make_moons
+import warnings
+
+
+def euclidean_distance(q, p):
+    """
+        Calculates the Euclidean distance
+        between points q and p
+
+        Distance can only be calculated between numeric values
+        >>> euclidean_distance([1,'a'],[1,2])
+        Traceback (most recent call last):
+        ...
+        ValueError: Non-numeric input detected
+
+        The dimentions of both the points must be the same
+        >>> euclidean_distance([1,1,1],[1,2])
+        Traceback (most recent call last):
+        ...
+        ValueError: expected dimensions to be 2-d, instead got p:3 and q:2
+
+        Supports only two dimentional points
+        >>> euclidean_distance([1,1,1],[1,2])
+        Traceback (most recent call last):
+        ...
+        ValueError: expected dimensions to be 2-d, instead got p:3 and q:2
+
+        Input should be in the format [x,y] or (x,y)
+        >>> euclidean_distance(1,2)
+        Traceback (most recent call last):
+        ...
+        TypeError: inputs must be iterable, either list [x,y] or tuple (x,y)
+    """
+    if not hasattr(q, "__iter__") or not hasattr(p, "__iter__"):
+        raise TypeError("inputs must be iterable, either list [x,y] or tuple (x,y)")
+
+    if isinstance(q, str) or isinstance(p, str):
+        raise TypeError("inputs cannot be str")
+
+    if len(q) != 2 or len(p) != 2:
+        raise ValueError(
+            "expected dimensions to be 2-d, instead got p:{} and q:{}".format(
+                len(q), len(p)
+            )
+        )
+
+    for num in q + p:
+        try:
+            num = int(num)
+        except:
+            raise ValueError("Non-numeric input detected")
+
+    a = pow((q[0] - p[0]), 2)
+    b = pow((q[1] - p[1]), 2)
+    return pow((a + b), 0.5)
+
+
+def find_neighbors(db, q, eps):
+    """
+        Finds all points in the db that
+        are within a distance of eps from Q
+
+        eps value should be a number
+        >>> find_neighbors({ (1,2):{'label':'undefined'}, (2,3):{'label':'undefined'}}, (2,5),'a')
+        Traceback (most recent call last):
+        ...
+        ValueError: eps should be either int or float
+
+        Q must be a 2-d point as list or tuple
+        >>> find_neighbors({ (1,2):{'label':'undefined'}, (2,3):{'label':'undefined'}}, 2, 0.5)
+        Traceback (most recent call last):
+        ...
+        TypeError: Q must a 2-dimentional point in the format (x,y) or [x,y]
+
+        Points must be in correct format
+        >>> find_neighbors([], (2,2) ,0.4)
+        Traceback (most recent call last):
+        ...
+        TypeError: db must be a dict of points in the format {(x,y):{'label':'boolean/undefined'}}
+    """
+
+    if not isinstance(eps, (int, float)):
+        raise ValueError("eps should be either int or float")
+
+    if not hasattr(q, "__iter__"):
+        raise TypeError("Q must a 2-dimentional point in the format (x,y) or [x,y]")
+
+    if not isinstance(db, dict):
+        raise TypeError(
+            "db must be a dict of points in the format {(x,y):{'label':'boolean/undefined'}}"
+        )
+
+    return [p for p in db if euclidean_distance(q, p) <= eps]
+
+
+def plot_cluster(db, clusters, ax):
+    """
+        Extracts all the points in the db and puts them together
+        as seperate clusters and finally plots them
+
+        db cannot be empty
+        >>> fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(7, 5))
+        >>> plot_cluster({},[1,2], axes[1] )
+        Traceback (most recent call last):
+        ...
+        Exception: db is empty. No points to cluster
+
+        clusters cannot be empty
+        >>> fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(7, 5))
+        >>> plot_cluster({ (1,2):{'label':'undefined'}, (2,3):{'label':'undefined'}},[],axes[1] )
+        Traceback (most recent call last):
+        ...
+        Exception: nothing to cluster. Empty clusters
+
+        clusters cannot be empty
+        >>> fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(7, 5))
+        >>> plot_cluster({ (1,2):{'label':'undefined'}, (2,3):{'label':'undefined'}},[],axes[1] )
+        Traceback (most recent call last):
+        ...
+        Exception: nothing to cluster. Empty clusters
+
+        ax must be a plotable
+        >>> plot_cluster({ (1,2):{'label':'1'}, (2,3):{'label':'2'}},[1,2], [] )
+        Traceback (most recent call last):
+        ...
+        TypeError: ax must be an slot in a matplotlib figure
+    """
+    if len(db) == 0:
+        raise Exception("db is empty. No points to cluster")
+
+    if len(clusters) == 0:
+        raise Exception("nothing to cluster. Empty clusters")
+
+    if not hasattr(ax, "plot"):
+        raise TypeError("ax must be an slot in a matplotlib figure")
+
+    temp = []
+    noise = []
+    for i in clusters:
+        stack = []
+        for k, v in db.items():
+            if v["label"] == i:
+                stack.append(k)
+            elif v["label"] == "noise":
+                noise.append(k)
+        temp.append(stack)
+
+    color = iter(plt.cm.rainbow(np.linspace(0, 1, len(clusters))))
+    for i in range(0, len(temp)):
+        c = next(color)
+        x = [l[0] for l in temp[i]]
+        y = [l[1] for l in temp[i]]
+        ax.plot(x, y, "ro", c=c)
+
+    x = [l[0] for l in noise]
+    y = [l[1] for l in noise]
+    ax.plot(x, y, "ro", c="0")
+
+
+def dbscan(db, eps, min_pts):
+    """
+        Implementation of the DBSCAN algorithm
+
+        Points must be in correct format
+        >>> dbscan([], (2,2) ,0.4)
+        Traceback (most recent call last):
+        ...
+        TypeError: db must be a dict of points in the format {(x,y):{'label':'boolean/undefined'}}
+
+        eps value should be a number
+        >>> dbscan({ (1,2):{'label':'undefined'}, (2,3):{'label':'undefined'}},'a',20 )
+        Traceback (most recent call last):
+        ...
+        ValueError: eps should be either int or float
+
+        min_pts value should be an integer
+        >>> dbscan({ (1,2):{'label':'undefined'}, (2,3):{'label':'undefined'}},0.4,20.0 )
+        Traceback (most recent call last):
+        ...
+        ValueError: min_pts should be int
+
+        db cannot be empty
+        >>> dbscan({},0.4,20.0 )
+        Traceback (most recent call last):
+        ...
+        Exception: db is empty, nothing to cluster
+
+        min_pts cannot be negative
+        >>> dbscan({ (1,2):{'label':'undefined'}, (2,3):{'label':'undefined'}}, 0.4, -20)
+        Traceback (most recent call last):
+        ...
+        ValueError: min_pts or eps cannot be negative
+
+        eps cannot be negative
+        >>> dbscan({ (1,2):{'label':'undefined'}, (2,3):{'label':'undefined'}},-0.4, 20)
+        Traceback (most recent call last):
+        ...
+        ValueError: min_pts or eps cannot be negative
+
+    """
+    if not isinstance(db, dict):
+        raise TypeError(
+            "db must be a dict of points in the format {(x,y):{'label':'boolean/undefined'}}"
+        )
+
+    if len(db) == 0:
+        raise Exception("db is empty, nothing to cluster")
+
+    if not isinstance(eps, (int, float)):
+        raise ValueError("eps should be either int or float")
+
+    if not isinstance(min_pts, int):
+        raise ValueError("min_pts should be int")
+
+    if min_pts < 0 or eps < 0:
+        raise ValueError("min_pts or eps cannot be negative")
+
+    if min_pts == 0:
+        warnings.warn("min_pts is 0. Are you sure you want this ?")
+
+    if eps == 0:
+        warnings.warn("eps is 0. Are you sure you want this ?")
+
+    clusters = []
+    c = 0
+    for p in db:
+        if db[p]["label"] != "undefined":
+            continue
+        neighbors = find_neighbors(db, p, eps)
+        if len(neighbors) < min_pts:
+            db[p]["label"] = "noise"
+            continue
+        c += 1
+        clusters.append(c)
+        db[p]["label"] = c
+        neighbors.remove(p)
+        seed_set = neighbors.copy()
+        while seed_set != []:
+            q = seed_set.pop(0)
+            if db[q]["label"] == "noise":
+                db[q]["label"] = c
+            if db[q]["label"] != "undefined":
+                continue
+            db[q]["label"] = c
+            neighbors_n = find_neighbors(db, q, eps)
+            if len(neighbors_n) >= min_pts:
+                seed_set = seed_set + neighbors_n
+    return db, clusters
+
+
+if __name__ == "__main__":
+
+    fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(7, 5))
+
+    x, label = make_moons(n_samples=200, noise=0.1, random_state=19)
+
+    axes[0].plot(x[:, 0], x[:, 1], "ro")
+
+    points = {(point[0], point[1]): {"label": "undefined"} for point in x}
+
+    eps = 0.25
+
+    min_pts = 12
+
+    db, clusters = dbscan(points, eps, min_pts)
+
+    plot_cluster(db, clusters, axes[1])
+
+    plt.show()

From 189b35031224e78e10b668e19fc4b2a1966d19c1 Mon Sep 17 00:00:00 2001
From: yijoonsu <44707391+paulo9428@users.noreply.github.com>
Date: Mon, 30 Sep 2019 23:27:41 +0900
Subject: [PATCH 223/348] Deque (#1200)

* deque add pop

* deque add remove
---
 data_structures/queue/double_ended_queue.py | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/data_structures/queue/double_ended_queue.py b/data_structures/queue/double_ended_queue.py
index a2fc8f66ec22..a3cfa7230710 100644
--- a/data_structures/queue/double_ended_queue.py
+++ b/data_structures/queue/double_ended_queue.py
@@ -37,3 +37,21 @@
 # printing modified deque
 print("The deque after reversing deque is : ")
 print(de)
+
+# get right-end value and eliminate
+startValue = de.pop()
+
+print("The deque after popping value at end is : ")
+print(de)
+
+# get left-end value and eliminate
+endValue = de.popleft()
+
+print("The deque after popping value at start is : ")
+print(de)
+
+# eliminate element searched by value
+de.remove(5)
+
+print("The deque after eliminating element searched by value : ")
+print(de)

From b738281f2b0cf44257e50b4f21ad74c8cbb1714e Mon Sep 17 00:00:00 2001
From: Shoaib Asgar <shoaib.mca19.du@gmail.com>
Date: Tue, 1 Oct 2019 12:28:00 +0530
Subject: [PATCH 224/348] maths-polynomial_evalutation (#1214)

* maths-polynomial_evalutation

* added doctest and removed redundancy
---
 maths/polynomial_evaluation.py | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 maths/polynomial_evaluation.py

diff --git a/maths/polynomial_evaluation.py b/maths/polynomial_evaluation.py
new file mode 100644
index 000000000000..b4f18b9fa106
--- /dev/null
+++ b/maths/polynomial_evaluation.py
@@ -0,0 +1,25 @@
+def evaluate_poly(poly, x):
+    """
+        Objective: Computes the polynomial function for a given value x. 
+                Returns that value. 
+        Input Prams: 
+            poly: tuple of numbers - value of cofficients
+            x: value for x in f(x)
+        Return: value of f(x)
+
+        >>> evaluate_poly((0.0, 0.0, 5.0, 9.3, 7.0), 10)
+        79800.0
+    """
+
+    return sum(c*(x**i) for i, c in enumerate(poly))
+
+
+if __name__ == "__main__":
+    """
+        Example: poly = (0.0, 0.0, 5.0, 9.3, 7.0)  # f(x) = 7.0x^4 + 9.3x^3 + 5.0x^2 
+                 x = -13
+                 print (evaluate_poly(poly, x))  # f(-13) = 7.0(-13)^4 + 9.3(-13)^3 + 5.0(-13)^2 = 180339.9
+    """
+    poly = (0.0, 0.0, 5.0, 9.3, 7.0)
+    x = 10
+    print(evaluate_poly(poly, x))

From df44d1b703d756f965f0085ac05e91810b8e9c21 Mon Sep 17 00:00:00 2001
From: Christian Clauss <cclauss@me.com>
Date: Wed, 2 Oct 2019 18:19:00 +0200
Subject: [PATCH 225/348] Update CONTRIBUTING.md (#1250)

* Update CONTRIBUTING.md

* Update CONTRIBUTING.md

* Add Python type hints and mypy
---
 CONTRIBUTING.md | 88 ++++++++++++++++++++++++++++---------------------
 1 file changed, 51 insertions(+), 37 deletions(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 8c0f54ad528d..8cd03217d51f 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -23,26 +23,38 @@ We are very happy that you consider implementing algorithms and data structure f
 
 We appreciate any contribution, from fixing a grammar mistake in a comment to implementing complex algorithms. Please read this section if you are contributing your work.
 
+Your contribution will be tested by our [automated testing on Travis CI](https://travis-ci.org/TheAlgorithms/Python/pull_requests) to save time and mental energy.  After you have submitted your pull request, you should see the Travis tests start to run at the bottom of your submission page.  If those tests fail, then click on the ___details___ button try to read through the Travis output to understand the failure.  If you do not understand, please leave a comment on your submission page and a community member will try to help.
+
 #### Coding Style
 
 We want your work to be readable by others; therefore, we encourage you to note the following:
 
-- Please write in Python 3.x.
-- Please consider running [__python/black__](https://github.com/python/black) on your Python file(s) before submitting your pull request.  This is not a requirement but it does make your code more readable.  There are other code formatters (autopep8, yapf) but the __black__ style is now the recommendation of the Python core team. To use it,
+- Please write in Python 3.7+.  __print()__ is a function in Python 3 so __print "Hello"__ will _not_ work but __print("Hello")__ will.
+
+- Please focus hard on naming of functions, classes, and variables.  Help your reader by using __descriptive names__ that can help you to remove redundant comments.
+    - Single letter variable names are _old school_ so please avoid them unless their life only spans a few lines.
+    - Expand acronyms because __gcd()__ is hard to understand but __greatest_common_divisor()__ is not.
+    - Please follow the [Python Naming Conventions](https://pep8.org/#prescriptive-naming-conventions) so variable_names and function_names should be lower_case, CONSTANTS in UPPERCASE, ClassNames should be CamelCase, etc.
+
+- We encourage the use of Python [f-strings](https://realpython.com/python-f-strings/#f-strings-a-new-and-improved-way-to-format-strings-in-python) where the make the code easier to read.
+
+- Please consider running [__psf/black__](https://github.com/python/black) on your Python file(s) before submitting your pull request.  This is not yet a requirement but it does make your code more readable and automatically aligns it with much of [PEP 8](https://www.python.org/dev/peps/pep-0008/).  There are other code formatters (autopep8, yapf) but the __black__ style is now the recommendation of the Python Core Team. To use it,
     ```bash
     pip3 install black  # only required the first time
-    black my-submission.py
+    black .
     ```
 
 - All submissions will need to pass the test __flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics__ before they will be accepted so if possible, try this test locally on your Python file(s) before submitting your pull request.
+    ```bash
+    pip3 install flake8  # only required the first time
+    flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
+    ```
 
-- If you know [PEP 8](https://www.python.org/dev/peps/pep-0008/) already, you will have no problem in coding style, though we do not follow it strictly. Read the remaining section and have fun coding!
-
-- Always use 4 spaces to indent.
+- Original code submission require docstrings or comments to describe your work.
 
-- Original code submission requires comments to describe your work.
+- More on docstrings and comments:
 
-- More on comments and docstrings:
+  If you are using a Wikipedia article or some other source material to create your algorithm, please add the URL in a docstring or comment to help your reader.
 
   The following are considered to be bad and may be requested to be improved:
 
@@ -52,34 +64,40 @@ We want your work to be readable by others; therefore, we encourage you to note
 
   This is too trivial. Comments are expected to be explanatory. For comments, you can write them above, on or below a line of code, as long as you are consistent within the same piece of code.
 
-  *Sometimes, docstrings are avoided.* This will happen if you are using some editors and not careful with indentation:
+  We encourage you to put docstrings inside your functions but please pay attention to indentation of docstrings. The following is acceptable in this case:
 
   ```python
+  def sumab(a, b):
+      """
+      This function returns the sum of two integers a and b
+  	  Return: a + b
       """
-  	This function sums a and b
-  """
-  def sum(a, b):
       return a + b
   ```
 
-  However, if you insist to use docstrings, we encourage you to put docstrings inside functions. Also, please pay attention to indentation to docstrings. The following is acceptable in this case:
+- Write tests (especially [__doctests__](https://docs.python.org/3/library/doctest.html)) to illustrate and verify your work.  We highly encourage the use of _doctests on all functions_.
 
   ```python
   def sumab(a, b):
       """
-  	This function sums two integers a and b
-  	Return: a + b
+      This function returns the sum of two integers a and b
+  	  Return: a + b
+      >>> sum(2, 2)
+      4
+      >>> sum(-2, 3)
+      1
+      >>> sum(4.9, 6.1)
+      10.0
       """
       return a + b
   ```
 
-- `lambda`, `map`, `filter`, `reduce` and complicated list comprehension are welcome and acceptable to demonstrate the power of Python, as long as they are simple enough to read.
-
-  - This is arguable: **write comments** and assign appropriate variable names, so that the code is easy to read!
-
-- Write tests to illustrate your work.
+  These doctests will be run by pytest as part of our automated testing so please try to run your doctests locally and make sure that they are found and pass:
+    ```bash
+    python3 -m doctest -v my_submission.py
+    ```
 
-  The following "testing" approaches are **not** encouraged:
+  The use of the Python builtin __input()__ function is **not** encouraged:
 
   ```python
   input('Enter your input:')
@@ -87,34 +105,31 @@ We want your work to be readable by others; therefore, we encourage you to note
   input = eval(input("Enter your input: "))
   ```
 
-  However, if your code uses __input()__ then we encourage you to gracefully deal with leading and trailing whitespace in user input by adding __.strip()__ to the end as in:
+  However, if your code uses __input()__ then we encourage you to gracefully deal with leading and trailing whitespace in user input by adding __.strip()__ as in:
 
   ```python
   starting_value = int(input("Please enter a starting value: ").strip())
   ```
-
-  Please write down your test case, like the following:
-
-  ```python
-  def sumab(a, b):
-      return a + b
-  # Write tests this way:
-  print(sumab(1, 2))	# 1+2 = 3
-  print(sumab(6, 4))	# 6+4 = 10
-  # Or this way:
-  print("1 + 2 = ", sumab(1, 2))	# 1+2 = 3
-  print("6 + 4 = ", sumab(6, 4))	# 6+4 = 10
+  
+  The use of [Python type hints](https://docs.python.org/3/library/typing.html) is encouraged for function parameters and return values.  Our automated testing will run [mypy](http://mypy-lang.org) so run that locally before making your submission.
+```python
+def sumab(a: int, b: int) --> int:
+    pass
   ```
 
-  Better yet, if you know how to write [__doctests__](https://docs.python.org/3/library/doctest.html), please consider adding them.
+- [__list comprehensions and generators__](https://docs.python.org/3/tutorial/datastructures.html#list-comprehensions) are preferred over the use of `lambda`, `map`, `filter`, `reduce` but the important thing is to demonstrate the power of Python in code that is easy to read and maintain.
 
 - Avoid importing external libraries for basic algorithms. Only use those libraries for complicated algorithms.
 
+- If you need a third party module that is not in the file __requirements.txt__, please add it to that file as part of your submission.
+
 #### Other Standard While Submitting Your Work
 
 - File extension for code should be `.py`. Jupiter notebook files are acceptable in machine learning algorithms.
 
-- Strictly use snake case (underscore separated) in your file name, as it will be easy to parse in future using scripts.
+- Please avoid creating new directories if at all possible.  Try to fit your work into the existing directory structue.
+
+- Strictly use snake_case (underscore_separated) in your file_name, as it will be easy to parse in future using scripts.
 
   If possible, follow the standard *within* the folder you are submitting to.
 
@@ -135,5 +150,4 @@ We want your work to be readable by others; therefore, we encourage you to note
   - Happy coding!
 
 
-
 Writer [@poyea](https://github.com/poyea), Jun 2019.

From b8490ed097d8baab3234c54f835b8a7a55454e52 Mon Sep 17 00:00:00 2001
From: Anup Kumar Panwar <1anuppanwar@gmail.com>
Date: Thu, 3 Oct 2019 12:47:22 +0530
Subject: [PATCH 226/348] Removed owners from README (#1254)

---
 README.md | 12 ------------
 1 file changed, 12 deletions(-)

diff --git a/README.md b/README.md
index d4f4acbadb6d..a5af46ad8505 100644
--- a/README.md
+++ b/README.md
@@ -10,18 +10,6 @@
 
 These implementations are for learning purposes. They may be less efficient than the implementations in the Python standard library.
 
-## Owners
-
-Anup Kumar Panwar
-&nbsp; [[Gmail](mailto:1anuppanwar@gmail.com?Subject=The%20Algorithms%20-%20Python)
-&nbsp; [GitHub](https://github.com/anupkumarpanwar)
-&nbsp; [LinkedIn](https://www.linkedin.com/in/anupkumarpanwar/)]
-
-Chetan Kaushik
-&nbsp; [[Gmail](mailto:dynamitechetan@gmail.com?Subject=The%20Algorithms%20-%20Python)
-&nbsp; [GitHub](https://github.com/dynamitechetan)
-&nbsp; [LinkedIn](https://www.linkedin.com/in/chetankaushik/)]
-
 ## Contribution Guidelines
 
 Read our [Contribution Guidelines](CONTRIBUTING.md) before you contribute.

From 390feb0b23b4845a7ddfec7afd703aa053d1b224 Mon Sep 17 00:00:00 2001
From: Parth Paradkar <parthparadkar3@gmail.com>
Date: Thu, 3 Oct 2019 13:49:11 +0530
Subject: [PATCH 227/348] Add doctests for sorting algorithms (#1263)

* doctests and intro docstring added

* doctests, docstrings and check for empty collection added

* Intro docstring added

* python versions reversed
---
 sorts/pancake_sort.py | 28 +++++++++++++++++++++++-----
 sorts/pigeon_sort.py  | 26 +++++++++++++++++++++++---
 2 files changed, 46 insertions(+), 8 deletions(-)

diff --git a/sorts/pancake_sort.py b/sorts/pancake_sort.py
index 3b48bc6e46d9..873c14a0a174 100644
--- a/sorts/pancake_sort.py
+++ b/sorts/pancake_sort.py
@@ -1,9 +1,25 @@
-"""Pancake Sort Algorithm."""
-# Only can reverse array from 0 to i
-
+"""
+This is a pure python implementation of the pancake sort algorithm
+For doctests run following command:
+python3 -m doctest -v pancake_sort.py
+or
+python -m doctest -v pancake_sort.py
+For manual testing run:
+python pancake_sort.py
+"""
 
 def pancake_sort(arr):
-    """Sort Array with Pancake Sort."""
+    """Sort Array with Pancake Sort.
+    :param arr: Collection containing comparable items
+    :return: Collection ordered in ascending order of items
+    Examples:
+    >>> pancake_sort([0, 5, 3, 2, 2])
+    [0, 2, 2, 3, 5]
+    >>> pancake_sort([])
+    []
+    >>> pancake_sort([-2, -5, -45])
+    [-45, -5, -2]
+    """
     cur = len(arr)
     while cur > 1:
         # Find the maximum number in arr
@@ -17,4 +33,6 @@ def pancake_sort(arr):
 
 
 if __name__ == '__main__':
-    print(pancake_sort([0, 10, 15, 3, 2, 9, 14, 13]))
+    user_input = input('Enter numbers separated by a comma:\n').strip()
+    unsorted = [int(item) for item in user_input.split(',')]
+    print(pancake_sort(unsorted))
diff --git a/sorts/pigeon_sort.py b/sorts/pigeon_sort.py
index 5e5afa137685..5417234d331b 100644
--- a/sorts/pigeon_sort.py
+++ b/sorts/pigeon_sort.py
@@ -1,7 +1,29 @@
 '''
     This is an implementation of Pigeon Hole Sort.
+    For doctests run following command:
+    
+    python3 -m doctest -v pigeon_sort.py
+    or
+    python -m doctest -v pigeon_sort.py
+    
+    For manual testing run:
+    python pigeon_sort.py
 '''
 def pigeon_sort(array):
+    """
+    Implementation of pigeon hole sort algorithm
+    :param array: Collection of comparable items
+    :return: Collection sorted in ascending order
+    >>> pigeon_sort([0, 5, 3, 2, 2])
+    [0, 2, 2, 3, 5]
+    >>> pigeon_sort([])
+    []
+    >>> pigeon_sort([-2, -5, -45])
+    [-45, -5, -2]
+    """
+    if(len(array) == 0):
+        return array
+
     # Manually finds the minimum and maximum of the array.
     min = array[0]
     max = array[0]
@@ -37,6 +59,4 @@ def pigeon_sort(array):
 if __name__ == '__main__':
     user_input = input('Enter numbers separated by comma:\n')
     unsorted = [int(x) for x in user_input.split(',')]
-    sorted = pigeon_sort(unsorted)
-
-    print(sorted)
+    print(pigeon_sort(unsorted))

From 0e333ae02193fca1046fcd65ff5202eb054cc04e Mon Sep 17 00:00:00 2001
From: William Zhang <39932068+WilliamHYZhang@users.noreply.github.com>
Date: Thu, 3 Oct 2019 05:17:30 -0400
Subject: [PATCH 228/348] added bogobogosort (#1258)

* added bogobogosort

* fix indentation error
---
 sorts/bogo_bogo_sort.py | 54 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 54 insertions(+)
 create mode 100644 sorts/bogo_bogo_sort.py

diff --git a/sorts/bogo_bogo_sort.py b/sorts/bogo_bogo_sort.py
new file mode 100644
index 000000000000..f26a46e78645
--- /dev/null
+++ b/sorts/bogo_bogo_sort.py
@@ -0,0 +1,54 @@
+"""
+Python implementation of bogobogosort, a "sorting algorithm
+designed not to succeed before the heat death of the universe
+on any sizable list" - https://en.wikipedia.org/wiki/Bogosort.
+
+Author: WilliamHYZhang
+"""
+
+import random
+
+
+def bogo_bogo_sort(collection):
+    """
+    returns the collection sorted in ascending order
+    :param collection: list of comparable items
+    :return: the list sorted in ascending order
+
+    Examples:
+    >>> bogo_bogo_sort([0, 5, 3, 2, 2])
+    [0, 2, 2, 3, 5]
+    >>> bogo_bogo_sort([-2, -5, -45])
+    [-45, -5, -2]
+    >>> bogo_bogo_sort([420, 69])
+    [69, 420]
+    """
+
+    def is_sorted(collection):
+        if len(collection) == 1:
+            return True
+
+        clone = collection.copy()
+        while True:
+            random.shuffle(clone)
+            ordered = bogo_bogo_sort(clone[:-1])
+            if clone[len(clone) - 1] >= max(ordered):
+                break
+
+        for i in range(len(ordered)):
+            clone[i] = ordered[i]
+
+        for i in range(len(collection)):
+            if clone[i] != collection[i]:
+                return False
+        return True
+
+    while not is_sorted(collection):
+        random.shuffle(collection)
+    return collection
+
+
+if __name__ == "__main__":
+    user_input = input("Enter numbers separated by a comma:\n").strip()
+    unsorted = [int(item) for item in user_input.split(",")]
+    print(bogo_bogo_sort(unsorted))

From 0e2d6b2963deff0a47c97c2b41deb69aed254350 Mon Sep 17 00:00:00 2001
From: Kaushik Amar Das <cozek@users.noreply.github.com>
Date: Thu, 3 Oct 2019 20:00:36 +0530
Subject: [PATCH 229/348] adding softmax function (#1267)

* adding softmax function

* wraped lines as asked
---
 maths/softmax.py | 56 ++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 56 insertions(+)
 create mode 100644 maths/softmax.py

diff --git a/maths/softmax.py b/maths/softmax.py
new file mode 100644
index 000000000000..92ff4ca27b88
--- /dev/null
+++ b/maths/softmax.py
@@ -0,0 +1,56 @@
+"""
+This script demonstrates the implementation of the Softmax function.
+
+Its a function that takes as input a vector of K real numbers, and normalizes
+it into a probability distribution consisting of K probabilities proportional
+to the exponentials of the input numbers. After softmax, the elements of the
+vector always sum up to 1.
+
+Script inspired from its corresponding Wikipedia article
+https://en.wikipedia.org/wiki/Softmax_function
+"""
+
+import numpy as np
+
+
+def softmax(vector):
+    """
+        Implements the softmax function
+
+        Parameters:
+            vector (np.array,list,tuple): A  numpy array of shape (1,n)
+            consisting of real values or a similar list,tuple
+
+
+        Returns:
+            softmax_vec (np.array): The input numpy array  after applying
+            softmax.
+
+        The softmax vector adds up to one. We need to ceil to mitigate for
+        precision
+        >>> np.ceil(np.sum(softmax([1,2,3,4])))
+        1.0
+
+        >>> vec = np.array([5,5])
+        >>> softmax(vec)
+        array([0.5, 0.5])
+
+        >>> softmax([0])
+        array([1.])
+    """
+
+    # Calculate e^x for each x in your vector where e is Euler's
+    # number (approximately 2.718)
+    exponentVector = np.exp(vector)
+
+    # Add up the all the exponentials
+    sumOfExponents = np.sum(exponentVector)
+
+    # Divide every exponent by the sum of all exponents
+    softmax_vector = exponentVector / sumOfExponents
+
+    return softmax_vector
+
+
+if __name__ == "__main__":
+    print(softmax((0,)))

From 03aba96c0a28cf69e827b85dac1a463c74930530 Mon Sep 17 00:00:00 2001
From: Shubham garg <42842217+shubhamgarg2000@users.noreply.github.com>
Date: Fri, 4 Oct 2019 01:01:11 +0530
Subject: [PATCH 230/348] added defination (#1244)

---
 arithmetic_analysis/newton_raphson_method.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/arithmetic_analysis/newton_raphson_method.py b/arithmetic_analysis/newton_raphson_method.py
index bb6fdd2193ec..d17b57a2e670 100644
--- a/arithmetic_analysis/newton_raphson_method.py
+++ b/arithmetic_analysis/newton_raphson_method.py
@@ -1,6 +1,7 @@
 # Implementing Newton Raphson method in Python
 # Author: Syed Haseeb Shah (github.com/QuantumNovice)
-
+#The Newton-Raphson method (also known as Newton's method) is a way to 
+#quickly find a good approximation for the root of a real-valued function
 from sympy import diff
 from decimal import Decimal
 

From f970c730611ea1c4679b5db1708c2f2f2cb8dabc Mon Sep 17 00:00:00 2001
From: Simon Landry <landry_simon@pm.me>
Date: Thu, 3 Oct 2019 16:08:25 -0400
Subject: [PATCH 231/348] Add problem 23 solution (#1261)

---
 project_euler/problem_23/sol1.py | 51 ++++++++++++++++++++++++++++++++
 1 file changed, 51 insertions(+)
 create mode 100644 project_euler/problem_23/sol1.py

diff --git a/project_euler/problem_23/sol1.py b/project_euler/problem_23/sol1.py
new file mode 100644
index 000000000000..e76be053040f
--- /dev/null
+++ b/project_euler/problem_23/sol1.py
@@ -0,0 +1,51 @@
+"""
+A perfect number is a number for which the sum of its proper divisors is exactly
+equal to the number. For example, the sum of the proper divisors of 28 would be
+1 + 2 + 4 + 7 + 14 = 28, which means that 28 is a perfect number.
+
+A number n is called deficient if the sum of its proper divisors is less than n
+and it is called abundant if this sum exceeds n.
+
+As 12 is the smallest abundant number, 1 + 2 + 3 + 4 + 6 = 16, the smallest
+number that can be written as the sum of two abundant numbers is 24. By
+mathematical analysis, it can be shown that all integers greater than 28123
+can be written as the sum of two abundant numbers. However, this upper limit
+cannot be reduced any further by analysis even though it is known that the
+greatest number that cannot be expressed as the sum of two abundant numbers
+is less than this limit.
+
+Find the sum of all the positive integers which cannot be written as the sum
+of two abundant numbers.
+"""
+
+def solution(limit = 28123):
+    """
+    Finds the sum of all the positive integers which cannot be written as
+    the sum of two abundant numbers
+    as described by the statement above.
+
+    >>> solution()
+    4179871
+    """
+    sumDivs = [1] * (limit + 1)
+
+    for i in range(2, int(limit ** 0.5) + 1):
+        sumDivs[i * i] += i
+        for k in range(i + 1, limit // i + 1):
+            sumDivs[k * i] += k + i
+
+    abundants = set()
+    res = 0
+
+    for n in range(1, limit + 1):
+        if sumDivs[n] > n:
+            abundants.add(n)
+
+        if not any((n - a in abundants) for a in abundants):
+            res+=n
+
+    return res
+
+
+if __name__ == "__main__":
+    print(solution())

From d28fc7120281d726741e3001d5750bd737a38c59 Mon Sep 17 00:00:00 2001
From: Simon Landry <landry_simon@pm.me>
Date: Thu, 3 Oct 2019 16:47:08 -0400
Subject: [PATCH 232/348] Add problem18 solution (#1260)

---
 project_euler/problem_18/solution.py  | 64 +++++++++++++++++++++++++++
 project_euler/problem_18/triangle.txt | 15 +++++++
 2 files changed, 79 insertions(+)
 create mode 100644 project_euler/problem_18/solution.py
 create mode 100644 project_euler/problem_18/triangle.txt

diff --git a/project_euler/problem_18/solution.py b/project_euler/problem_18/solution.py
new file mode 100644
index 000000000000..f9762e8b0176
--- /dev/null
+++ b/project_euler/problem_18/solution.py
@@ -0,0 +1,64 @@
+"""
+By starting at the top of the triangle below and moving to adjacent numbers on
+the row below, the maximum total from top to bottom is 23.
+
+3
+7 4
+2 4 6
+8 5 9 3
+
+That is, 3 + 7 + 4 + 9 = 23.
+
+Find the maximum total from top to bottom of the triangle below:
+
+75
+95 64
+17 47 82
+18 35 87 10
+20 04 82 47 65
+19 01 23 75 03 34
+88 02 77 73 07 63 67
+99 65 04 28 06 16 70 92
+41 41 26 56 83 40 80 70 33
+41 48 72 33 47 32 37 16 94 29
+53 71 44 65 25 43 91 52 97 51 14
+70 11 33 28 77 73 17 78 39 68 17 57
+91 71 52 38 17 14 91 43 58 50 27 29 48
+63 66 04 68 89 53 67 30 73 16 69 87 40 31
+04 62 98 27 23 09 70 98 73 93 38 53 60 04 23
+"""
+import os
+
+
+def solution():
+    """
+    Finds the maximum total in a triangle as described by the problem statement
+    above.
+
+    >>> solution()
+    1074
+    """
+    script_dir = os.path.dirname(os.path.realpath(__file__))
+    triangle = os.path.join(script_dir, 'triangle.txt')
+
+    with open(triangle, 'r') as f:
+        triangle = f.readlines()
+
+    a = [[int(y) for y in x.rstrip('\r\n').split(' ')] for x in triangle]
+
+    for i in range(1, len(a)):
+        for j in range(len(a[i])):
+            if j != len(a[i - 1]):
+                number1 = a[i - 1][j]
+            else:
+                number1 = 0
+            if j > 0:
+                number2 = a[i - 1][j - 1]
+            else:
+                number2 = 0
+            a[i][j] += max(number1, number2)
+    return max(a[-1])
+
+
+if __name__ == "__main__":
+    print(solution())
diff --git a/project_euler/problem_18/triangle.txt b/project_euler/problem_18/triangle.txt
new file mode 100644
index 000000000000..e236c2ff7ee2
--- /dev/null
+++ b/project_euler/problem_18/triangle.txt
@@ -0,0 +1,15 @@
+75
+95 64
+17 47 82
+18 35 87 10
+20 04 82 47 65
+19 01 23 75 03 34
+88 02 77 73 07 63 67
+99 65 04 28 06 16 70 92
+41 41 26 56 83 40 80 70 33
+41 48 72 33 47 32 37 16 94 29
+53 71 44 65 25 43 91 52 97 51 14
+70 11 33 28 77 73 17 78 39 68 17 57
+91 71 52 38 17 14 91 43 58 50 27 29 48
+63 66 04 68 89 53 67 30 73 16 69 87 40 31
+04 62 98 27 23 09 70 98 73 93 38 53 60 04 23

From 6e6920866662f314a9cbb125667c64e421046a4b Mon Sep 17 00:00:00 2001
From: Simon Landry <landry_simon@pm.me>
Date: Thu, 3 Oct 2019 16:47:39 -0400
Subject: [PATCH 233/348] Add problem 32 solution (#1257)

---
 project_euler/problem_32/solution.py | 62 ++++++++++++++++++++++++++++
 1 file changed, 62 insertions(+)
 create mode 100644 project_euler/problem_32/solution.py

diff --git a/project_euler/problem_32/solution.py b/project_euler/problem_32/solution.py
new file mode 100644
index 000000000000..fd5178303de3
--- /dev/null
+++ b/project_euler/problem_32/solution.py
@@ -0,0 +1,62 @@
+"""
+We shall say that an n-digit number is pandigital if it makes use of all the
+digits 1 to n exactly once; for example, the 5-digit number, 15234, is 1 through
+5 pandigital.
+
+The product 7254 is unusual, as the identity, 39 × 186 = 7254, containing
+multiplicand, multiplier, and product is 1 through 9 pandigital.
+
+Find the sum of all products whose multiplicand/multiplier/product identity can
+be written as a 1 through 9 pandigital.
+
+HINT: Some products can be obtained in more than one way so be sure to only
+include it once in your sum.
+"""
+import itertools
+
+
+def isCombinationValid(combination):
+    """
+    Checks if a combination (a tuple of 9 digits)
+    is a valid product equation.
+
+    >>> isCombinationValid(('3', '9', '1', '8', '6', '7', '2', '5', '4'))
+    True
+
+    >>> isCombinationValid(('1', '2', '3', '4', '5', '6', '7', '8', '9'))
+    False
+
+    """
+    return (
+        int(''.join(combination[0:2])) *
+        int(''.join(combination[2:5])) ==
+        int(''.join(combination[5:9]))
+    ) or (
+        int(''.join(combination[0])) *
+        int(''.join(combination[1:5])) ==
+        int(''.join(combination[5:9]))
+    )
+
+
+def solution():
+    """
+    Finds the sum of all products whose multiplicand/multiplier/product identity
+    can be written as a 1 through 9 pandigital
+
+    >>> solution()
+    45228
+    """
+
+    return sum(
+        set(
+            [
+                int(''.join(pandigital[5:9]))
+                for pandigital
+                in itertools.permutations('123456789')
+                if isCombinationValid(pandigital)
+            ]
+        )
+    )
+
+if __name__ == "__main__":
+    print(solution())

From 309204a5813cae19e2397f5aeb27fefb7dfac514 Mon Sep 17 00:00:00 2001
From: Simon Landry <landry_simon@pm.me>
Date: Thu, 3 Oct 2019 16:48:53 -0400
Subject: [PATCH 234/348] Add problem 42 solution (#1259)

---
 project_euler/problem_42/solution.py | 50 ++++++++++++++++++++++++++++
 project_euler/problem_42/words.txt   |  1 +
 2 files changed, 51 insertions(+)
 create mode 100644 project_euler/problem_42/solution.py
 create mode 100644 project_euler/problem_42/words.txt

diff --git a/project_euler/problem_42/solution.py b/project_euler/problem_42/solution.py
new file mode 100644
index 000000000000..ff976545055d
--- /dev/null
+++ b/project_euler/problem_42/solution.py
@@ -0,0 +1,50 @@
+"""
+The nth term of the sequence of triangle numbers is given by, tn = ½n(n+1); so
+the first ten triangle numbers are:
+
+1, 3, 6, 10, 15, 21, 28, 36, 45, 55, ...
+
+By converting each letter in a word to a number corresponding to its
+alphabetical position and adding these values we form a word value. For example,
+the word value for SKY is 19 + 11 + 25 = 55 = t10. If the word value is a
+triangle number then we shall call the word a triangle word.
+
+Using words.txt (right click and 'Save Link/Target As...'), a 16K text file
+containing nearly two-thousand common English words, how many are triangle
+words?
+"""
+import os
+
+
+# Precomputes a list of the 100 first triangular numbers
+TRIANGULAR_NUMBERS = [int(0.5 * n * (n + 1)) for n in range(1, 101)]
+
+
+def solution():
+    """
+    Finds the amount of triangular words in the words file.
+
+    >>> solution()
+    162
+    """
+    script_dir = os.path.dirname(os.path.realpath(__file__))
+    wordsFilePath = os.path.join(script_dir, 'words.txt')
+
+    words = ''
+    with open(wordsFilePath, 'r') as f:
+        words = f.readline()
+
+    words = list(map(lambda word: word.strip('"'), words.strip('\r\n').split(',')))
+    words = list(
+        filter(
+            lambda word: word in TRIANGULAR_NUMBERS,
+            map(
+                lambda word: sum(map(lambda x: ord(x) - 64, word)),
+                words
+            )
+        )
+    )
+    return len(words)
+
+if __name__ == '__main__':
+    print(solution())
diff --git a/project_euler/problem_42/words.txt b/project_euler/problem_42/words.txt
new file mode 100644
index 000000000000..af3aeb42f151
--- /dev/null
+++ b/project_euler/problem_42/words.txt
@@ -0,0 +1 @@
+"A","ABILITY","ABLE","ABOUT","ABOVE","ABSENCE","ABSOLUTELY","ACADEMIC","ACCEPT","ACCESS","ACCIDENT","ACCOMPANY","ACCORDING","ACCOUNT","ACHIEVE","ACHIEVEMENT","ACID","ACQUIRE","ACROSS","ACT","ACTION","ACTIVE","ACTIVITY","ACTUAL","ACTUALLY","ADD","ADDITION","ADDITIONAL","ADDRESS","ADMINISTRATION","ADMIT","ADOPT","ADULT","ADVANCE","ADVANTAGE","ADVICE","ADVISE","AFFAIR","AFFECT","AFFORD","AFRAID","AFTER","AFTERNOON","AFTERWARDS","AGAIN","AGAINST","AGE","AGENCY","AGENT","AGO","AGREE","AGREEMENT","AHEAD","AID","AIM","AIR","AIRCRAFT","ALL","ALLOW","ALMOST","ALONE","ALONG","ALREADY","ALRIGHT","ALSO","ALTERNATIVE","ALTHOUGH","ALWAYS","AMONG","AMONGST","AMOUNT","AN","ANALYSIS","ANCIENT","AND","ANIMAL","ANNOUNCE","ANNUAL","ANOTHER","ANSWER","ANY","ANYBODY","ANYONE","ANYTHING","ANYWAY","APART","APPARENT","APPARENTLY","APPEAL","APPEAR","APPEARANCE","APPLICATION","APPLY","APPOINT","APPOINTMENT","APPROACH","APPROPRIATE","APPROVE","AREA","ARGUE","ARGUMENT","ARISE","ARM","ARMY","AROUND","ARRANGE","ARRANGEMENT","ARRIVE","ART","ARTICLE","ARTIST","AS","ASK","ASPECT","ASSEMBLY","ASSESS","ASSESSMENT","ASSET","ASSOCIATE","ASSOCIATION","ASSUME","ASSUMPTION","AT","ATMOSPHERE","ATTACH","ATTACK","ATTEMPT","ATTEND","ATTENTION","ATTITUDE","ATTRACT","ATTRACTIVE","AUDIENCE","AUTHOR","AUTHORITY","AVAILABLE","AVERAGE","AVOID","AWARD","AWARE","AWAY","AYE","BABY","BACK","BACKGROUND","BAD","BAG","BALANCE","BALL","BAND","BANK","BAR","BASE","BASIC","BASIS","BATTLE","BE","BEAR","BEAT","BEAUTIFUL","BECAUSE","BECOME","BED","BEDROOM","BEFORE","BEGIN","BEGINNING","BEHAVIOUR","BEHIND","BELIEF","BELIEVE","BELONG","BELOW","BENEATH","BENEFIT","BESIDE","BEST","BETTER","BETWEEN","BEYOND","BIG","BILL","BIND","BIRD","BIRTH","BIT","BLACK","BLOCK","BLOOD","BLOODY","BLOW","BLUE","BOARD","BOAT","BODY","BONE","BOOK","BORDER","BOTH","BOTTLE","BOTTOM","BOX","BOY","BRAIN","BRANCH","BREAK","BREATH","BRIDGE","BRIEF","BRIGHT","BRING","BROAD","BROTHER","BUDGET","BUILD","BUILDING","BURN","BUS","BUSINESS","BUSY","BUT","BUY","BY","CABINET","CALL","CAMPAIGN","CAN","CANDIDATE","CAPABLE","CAPACITY","CAPITAL","CAR","CARD","CARE","CAREER","CAREFUL","CAREFULLY","CARRY","CASE","CASH","CAT","CATCH","CATEGORY","CAUSE","CELL","CENTRAL","CENTRE","CENTURY","CERTAIN","CERTAINLY","CHAIN","CHAIR","CHAIRMAN","CHALLENGE","CHANCE","CHANGE","CHANNEL","CHAPTER","CHARACTER","CHARACTERISTIC","CHARGE","CHEAP","CHECK","CHEMICAL","CHIEF","CHILD","CHOICE","CHOOSE","CHURCH","CIRCLE","CIRCUMSTANCE","CITIZEN","CITY","CIVIL","CLAIM","CLASS","CLEAN","CLEAR","CLEARLY","CLIENT","CLIMB","CLOSE","CLOSELY","CLOTHES","CLUB","COAL","CODE","COFFEE","COLD","COLLEAGUE","COLLECT","COLLECTION","COLLEGE","COLOUR","COMBINATION","COMBINE","COME","COMMENT","COMMERCIAL","COMMISSION","COMMIT","COMMITMENT","COMMITTEE","COMMON","COMMUNICATION","COMMUNITY","COMPANY","COMPARE","COMPARISON","COMPETITION","COMPLETE","COMPLETELY","COMPLEX","COMPONENT","COMPUTER","CONCENTRATE","CONCENTRATION","CONCEPT","CONCERN","CONCERNED","CONCLUDE","CONCLUSION","CONDITION","CONDUCT","CONFERENCE","CONFIDENCE","CONFIRM","CONFLICT","CONGRESS","CONNECT","CONNECTION","CONSEQUENCE","CONSERVATIVE","CONSIDER","CONSIDERABLE","CONSIDERATION","CONSIST","CONSTANT","CONSTRUCTION","CONSUMER","CONTACT","CONTAIN","CONTENT","CONTEXT","CONTINUE","CONTRACT","CONTRAST","CONTRIBUTE","CONTRIBUTION","CONTROL","CONVENTION","CONVERSATION","COPY","CORNER","CORPORATE","CORRECT","COS","COST","COULD","COUNCIL","COUNT","COUNTRY","COUNTY","COUPLE","COURSE","COURT","COVER","CREATE","CREATION","CREDIT","CRIME","CRIMINAL","CRISIS","CRITERION","CRITICAL","CRITICISM","CROSS","CROWD","CRY","CULTURAL","CULTURE","CUP","CURRENT","CURRENTLY","CURRICULUM","CUSTOMER","CUT","DAMAGE","DANGER","DANGEROUS","DARK","DATA","DATE","DAUGHTER","DAY","DEAD","DEAL","DEATH","DEBATE","DEBT","DECADE","DECIDE","DECISION","DECLARE","DEEP","DEFENCE","DEFENDANT","DEFINE","DEFINITION","DEGREE","DELIVER","DEMAND","DEMOCRATIC","DEMONSTRATE","DENY","DEPARTMENT","DEPEND","DEPUTY","DERIVE","DESCRIBE","DESCRIPTION","DESIGN","DESIRE","DESK","DESPITE","DESTROY","DETAIL","DETAILED","DETERMINE","DEVELOP","DEVELOPMENT","DEVICE","DIE","DIFFERENCE","DIFFERENT","DIFFICULT","DIFFICULTY","DINNER","DIRECT","DIRECTION","DIRECTLY","DIRECTOR","DISAPPEAR","DISCIPLINE","DISCOVER","DISCUSS","DISCUSSION","DISEASE","DISPLAY","DISTANCE","DISTINCTION","DISTRIBUTION","DISTRICT","DIVIDE","DIVISION","DO","DOCTOR","DOCUMENT","DOG","DOMESTIC","DOOR","DOUBLE","DOUBT","DOWN","DRAW","DRAWING","DREAM","DRESS","DRINK","DRIVE","DRIVER","DROP","DRUG","DRY","DUE","DURING","DUTY","EACH","EAR","EARLY","EARN","EARTH","EASILY","EAST","EASY","EAT","ECONOMIC","ECONOMY","EDGE","EDITOR","EDUCATION","EDUCATIONAL","EFFECT","EFFECTIVE","EFFECTIVELY","EFFORT","EGG","EITHER","ELDERLY","ELECTION","ELEMENT","ELSE","ELSEWHERE","EMERGE","EMPHASIS","EMPLOY","EMPLOYEE","EMPLOYER","EMPLOYMENT","EMPTY","ENABLE","ENCOURAGE","END","ENEMY","ENERGY","ENGINE","ENGINEERING","ENJOY","ENOUGH","ENSURE","ENTER","ENTERPRISE","ENTIRE","ENTIRELY","ENTITLE","ENTRY","ENVIRONMENT","ENVIRONMENTAL","EQUAL","EQUALLY","EQUIPMENT","ERROR","ESCAPE","ESPECIALLY","ESSENTIAL","ESTABLISH","ESTABLISHMENT","ESTATE","ESTIMATE","EVEN","EVENING","EVENT","EVENTUALLY","EVER","EVERY","EVERYBODY","EVERYONE","EVERYTHING","EVIDENCE","EXACTLY","EXAMINATION","EXAMINE","EXAMPLE","EXCELLENT","EXCEPT","EXCHANGE","EXECUTIVE","EXERCISE","EXHIBITION","EXIST","EXISTENCE","EXISTING","EXPECT","EXPECTATION","EXPENDITURE","EXPENSE","EXPENSIVE","EXPERIENCE","EXPERIMENT","EXPERT","EXPLAIN","EXPLANATION","EXPLORE","EXPRESS","EXPRESSION","EXTEND","EXTENT","EXTERNAL","EXTRA","EXTREMELY","EYE","FACE","FACILITY","FACT","FACTOR","FACTORY","FAIL","FAILURE","FAIR","FAIRLY","FAITH","FALL","FAMILIAR","FAMILY","FAMOUS","FAR","FARM","FARMER","FASHION","FAST","FATHER","FAVOUR","FEAR","FEATURE","FEE","FEEL","FEELING","FEMALE","FEW","FIELD","FIGHT","FIGURE","FILE","FILL","FILM","FINAL","FINALLY","FINANCE","FINANCIAL","FIND","FINDING","FINE","FINGER","FINISH","FIRE","FIRM","FIRST","FISH","FIT","FIX","FLAT","FLIGHT","FLOOR","FLOW","FLOWER","FLY","FOCUS","FOLLOW","FOLLOWING","FOOD","FOOT","FOOTBALL","FOR","FORCE","FOREIGN","FOREST","FORGET","FORM","FORMAL","FORMER","FORWARD","FOUNDATION","FREE","FREEDOM","FREQUENTLY","FRESH","FRIEND","FROM","FRONT","FRUIT","FUEL","FULL","FULLY","FUNCTION","FUND","FUNNY","FURTHER","FUTURE","GAIN","GAME","GARDEN","GAS","GATE","GATHER","GENERAL","GENERALLY","GENERATE","GENERATION","GENTLEMAN","GET","GIRL","GIVE","GLASS","GO","GOAL","GOD","GOLD","GOOD","GOVERNMENT","GRANT","GREAT","GREEN","GREY","GROUND","GROUP","GROW","GROWING","GROWTH","GUEST","GUIDE","GUN","HAIR","HALF","HALL","HAND","HANDLE","HANG","HAPPEN","HAPPY","HARD","HARDLY","HATE","HAVE","HE","HEAD","HEALTH","HEAR","HEART","HEAT","HEAVY","HELL","HELP","HENCE","HER","HERE","HERSELF","HIDE","HIGH","HIGHLY","HILL","HIM","HIMSELF","HIS","HISTORICAL","HISTORY","HIT","HOLD","HOLE","HOLIDAY","HOME","HOPE","HORSE","HOSPITAL","HOT","HOTEL","HOUR","HOUSE","HOUSEHOLD","HOUSING","HOW","HOWEVER","HUGE","HUMAN","HURT","HUSBAND","I","IDEA","IDENTIFY","IF","IGNORE","ILLUSTRATE","IMAGE","IMAGINE","IMMEDIATE","IMMEDIATELY","IMPACT","IMPLICATION","IMPLY","IMPORTANCE","IMPORTANT","IMPOSE","IMPOSSIBLE","IMPRESSION","IMPROVE","IMPROVEMENT","IN","INCIDENT","INCLUDE","INCLUDING","INCOME","INCREASE","INCREASED","INCREASINGLY","INDEED","INDEPENDENT","INDEX","INDICATE","INDIVIDUAL","INDUSTRIAL","INDUSTRY","INFLUENCE","INFORM","INFORMATION","INITIAL","INITIATIVE","INJURY","INSIDE","INSIST","INSTANCE","INSTEAD","INSTITUTE","INSTITUTION","INSTRUCTION","INSTRUMENT","INSURANCE","INTEND","INTENTION","INTEREST","INTERESTED","INTERESTING","INTERNAL","INTERNATIONAL","INTERPRETATION","INTERVIEW","INTO","INTRODUCE","INTRODUCTION","INVESTIGATE","INVESTIGATION","INVESTMENT","INVITE","INVOLVE","IRON","IS","ISLAND","ISSUE","IT","ITEM","ITS","ITSELF","JOB","JOIN","JOINT","JOURNEY","JUDGE","JUMP","JUST","JUSTICE","KEEP","KEY","KID","KILL","KIND","KING","KITCHEN","KNEE","KNOW","KNOWLEDGE","LABOUR","LACK","LADY","LAND","LANGUAGE","LARGE","LARGELY","LAST","LATE","LATER","LATTER","LAUGH","LAUNCH","LAW","LAWYER","LAY","LEAD","LEADER","LEADERSHIP","LEADING","LEAF","LEAGUE","LEAN","LEARN","LEAST","LEAVE","LEFT","LEG","LEGAL","LEGISLATION","LENGTH","LESS","LET","LETTER","LEVEL","LIABILITY","LIBERAL","LIBRARY","LIE","LIFE","LIFT","LIGHT","LIKE","LIKELY","LIMIT","LIMITED","LINE","LINK","LIP","LIST","LISTEN","LITERATURE","LITTLE","LIVE","LIVING","LOAN","LOCAL","LOCATION","LONG","LOOK","LORD","LOSE","LOSS","LOT","LOVE","LOVELY","LOW","LUNCH","MACHINE","MAGAZINE","MAIN","MAINLY","MAINTAIN","MAJOR","MAJORITY","MAKE","MALE","MAN","MANAGE","MANAGEMENT","MANAGER","MANNER","MANY","MAP","MARK","MARKET","MARRIAGE","MARRIED","MARRY","MASS","MASTER","MATCH","MATERIAL","MATTER","MAY","MAYBE","ME","MEAL","MEAN","MEANING","MEANS","MEANWHILE","MEASURE","MECHANISM","MEDIA","MEDICAL","MEET","MEETING","MEMBER","MEMBERSHIP","MEMORY","MENTAL","MENTION","MERELY","MESSAGE","METAL","METHOD","MIDDLE","MIGHT","MILE","MILITARY","MILK","MIND","MINE","MINISTER","MINISTRY","MINUTE","MISS","MISTAKE","MODEL","MODERN","MODULE","MOMENT","MONEY","MONTH","MORE","MORNING","MOST","MOTHER","MOTION","MOTOR","MOUNTAIN","MOUTH","MOVE","MOVEMENT","MUCH","MURDER","MUSEUM","MUSIC","MUST","MY","MYSELF","NAME","NARROW","NATION","NATIONAL","NATURAL","NATURE","NEAR","NEARLY","NECESSARILY","NECESSARY","NECK","NEED","NEGOTIATION","NEIGHBOUR","NEITHER","NETWORK","NEVER","NEVERTHELESS","NEW","NEWS","NEWSPAPER","NEXT","NICE","NIGHT","NO","NOBODY","NOD","NOISE","NONE","NOR","NORMAL","NORMALLY","NORTH","NORTHERN","NOSE","NOT","NOTE","NOTHING","NOTICE","NOTION","NOW","NUCLEAR","NUMBER","NURSE","OBJECT","OBJECTIVE","OBSERVATION","OBSERVE","OBTAIN","OBVIOUS","OBVIOUSLY","OCCASION","OCCUR","ODD","OF","OFF","OFFENCE","OFFER","OFFICE","OFFICER","OFFICIAL","OFTEN","OIL","OKAY","OLD","ON","ONCE","ONE","ONLY","ONTO","OPEN","OPERATE","OPERATION","OPINION","OPPORTUNITY","OPPOSITION","OPTION","OR","ORDER","ORDINARY","ORGANISATION","ORGANISE","ORGANIZATION","ORIGIN","ORIGINAL","OTHER","OTHERWISE","OUGHT","OUR","OURSELVES","OUT","OUTCOME","OUTPUT","OUTSIDE","OVER","OVERALL","OWN","OWNER","PACKAGE","PAGE","PAIN","PAINT","PAINTING","PAIR","PANEL","PAPER","PARENT","PARK","PARLIAMENT","PART","PARTICULAR","PARTICULARLY","PARTLY","PARTNER","PARTY","PASS","PASSAGE","PAST","PATH","PATIENT","PATTERN","PAY","PAYMENT","PEACE","PENSION","PEOPLE","PER","PERCENT","PERFECT","PERFORM","PERFORMANCE","PERHAPS","PERIOD","PERMANENT","PERSON","PERSONAL","PERSUADE","PHASE","PHONE","PHOTOGRAPH","PHYSICAL","PICK","PICTURE","PIECE","PLACE","PLAN","PLANNING","PLANT","PLASTIC","PLATE","PLAY","PLAYER","PLEASE","PLEASURE","PLENTY","PLUS","POCKET","POINT","POLICE","POLICY","POLITICAL","POLITICS","POOL","POOR","POPULAR","POPULATION","POSITION","POSITIVE","POSSIBILITY","POSSIBLE","POSSIBLY","POST","POTENTIAL","POUND","POWER","POWERFUL","PRACTICAL","PRACTICE","PREFER","PREPARE","PRESENCE","PRESENT","PRESIDENT","PRESS","PRESSURE","PRETTY","PREVENT","PREVIOUS","PREVIOUSLY","PRICE","PRIMARY","PRIME","PRINCIPLE","PRIORITY","PRISON","PRISONER","PRIVATE","PROBABLY","PROBLEM","PROCEDURE","PROCESS","PRODUCE","PRODUCT","PRODUCTION","PROFESSIONAL","PROFIT","PROGRAM","PROGRAMME","PROGRESS","PROJECT","PROMISE","PROMOTE","PROPER","PROPERLY","PROPERTY","PROPORTION","PROPOSE","PROPOSAL","PROSPECT","PROTECT","PROTECTION","PROVE","PROVIDE","PROVIDED","PROVISION","PUB","PUBLIC","PUBLICATION","PUBLISH","PULL","PUPIL","PURPOSE","PUSH","PUT","QUALITY","QUARTER","QUESTION","QUICK","QUICKLY","QUIET","QUITE","RACE","RADIO","RAILWAY","RAIN","RAISE","RANGE","RAPIDLY","RARE","RATE","RATHER","REACH","REACTION","READ","READER","READING","READY","REAL","REALISE","REALITY","REALIZE","REALLY","REASON","REASONABLE","RECALL","RECEIVE","RECENT","RECENTLY","RECOGNISE","RECOGNITION","RECOGNIZE","RECOMMEND","RECORD","RECOVER","RED","REDUCE","REDUCTION","REFER","REFERENCE","REFLECT","REFORM","REFUSE","REGARD","REGION","REGIONAL","REGULAR","REGULATION","REJECT","RELATE","RELATION","RELATIONSHIP","RELATIVE","RELATIVELY","RELEASE","RELEVANT","RELIEF","RELIGION","RELIGIOUS","RELY","REMAIN","REMEMBER","REMIND","REMOVE","REPEAT","REPLACE","REPLY","REPORT","REPRESENT","REPRESENTATION","REPRESENTATIVE","REQUEST","REQUIRE","REQUIREMENT","RESEARCH","RESOURCE","RESPECT","RESPOND","RESPONSE","RESPONSIBILITY","RESPONSIBLE","REST","RESTAURANT","RESULT","RETAIN","RETURN","REVEAL","REVENUE","REVIEW","REVOLUTION","RICH","RIDE","RIGHT","RING","RISE","RISK","RIVER","ROAD","ROCK","ROLE","ROLL","ROOF","ROOM","ROUND","ROUTE","ROW","ROYAL","RULE","RUN","RURAL","SAFE","SAFETY","SALE","SAME","SAMPLE","SATISFY","SAVE","SAY","SCALE","SCENE","SCHEME","SCHOOL","SCIENCE","SCIENTIFIC","SCIENTIST","SCORE","SCREEN","SEA","SEARCH","SEASON","SEAT","SECOND","SECONDARY","SECRETARY","SECTION","SECTOR","SECURE","SECURITY","SEE","SEEK","SEEM","SELECT","SELECTION","SELL","SEND","SENIOR","SENSE","SENTENCE","SEPARATE","SEQUENCE","SERIES","SERIOUS","SERIOUSLY","SERVANT","SERVE","SERVICE","SESSION","SET","SETTLE","SETTLEMENT","SEVERAL","SEVERE","SEX","SEXUAL","SHAKE","SHALL","SHAPE","SHARE","SHE","SHEET","SHIP","SHOE","SHOOT","SHOP","SHORT","SHOT","SHOULD","SHOULDER","SHOUT","SHOW","SHUT","SIDE","SIGHT","SIGN","SIGNAL","SIGNIFICANCE","SIGNIFICANT","SILENCE","SIMILAR","SIMPLE","SIMPLY","SINCE","SING","SINGLE","SIR","SISTER","SIT","SITE","SITUATION","SIZE","SKILL","SKIN","SKY","SLEEP","SLIGHTLY","SLIP","SLOW","SLOWLY","SMALL","SMILE","SO","SOCIAL","SOCIETY","SOFT","SOFTWARE","SOIL","SOLDIER","SOLICITOR","SOLUTION","SOME","SOMEBODY","SOMEONE","SOMETHING","SOMETIMES","SOMEWHAT","SOMEWHERE","SON","SONG","SOON","SORRY","SORT","SOUND","SOURCE","SOUTH","SOUTHERN","SPACE","SPEAK","SPEAKER","SPECIAL","SPECIES","SPECIFIC","SPEECH","SPEED","SPEND","SPIRIT","SPORT","SPOT","SPREAD","SPRING","STAFF","STAGE","STAND","STANDARD","STAR","START","STATE","STATEMENT","STATION","STATUS","STAY","STEAL","STEP","STICK","STILL","STOCK","STONE","STOP","STORE","STORY","STRAIGHT","STRANGE","STRATEGY","STREET","STRENGTH","STRIKE","STRONG","STRONGLY","STRUCTURE","STUDENT","STUDIO","STUDY","STUFF","STYLE","SUBJECT","SUBSTANTIAL","SUCCEED","SUCCESS","SUCCESSFUL","SUCH","SUDDENLY","SUFFER","SUFFICIENT","SUGGEST","SUGGESTION","SUITABLE","SUM","SUMMER","SUN","SUPPLY","SUPPORT","SUPPOSE","SURE","SURELY","SURFACE","SURPRISE","SURROUND","SURVEY","SURVIVE","SWITCH","SYSTEM","TABLE","TAKE","TALK","TALL","TAPE","TARGET","TASK","TAX","TEA","TEACH","TEACHER","TEACHING","TEAM","TEAR","TECHNICAL","TECHNIQUE","TECHNOLOGY","TELEPHONE","TELEVISION","TELL","TEMPERATURE","TEND","TERM","TERMS","TERRIBLE","TEST","TEXT","THAN","THANK","THANKS","THAT","THE","THEATRE","THEIR","THEM","THEME","THEMSELVES","THEN","THEORY","THERE","THEREFORE","THESE","THEY","THIN","THING","THINK","THIS","THOSE","THOUGH","THOUGHT","THREAT","THREATEN","THROUGH","THROUGHOUT","THROW","THUS","TICKET","TIME","TINY","TITLE","TO","TODAY","TOGETHER","TOMORROW","TONE","TONIGHT","TOO","TOOL","TOOTH","TOP","TOTAL","TOTALLY","TOUCH","TOUR","TOWARDS","TOWN","TRACK","TRADE","TRADITION","TRADITIONAL","TRAFFIC","TRAIN","TRAINING","TRANSFER","TRANSPORT","TRAVEL","TREAT","TREATMENT","TREATY","TREE","TREND","TRIAL","TRIP","TROOP","TROUBLE","TRUE","TRUST","TRUTH","TRY","TURN","TWICE","TYPE","TYPICAL","UNABLE","UNDER","UNDERSTAND","UNDERSTANDING","UNDERTAKE","UNEMPLOYMENT","UNFORTUNATELY","UNION","UNIT","UNITED","UNIVERSITY","UNLESS","UNLIKELY","UNTIL","UP","UPON","UPPER","URBAN","US","USE","USED","USEFUL","USER","USUAL","USUALLY","VALUE","VARIATION","VARIETY","VARIOUS","VARY","VAST","VEHICLE","VERSION","VERY","VIA","VICTIM","VICTORY","VIDEO","VIEW","VILLAGE","VIOLENCE","VISION","VISIT","VISITOR","VITAL","VOICE","VOLUME","VOTE","WAGE","WAIT","WALK","WALL","WANT","WAR","WARM","WARN","WASH","WATCH","WATER","WAVE","WAY","WE","WEAK","WEAPON","WEAR","WEATHER","WEEK","WEEKEND","WEIGHT","WELCOME","WELFARE","WELL","WEST","WESTERN","WHAT","WHATEVER","WHEN","WHERE","WHEREAS","WHETHER","WHICH","WHILE","WHILST","WHITE","WHO","WHOLE","WHOM","WHOSE","WHY","WIDE","WIDELY","WIFE","WILD","WILL","WIN","WIND","WINDOW","WINE","WING","WINNER","WINTER","WISH","WITH","WITHDRAW","WITHIN","WITHOUT","WOMAN","WONDER","WONDERFUL","WOOD","WORD","WORK","WORKER","WORKING","WORKS","WORLD","WORRY","WORTH","WOULD","WRITE","WRITER","WRITING","WRONG","YARD","YEAH","YEAR","YES","YESTERDAY","YET","YOU","YOUNG","YOUR","YOURSELF","YOUTH"

From 07f04a2e5523f91954d7c468e94b395457ea3b7d Mon Sep 17 00:00:00 2001
From: Kaushik Amar Das <cozek@users.noreply.github.com>
Date: Fri, 4 Oct 2019 13:29:45 +0530
Subject: [PATCH 235/348] adding jaccard similarity (#1270)

* adding jaccard similarity

* renaming files. zeebus! what an headache
---
 maths/jaccard_similarity.py                   | 80 +++++++++++++++++++
 .../problem_32/{solution.py => sol32.py}      |  0
 .../problem_42/{solution.py => solution42.py} |  0
 3 files changed, 80 insertions(+)
 create mode 100644 maths/jaccard_similarity.py
 rename project_euler/problem_32/{solution.py => sol32.py} (100%)
 rename project_euler/problem_42/{solution.py => solution42.py} (100%)

diff --git a/maths/jaccard_similarity.py b/maths/jaccard_similarity.py
new file mode 100644
index 000000000000..4f24d308f340
--- /dev/null
+++ b/maths/jaccard_similarity.py
@@ -0,0 +1,80 @@
+"""
+The Jaccard similarity coefficient is a commonly used indicator of the
+similarity between two sets. Let U be a set and A and B be subsets of U,
+then the Jaccard index/similarity is defined to be the ratio of the number
+of elements of their intersection and the number of elements of their union.
+
+Inspired from Wikipedia and
+the book Mining of Massive Datasets [MMDS 2nd Edition, Chapter 3]
+
+https://en.wikipedia.org/wiki/Jaccard_index
+https://mmds.org
+
+Jaccard similarity is widely used with MinHashing.
+"""
+
+
+def jaccard_similariy(setA, setB, alternativeUnion=False):
+    """
+    Finds the jaccard similarity between two sets.
+    Essentially, its intersection over union.
+
+    The alternative way to calculate this is to take union as sum of the
+    number of items in the two sets. This will lead to jaccard similarity
+    of a set with itself be 1/2 instead of 1. [MMDS 2nd Edition, Page 77]
+
+    Parameters:
+        :setA (set,list,tuple): A non-empty set/list
+        :setB (set,list,tuple): A non-empty set/list
+        :alternativeUnion (boolean): If True, use sum of number of
+        items as union
+
+    Output:
+        (float) The jaccard similarity between the two sets.
+
+    Examples:
+    >>> setA = {'a', 'b', 'c', 'd', 'e'}
+    >>> setB = {'c', 'd', 'e', 'f', 'h', 'i'}
+    >>> jaccard_similariy(setA,setB)
+    0.375
+
+    >>> jaccard_similariy(setA,setA)
+    1.0
+
+    >>> jaccard_similariy(setA,setA,True)
+    0.5
+
+    >>> setA = ['a', 'b', 'c', 'd', 'e']
+    >>> setB = ('c', 'd', 'e', 'f', 'h', 'i')
+    >>> jaccard_similariy(setA,setB)
+    0.375
+    """
+
+    if isinstance(setA, set) and isinstance(setB, set):
+
+        intersection = len(setA.intersection(setB))
+
+        if alternativeUnion:
+            union = len(setA) + len(setB)
+        else:
+            union = len(setA.union(setB))
+
+        return intersection / union
+
+    if isinstance(setA, (list, tuple)) and isinstance(setB, (list, tuple)):
+
+        intersection = [element for element in setA if element in setB]
+
+        if alternativeUnion:
+            union = len(setA) + len(setB)
+        else:
+            union = setA + [element for element in setB if element not in setA]
+
+        return len(intersection) / len(union)
+
+
+if __name__ == "__main__":
+
+    setA = {"a", "b", "c", "d", "e"}
+    setB = {"c", "d", "e", "f", "h", "i"}
+    print(jaccard_similariy(setA, setB))
diff --git a/project_euler/problem_32/solution.py b/project_euler/problem_32/sol32.py
similarity index 100%
rename from project_euler/problem_32/solution.py
rename to project_euler/problem_32/sol32.py
diff --git a/project_euler/problem_42/solution.py b/project_euler/problem_42/solution42.py
similarity index 100%
rename from project_euler/problem_42/solution.py
rename to project_euler/problem_42/solution42.py

From 9eac17a4083ad08c4bb0520cb0b8e5ce385f9ce0 Mon Sep 17 00:00:00 2001
From: William Zhang <39932068+WilliamHYZhang@users.noreply.github.com>
Date: Sat, 5 Oct 2019 01:14:13 -0400
Subject: [PATCH 236/348] psf/black code formatting (#1277)

---
 arithmetic_analysis/bisection.py              |  13 +-
 arithmetic_analysis/in_static_equilibrium.py  |   7 +-
 arithmetic_analysis/intersection.py           |  21 +-
 arithmetic_analysis/lu_decomposition.py       |   4 +-
 arithmetic_analysis/newton_method.py          |   6 +-
 arithmetic_analysis/newton_raphson_method.py  |  23 +-
 backtracking/all_combinations.py              |   4 +-
 backtracking/all_permutations.py              |  34 +-
 backtracking/all_subsequences.py              |  28 +-
 backtracking/minimax.py                       |  40 +-
 backtracking/n_queens.py                      |  48 +-
 backtracking/sum_of_subsets.py                |  56 +-
 boolean_algebra/quine_mc_cluskey.py           | 241 ++---
 ciphers/affine_cipher.py                      |  70 +-
 ciphers/atbash.py                             |   8 +-
 ciphers/base16.py                             |  12 +-
 ciphers/base32.py                             |  12 +-
 ciphers/base64_cipher.py                      |  63 +-
 ciphers/base85.py                             |  12 +-
 ciphers/brute_force_caesar_cipher.py          |   5 +-
 ciphers/caesar_cipher.py                      |  25 +-
 ciphers/cryptomath_module.py                  |   5 +-
 ciphers/elgamal_key_generator.py              |  41 +-
 ciphers/hill_cipher.py                        |  62 +-
 ciphers/morse_code_implementation.py          |  95 +-
 ciphers/onepad_cipher.py                      |  14 +-
 ciphers/playfair_cipher.py                    |  60 +-
 ciphers/rabin_miller.py                       | 198 +++-
 ciphers/rot13.py                              |  14 +-
 ciphers/rsa_cipher.py                         |  72 +-
 ciphers/rsa_key_generator.py                  |  43 +-
 ciphers/simple_substitution_cipher.py         |  39 +-
 ciphers/trafid_cipher.py                      |  66 +-
 ciphers/transposition_cipher.py               |  32 +-
 ...ansposition_cipher_encrypt_decrypt_file.py |  30 +-
 ciphers/vigenere_cipher.py                    |  43 +-
 ciphers/xor_cipher.py                         | 172 ++--
 compression/burrows_wheeler.py                |  13 +-
 compression/huffman.py                        |   9 +-
 compression/peak_signal_to_noise_ratio.py     |  13 +-
 conversions/decimal_to_binary.py              |   1 +
 conversions/decimal_to_hexadecimal.py         |  43 +-
 conversions/decimal_to_octal.py               |   4 +-
 data_structures/binary_tree/avl_tree.py       | 142 ++-
 .../binary_tree/basic_binary_tree.py          |  22 +-
 .../binary_tree/binary_search_tree.py         | 144 +--
 data_structures/binary_tree/fenwick_tree.py   |  22 +-
 .../binary_tree/lazy_segment_tree.py          |  76 +-
 data_structures/binary_tree/lca.py            |   2 +-
 data_structures/binary_tree/red_black_tree.py |   1 -
 data_structures/binary_tree/segment_tree.py   |  36 +-
 data_structures/binary_tree/treap.py          |   1 +
 data_structures/hashing/double_hash.py        |  21 +-
 data_structures/hashing/hash_table.py         |  12 +-
 .../hashing/hash_table_with_linked_list.py    |  18 +-
 .../hashing/number_theory/prime_numbers.py    |  20 +-
 data_structures/hashing/quadratic_probing.py  |  13 +-
 data_structures/heap/binomial_heap.py         |  68 +-
 data_structures/heap/heap.py                  | 138 +--
 data_structures/linked_list/__init__.py       |   1 +
 .../linked_list/doubly_linked_list.py         |  65 +-
 .../linked_list/singly_linked_list.py         |  36 +-
 data_structures/linked_list/swap_nodes.py     |  13 +-
 data_structures/queue/double_ended_queue.py   |   6 +-
 data_structures/queue/queue_on_list.py        |  18 +-
 .../queue/queue_on_pseudo_stack.py            |  19 +-
 data_structures/stacks/__init__.py            |  35 +-
 .../stacks/balanced_parentheses.py            |  14 +-
 .../stacks/infix_to_postfix_conversion.py     |  33 +-
 .../stacks/infix_to_prefix_conversion.py      |  86 +-
 .../stacks/next_greater_element.py            |   5 +-
 data_structures/stacks/postfix_evaluation.py  |  48 +-
 data_structures/stacks/stack.py               |  22 +-
 data_structures/stacks/stock_span_problem.py  |  16 +-
 .../edge_detection/canny.py                   |  46 +-
 digital_image_processing/filters/convolve.py  |  12 +-
 .../filters/gaussian_filter.py                |  20 +-
 .../filters/median_filter.py                  |  10 +-
 .../filters/sobel_filter.py                   |  14 +-
 divide_and_conquer/closest_pair_of_points.py  |  43 +-
 divide_and_conquer/convex_hull.py             |  52 +-
 divide_and_conquer/inversions.py              |  14 +-
 divide_and_conquer/max_subarray_sum.py        |  11 +-
 dynamic_programming/bitmask.py                |  53 +-
 dynamic_programming/coin_change.py            |   4 +-
 dynamic_programming/edit_distance.py          |  81 +-
 dynamic_programming/factorial.py              |  26 +-
 dynamic_programming/fibonacci.py              |   8 +-
 dynamic_programming/floyd_warshall.py         |  49 +-
 dynamic_programming/fractional_knapsack.py    |  20 +-
 dynamic_programming/integer_partition.py      |  53 +-
 .../k_means_clustering_tensorflow.py          | 110 +-
 dynamic_programming/knapsack.py               |  61 +-
 .../longest_common_subsequence.py             |  10 +-
 .../longest_increasing_subsequence.py         |  71 +-
 ...longest_increasing_subsequence_o(nlogn).py |  48 +-
 dynamic_programming/longest_sub_array.py      |  22 +-
 dynamic_programming/matrix_chain_order.py     |  62 +-
 dynamic_programming/max_sub_array.py          |  86 +-
 dynamic_programming/minimum_partition.py      |  24 +-
 dynamic_programming/rod_cutting.py            | 113 ++-
 dynamic_programming/subset_generation.py      |  74 +-
 dynamic_programming/sum_of_subset.py          |  23 +-
 file_transfer/recieve_file.py                 |  14 +-
 file_transfer/send_file.py                    |  26 +-
 graphs/a_star.py                              |  62 +-
 graphs/articulation_points.py                 |  15 +-
 graphs/basic_graphs.py                        |   2 +-
 graphs/bellman_ford.py                        |  62 +-
 graphs/bfs.py                                 |  18 +-
 graphs/bfs_shortest_path.py                   |  30 +-
 graphs/breadth_first_search.py                |  11 +-
 graphs/check_bipartite_graph_bfs.py           |   5 +-
 graphs/check_bipartite_graph_dfs.py           |   4 +-
 graphs/depth_first_search.py                  |  13 +-
 graphs/dfs.py                                 |  22 +-
 graphs/dijkstra.py                            |   1 +
 graphs/dijkstra_2.py                          |  71 +-
 graphs/dijkstra_algorithm.py                  |  26 +-
 ...irected_and_undirected_(weighted)_graph.py | 949 +++++++++---------
 .../edmonds_karp_multiple_source_and_sink.py  |  35 +-
 ...n_path_and_circuit_for_undirected_graph.py |  30 +-
 graphs/even_tree.py                           |  14 +-
 graphs/finding_bridges.py                     |  19 +-
 graphs/graph_list.py                          |   8 +-
 graphs/graph_matrix.py                        |  20 +-
 graphs/graphs_floyd_warshall.py               | 151 +--
 graphs/kahns_algorithm_long.py                |   7 +-
 graphs/kahns_algorithm_topo.py                |   5 +-
 graphs/minimum_spanning_tree_kruskal.py       |  24 +-
 graphs/minimum_spanning_tree_prims.py         |  27 +-
 graphs/multi_hueristic_astar.py               | 503 ++++++----
 graphs/page_rank.py                           |  38 +-
 graphs/prim.py                                |   6 +-
 graphs/scc_kosaraju.py                        |  23 +-
 graphs/tarjans_scc.py                         |  10 +-
 hashes/chaos_machine.py                       | 112 ++-
 hashes/enigma_machine.py                      |   5 +-
 hashes/md5.py                                 | 142 ++-
 hashes/sha1.py                                |  67 +-
 linear_algebra/src/lib.py                     | 158 +--
 linear_algebra/src/tests.py                   | 129 ++-
 machine_learning/decision_tree.py             |  25 +-
 machine_learning/gradient_descent.py          |  46 +-
 machine_learning/k_means_clust.py             |  99 +-
 machine_learning/knn_sklearn.py               |  27 +-
 machine_learning/linear_regression.py         |  24 +-
 machine_learning/logistic_regression.py       |  47 +-
 .../random_forest_classification.py           |  74 +-
 .../random_forest_regression.py               |  15 +-
 machine_learning/scoring_functions.py         |  22 +-
 .../sequential_minimum_optimization.py        | 207 +++-
 maths/3n+1.py                                 |  25 +-
 maths/abs.py                                  |   2 +-
 maths/abs_max.py                              |  15 +-
 maths/abs_min.py                              |   6 +-
 maths/average_mean.py                         |   2 +-
 maths/average_median.py                       |   4 +-
 maths/basic_maths.py                          |   6 +-
 maths/binary_exponentiation.py                |   4 +-
 maths/collatz_sequence.py                     |  11 +-
 maths/extended_euclidean_algorithm.py         |   4 +-
 maths/factorial_recursive.py                  |   2 +-
 maths/fermat_little_theorem.py                |   4 +-
 maths/fibonacci.py                            |  23 +-
 maths/fibonacci_sequence_recursion.py         |   8 +-
 maths/find_lcm.py                             |  16 +-
 maths/find_max.py                             |  13 +-
 maths/find_min.py                             |   3 +-
 maths/gaussian.py                             |   2 -
 maths/greater_common_divisor.py               |   4 +-
 maths/lucas_series.py                         |   1 +
 maths/matrix_exponentiation.py                |   5 +-
 maths/modular_exponential.py                  |   2 +-
 maths/newton_raphson.py                       |  36 +-
 maths/polynomial_evaluation.py                |   2 +-
 maths/prime_check.py                          |  15 +-
 maths/radix2_fft.py                           |  68 +-
 maths/segmented_sieve.py                      |   2 +-
 maths/simpson_rule.py                         |  41 +-
 maths/trapezoidal_rule.py                     |  70 +-
 maths/zellers_congruence.py                   |  50 +-
 matrix/matrix_class.py                        |  10 +-
 matrix/matrix_operation.py                    |  53 +-
 ...h_fibonacci_using_matrix_exponentiation.py |   2 +
 matrix/searching_in_sorted_matrix.py          |  13 +-
 matrix/sherman_morrison.py                    |  59 +-
 matrix/spiral_print.py                        |   6 +-
 matrix/tests/test_matrix_operation.py         |  21 +-
 networking_flow/ford_fulkerson.py             |  43 +-
 .../back_propagation_neural_network.py        | 113 ++-
 neural_network/convolution_neural_network.py  | 312 +++---
 neural_network/perceptron.py                  |  73 +-
 other/anagrams.py                             |  23 +-
 other/binary_exponentiation.py                |   7 +-
 other/binary_exponentiation_2.py              |   6 +-
 other/detecting_english_programmatically.py   |  18 +-
 other/euclidean_gcd.py                        |   5 +-
 other/fischer_yates_shuffle.py                |  18 +-
 other/frequency_finder.py                     |  90 +-
 other/game_of_life.py                         |  87 +-
 other/linear_congruential_generator.py        |  12 +-
 other/nested_brackets.py                      |  16 +-
 other/palindrome.py                           |   4 +-
 other/password_generator.py                   |  11 +-
 other/primelib.py                             | 223 ++--
 other/sierpinski_triangle.py                  |  71 +-
 other/tower_of_hanoi.py                       |  21 +-
 other/two_sum.py                              |  16 +-
 other/word_patterns.py                        |  15 +-
 project_euler/problem_01/sol1.py              |   2 +
 project_euler/problem_01/sol3.py              |   2 +
 project_euler/problem_01/sol4.py              |   2 +
 project_euler/problem_01/sol6.py              |   2 +
 project_euler/problem_02/sol1.py              |   2 +
 project_euler/problem_02/sol2.py              |   2 +
 project_euler/problem_02/sol3.py              |   2 +
 project_euler/problem_04/sol1.py              |   6 +-
 project_euler/problem_04/sol2.py              |   2 +
 project_euler/problem_05/sol1.py              |   2 +
 project_euler/problem_06/sol1.py              |   2 +
 project_euler/problem_06/sol2.py              |   2 +
 project_euler/problem_07/sol2.py              |   2 +
 project_euler/problem_09/sol2.py              |   2 +
 project_euler/problem_09/sol3.py              |   2 +
 project_euler/problem_11/sol1.py              |  12 +-
 project_euler/problem_11/sol2.py              |  14 +-
 project_euler/problem_12/sol2.py              |  10 +-
 project_euler/problem_14/sol1.py              |  10 +-
 project_euler/problem_14/sol2.py              |   2 +
 project_euler/problem_15/sol1.py              |   4 +-
 project_euler/problem_18/solution.py          |   6 +-
 project_euler/problem_21/sol1.py              |   5 +-
 project_euler/problem_23/sol1.py              |   5 +-
 project_euler/problem_234/sol1.py             |  29 +-
 project_euler/problem_25/sol1.py              |   1 +
 project_euler/problem_29/solution.py          |   2 +
 project_euler/problem_31/sol1.py              |   2 +
 project_euler/problem_32/sol32.py             |  16 +-
 project_euler/problem_36/sol1.py              |   2 +
 project_euler/problem_40/sol1.py              |   2 +
 project_euler/problem_42/solution42.py        |  16 +-
 project_euler/problem_551/sol1.py             |   2 +-
 project_euler/problem_56/sol1.py              |  14 +-
 project_euler/problem_67/sol1.py              |   6 +-
 scripts/build_directory_md.py                 |   6 +-
 scripts/validate_filenames.py                 |   1 +
 searches/binary_search.py                     |  25 +-
 searches/interpolation_search.py              |  58 +-
 searches/jump_search.py                       |   9 +-
 searches/linear_search.py                     |  12 +-
 searches/quick_select.py                      |  23 +-
 searches/sentinel_linear_search.py            |  13 +-
 searches/tabu_search.py                       |  55 +-
 searches/ternary_search.py                    |  85 +-
 sorts/bitonic_sort.py                         |  16 +-
 sorts/bogo_sort.py                            |   7 +-
 sorts/bubble_sort.py                          |  16 +-
 sorts/bucket_sort.py                          |  18 +-
 sorts/cocktail_shaker_sort.py                 |  17 +-
 sorts/comb_sort.py                            |  11 +-
 sorts/counting_sort.py                        |  13 +-
 sorts/cycle_sort.py                           |   8 +-
 sorts/external_sort.py                        |  43 +-
 sorts/gnome_sort.py                           |   8 +-
 sorts/heap_sort.py                            |  16 +-
 sorts/insertion_sort.py                       |  18 +-
 sorts/merge_sort.py                           |  16 +-
 sorts/merge_sort_fastest.py                   |  14 +-
 sorts/odd_even_transposition_parallel.py      |  79 +-
 .../odd_even_transposition_single_threaded.py |   5 +-
 sorts/pancake_sort.py                         |  11 +-
 sorts/pigeon_sort.py                          |  30 +-
 sorts/quick_sort.py                           |  10 +-
 sorts/quick_sort_3_partition.py               |   9 +-
 sorts/radix_sort.py                           |  30 +-
 sorts/random_normal_distribution_quicksort.py |  74 +-
 sorts/random_pivot_quick_sort.py              |  23 +-
 sorts/selection_sort.py                       |  12 +-
 sorts/shell_sort.py                           |   9 +-
 sorts/stooge_sort.py                          |  29 +-
 sorts/topological_sort.py                     |   8 +-
 sorts/tree_sort.py                            |   4 +-
 sorts/wiggle_sort.py                          |   2 +-
 strings/boyer_moore_search.py                 |  23 +-
 strings/knuth_morris_pratt.py                 |   4 +-
 strings/levenshtein_distance.py               |  13 +-
 strings/manacher.py                           |  34 +-
 strings/min_cost_string_conversion.py         | 200 ++--
 strings/naive_string_search.py                |  27 +-
 traversals/binary_tree_traversals.py          |   1 +
 291 files changed, 6100 insertions(+), 4657 deletions(-)

diff --git a/arithmetic_analysis/bisection.py b/arithmetic_analysis/bisection.py
index 8bf3f09782a3..78582b025880 100644
--- a/arithmetic_analysis/bisection.py
+++ b/arithmetic_analysis/bisection.py
@@ -1,7 +1,9 @@
 import math
 
 
-def bisection(function, a, b):  # finds where the function becomes 0 in [a,b] using bolzano
+def bisection(
+    function, a, b
+):  # finds where the function becomes 0 in [a,b] using bolzano
 
     start = a
     end = b
@@ -9,13 +11,15 @@ def bisection(function, a, b):  # finds where the function becomes 0 in [a,b] us
         return a
     elif function(b) == 0:
         return b
-    elif function(a) * function(b) > 0:  # if none of these are root and they are both positive or negative,
+    elif (
+        function(a) * function(b) > 0
+    ):  # if none of these are root and they are both positive or negative,
         # then his algorithm can't find the root
         print("couldn't find root in [a,b]")
         return
     else:
         mid = start + (end - start) / 2.0
-        while abs(start - mid) > 10**-7:  # until we achieve precise equals to 10^-7
+        while abs(start - mid) > 10 ** -7:  # until we achieve precise equals to 10^-7
             if function(mid) == 0:
                 return mid
             elif function(mid) * function(start) < 0:
@@ -27,7 +31,8 @@ def bisection(function, a, b):  # finds where the function becomes 0 in [a,b] us
 
 
 def f(x):
-    return math.pow(x, 3) - 2*x - 5
+    return math.pow(x, 3) - 2 * x - 5
+
 
 if __name__ == "__main__":
     print(bisection(f, 1, 1000))
diff --git a/arithmetic_analysis/in_static_equilibrium.py b/arithmetic_analysis/in_static_equilibrium.py
index 48eb6135eba7..addaff888f7f 100644
--- a/arithmetic_analysis/in_static_equilibrium.py
+++ b/arithmetic_analysis/in_static_equilibrium.py
@@ -54,11 +54,8 @@ def in_static_equilibrium(
 if __name__ == "__main__":
     # Test to check if it works
     forces = array(
-        [
-            polar_force(718.4, 180 - 30),
-            polar_force(879.54, 45),
-            polar_force(100, -90)
-        ])
+        [polar_force(718.4, 180 - 30), polar_force(879.54, 45), polar_force(100, -90)]
+    )
 
     location = array([[0, 0], [0, 0], [0, 0]])
 
diff --git a/arithmetic_analysis/intersection.py b/arithmetic_analysis/intersection.py
index 2f25f76ebd96..0fdcfbf1943e 100644
--- a/arithmetic_analysis/intersection.py
+++ b/arithmetic_analysis/intersection.py
@@ -1,17 +1,24 @@
 import math
 
-def intersection(function,x0,x1): #function is the f we want to find its root and x0 and x1 are two random starting points
+
+def intersection(
+    function, x0, x1
+):  # function is the f we want to find its root and x0 and x1 are two random starting points
     x_n = x0
     x_n1 = x1
     while True:
-        x_n2 = x_n1-(function(x_n1)/((function(x_n1)-function(x_n))/(x_n1-x_n)))
-        if abs(x_n2 - x_n1) < 10**-5:
+        x_n2 = x_n1 - (
+            function(x_n1) / ((function(x_n1) - function(x_n)) / (x_n1 - x_n))
+        )
+        if abs(x_n2 - x_n1) < 10 ** -5:
             return x_n2
-        x_n=x_n1
-        x_n1=x_n2
+        x_n = x_n1
+        x_n1 = x_n2
+
 
 def f(x):
-    return math.pow(x , 3) - (2 * x) -5
+    return math.pow(x, 3) - (2 * x) - 5
+
 
 if __name__ == "__main__":
-    print(intersection(f,3,3.5))
+    print(intersection(f, 3, 3.5))
diff --git a/arithmetic_analysis/lu_decomposition.py b/arithmetic_analysis/lu_decomposition.py
index 19e259afb826..4372621d74cb 100644
--- a/arithmetic_analysis/lu_decomposition.py
+++ b/arithmetic_analysis/lu_decomposition.py
@@ -28,9 +28,7 @@ def LUDecompose(table):
 
 
 if __name__ == "__main__":
-    matrix = numpy.array([[2, -2, 1],
-                          [0, 1, 2],
-                          [5, 3, 1]])
+    matrix = numpy.array([[2, -2, 1], [0, 1, 2], [5, 3, 1]])
     L, U = LUDecompose(matrix)
     print(L)
     print(U)
diff --git a/arithmetic_analysis/newton_method.py b/arithmetic_analysis/newton_method.py
index cf5649ee3f3b..1408a983041d 100644
--- a/arithmetic_analysis/newton_method.py
+++ b/arithmetic_analysis/newton_method.py
@@ -8,17 +8,17 @@ def newton(function, function1, startingInt):
     x_n = startingInt
     while True:
         x_n1 = x_n - function(x_n) / function1(x_n)
-        if abs(x_n - x_n1) < 10**-5:
+        if abs(x_n - x_n1) < 10 ** -5:
             return x_n1
         x_n = x_n1
 
 
 def f(x):
-    return (x**3) - (2 * x) - 5
+    return (x ** 3) - (2 * x) - 5
 
 
 def f1(x):
-    return 3 * (x**2) - 2
+    return 3 * (x ** 2) - 2
 
 
 if __name__ == "__main__":
diff --git a/arithmetic_analysis/newton_raphson_method.py b/arithmetic_analysis/newton_raphson_method.py
index d17b57a2e670..646b352a923c 100644
--- a/arithmetic_analysis/newton_raphson_method.py
+++ b/arithmetic_analysis/newton_raphson_method.py
@@ -1,33 +1,34 @@
 # Implementing Newton Raphson method in Python
 # Author: Syed Haseeb Shah (github.com/QuantumNovice)
-#The Newton-Raphson method (also known as Newton's method) is a way to 
-#quickly find a good approximation for the root of a real-valued function
+# The Newton-Raphson method (also known as Newton's method) is a way to
+# quickly find a good approximation for the root of a real-valued function
 from sympy import diff
 from decimal import Decimal
 
+
 def NewtonRaphson(func, a):
-    ''' Finds root from the point 'a' onwards by Newton-Raphson method '''
+    """ Finds root from the point 'a' onwards by Newton-Raphson method """
     while True:
-        c = Decimal(a) - ( Decimal(eval(func)) / Decimal(eval(str(diff(func)))) )
+        c = Decimal(a) - (Decimal(eval(func)) / Decimal(eval(str(diff(func)))))
 
         a = c
 
         # This number dictates the accuracy of the answer
-        if  abs(eval(func)) < 10**-15:
-            return  c
+        if abs(eval(func)) < 10 ** -15:
+            return c
 
 
 # Let's Execute
-if __name__ == '__main__':
+if __name__ == "__main__":
     # Find root of trigonometric function
     # Find value of pi
-    print('sin(x) = 0', NewtonRaphson('sin(x)', 2))
+    print("sin(x) = 0", NewtonRaphson("sin(x)", 2))
 
     # Find root of polynomial
-    print('x**2 - 5*x +2 = 0', NewtonRaphson('x**2 - 5*x +2', 0.4))
+    print("x**2 - 5*x +2 = 0", NewtonRaphson("x**2 - 5*x +2", 0.4))
 
     # Find Square Root of 5
-    print('x**2 - 5 = 0', NewtonRaphson('x**2 - 5', 0.1))
+    print("x**2 - 5 = 0", NewtonRaphson("x**2 - 5", 0.1))
 
     # Exponential Roots
-    print('exp(x) - 1 = 0', NewtonRaphson('exp(x) - 1', 0))
+    print("exp(x) - 1 = 0", NewtonRaphson("exp(x) - 1", 0))
diff --git a/backtracking/all_combinations.py b/backtracking/all_combinations.py
index 63425aeabbd1..23fe378f5462 100644
--- a/backtracking/all_combinations.py
+++ b/backtracking/all_combinations.py
@@ -12,7 +12,7 @@ def generate_all_combinations(n: int, k: int) -> [[int]]:
     >>> generate_all_combinations(n=4, k=2)
     [[1, 2], [1, 3], [1, 4], [2, 3], [2, 4], [3, 4]]
     """
-    
+
     result = []
     create_all_state(1, n, k, [], result)
     return result
@@ -34,7 +34,7 @@ def print_all_state(total_list):
         print(*i)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     n = 4
     k = 2
     total_list = generate_all_combinations(n, k)
diff --git a/backtracking/all_permutations.py b/backtracking/all_permutations.py
index 299b708fef4e..b0955bf53a31 100644
--- a/backtracking/all_permutations.py
+++ b/backtracking/all_permutations.py
@@ -1,42 +1,42 @@
-'''
+"""
 	In this problem, we want to determine all possible permutations
 	of the given sequence. We use backtracking to solve this problem.
 
 	Time complexity: O(n! * n),
 	where n denotes the length of the given sequence.
-'''
+"""
 
 
 def generate_all_permutations(sequence):
-	create_state_space_tree(sequence, [], 0, [0 for i in range(len(sequence))])
+    create_state_space_tree(sequence, [], 0, [0 for i in range(len(sequence))])
 
 
 def create_state_space_tree(sequence, current_sequence, index, index_used):
-	'''
+    """
 	Creates a state space tree to iterate through each branch using DFS.
 	We know that each state has exactly len(sequence) - index children.
 	It terminates when it reaches the end of the given sequence.
-	'''
+	"""
 
-	if index == len(sequence):
-		print(current_sequence)
-		return
+    if index == len(sequence):
+        print(current_sequence)
+        return
 
-	for i in range(len(sequence)):
-		if not index_used[i]:
-			current_sequence.append(sequence[i])
-			index_used[i] = True
-			create_state_space_tree(sequence, current_sequence, index + 1, index_used)
-			current_sequence.pop()
-			index_used[i] = False
+    for i in range(len(sequence)):
+        if not index_used[i]:
+            current_sequence.append(sequence[i])
+            index_used[i] = True
+            create_state_space_tree(sequence, current_sequence, index + 1, index_used)
+            current_sequence.pop()
+            index_used[i] = False
 
 
-'''
+"""
 remove the comment to take an input from the user 
 
 print("Enter the elements")
 sequence = list(map(int, input().split()))
-'''
+"""
 
 sequence = [3, 1, 2, 4]
 generate_all_permutations(sequence)
diff --git a/backtracking/all_subsequences.py b/backtracking/all_subsequences.py
index d868377234a8..4a22c05d29a8 100644
--- a/backtracking/all_subsequences.py
+++ b/backtracking/all_subsequences.py
@@ -1,39 +1,39 @@
-'''
+"""
 	In this problem, we want to determine all possible subsequences
 	of the given sequence. We use backtracking to solve this problem.
 
 	Time complexity: O(2^n),
 	where n denotes the length of the given sequence.
-'''
+"""
 
 
 def generate_all_subsequences(sequence):
-	create_state_space_tree(sequence, [], 0)
+    create_state_space_tree(sequence, [], 0)
 
 
 def create_state_space_tree(sequence, current_subsequence, index):
-	'''
+    """
 	Creates a state space tree to iterate through each branch using DFS.
 	We know that each state has exactly two children.
 	It terminates when it reaches the end of the given sequence.
-	'''
+	"""
 
-	if index == len(sequence):
-		print(current_subsequence)
-		return
+    if index == len(sequence):
+        print(current_subsequence)
+        return
 
-	create_state_space_tree(sequence, current_subsequence, index + 1)
-	current_subsequence.append(sequence[index])
-	create_state_space_tree(sequence, current_subsequence, index + 1)
-	current_subsequence.pop()
+    create_state_space_tree(sequence, current_subsequence, index + 1)
+    current_subsequence.append(sequence[index])
+    create_state_space_tree(sequence, current_subsequence, index + 1)
+    current_subsequence.pop()
 
 
-'''
+"""
 remove the comment to take an input from the user 
 
 print("Enter the elements")
 sequence = list(map(int, input().split()))
-'''
+"""
 
 sequence = [3, 1, 2, 4]
 generate_all_subsequences(sequence)
diff --git a/backtracking/minimax.py b/backtracking/minimax.py
index 5168306e71fc..af07b8d8171a 100644
--- a/backtracking/minimax.py
+++ b/backtracking/minimax.py
@@ -1,28 +1,34 @@
-import math 
+import math
 
-''' Minimax helps to achieve maximum score in a game by checking all possible moves
+""" Minimax helps to achieve maximum score in a game by checking all possible moves
     depth is current depth in game tree. 
     nodeIndex is index of current node in scores[].
     if move is of maximizer return true else false
     leaves of game tree is stored in scores[]  
     height is maximum height of Game tree
-'''
+"""
 
-def minimax (Depth, nodeIndex, isMax, scores, height):  
 
-    if Depth == height:  
-        return scores[nodeIndex] 
+def minimax(Depth, nodeIndex, isMax, scores, height):
 
-    if isMax: 
-        return (max(minimax(Depth + 1, nodeIndex * 2, False, scores, height),
-                    minimax(Depth + 1, nodeIndex * 2 + 1, False, scores, height))) 
-    return (min(minimax(Depth + 1, nodeIndex * 2, True, scores, height), 
-               minimax(Depth + 1, nodeIndex * 2 + 1, True, scores, height))) 
+    if Depth == height:
+        return scores[nodeIndex]
 
-if __name__ == "__main__": 
- 
-    scores = [90, 23, 6, 33, 21, 65, 123, 34423] 
-    height = math.log(len(scores), 2) 
+    if isMax:
+        return max(
+            minimax(Depth + 1, nodeIndex * 2, False, scores, height),
+            minimax(Depth + 1, nodeIndex * 2 + 1, False, scores, height),
+        )
+    return min(
+        minimax(Depth + 1, nodeIndex * 2, True, scores, height),
+        minimax(Depth + 1, nodeIndex * 2 + 1, True, scores, height),
+    )
 
-    print("Optimal value : ", end = "") 
-    print(minimax(0, 0, True, scores, height)) 
+
+if __name__ == "__main__":
+
+    scores = [90, 23, 6, 33, 21, 65, 123, 34423]
+    height = math.log(len(scores), 2)
+
+    print("Optimal value : ", end="")
+    print(minimax(0, 0, True, scores, height))
diff --git a/backtracking/n_queens.py b/backtracking/n_queens.py
index dfd4498b166b..f95357c82e21 100644
--- a/backtracking/n_queens.py
+++ b/backtracking/n_queens.py
@@ -1,4 +1,4 @@
-'''
+"""
 
  The nqueens problem is of placing N queens on a N * N 
  chess board such that no queen can attack any other queens placed
@@ -6,11 +6,12 @@
  This means that one queen cannot have any other queen on its horizontal, vertical and 
  diagonal lines.
 
-'''
+"""
 solution = []
 
+
 def isSafe(board, row, column):
-    '''
+    """
     This function returns a boolean value True if it is safe to place a queen there considering 
     the current state of the board.
 
@@ -21,64 +22,67 @@ def isSafe(board, row, column):
     Returns :
     Boolean Value
 
-    '''
+    """
     for i in range(len(board)):
         if board[row][i] == 1:
             return False
     for i in range(len(board)):
         if board[i][column] == 1:
             return False
-    for i,j in zip(range(row,-1,-1),range(column,-1,-1)):
+    for i, j in zip(range(row, -1, -1), range(column, -1, -1)):
         if board[i][j] == 1:
             return False
-    for i,j in zip(range(row,-1,-1),range(column,len(board))):
+    for i, j in zip(range(row, -1, -1), range(column, len(board))):
         if board[i][j] == 1:
             return False
     return True
 
+
 def solve(board, row):
-    '''
+    """
     It creates a state space tree and calls the safe function untill it receives a 
     False Boolean and terminates that brach and backtracks to the next 
     poosible solution branch.
-    '''
+    """
     if row >= len(board):
-        '''
+        """
         If the row number exceeds N we have board with a successful combination 
         and that combination is appended to the solution list and the board is printed.
 
-        '''
+        """
         solution.append(board)
         printboard(board)
         print()
-        return 
+        return
     for i in range(len(board)):
-        '''
+        """
         For every row it iterates through each column to check if it is feesible to place a 
         queen there.
         If all the combinations for that particaular branch are successfull the board is 
         reinitialized for the next possible combination.
-        '''
-        if isSafe(board,row,i):
+        """
+        if isSafe(board, row, i):
             board[row][i] = 1
-            solve(board,row+1)
+            solve(board, row + 1)
             board[row][i] = 0
     return False
 
+
 def printboard(board):
-    '''
+    """
     Prints the boards that have a successfull combination.
-    '''
+    """
     for i in range(len(board)):
         for j in range(len(board)):
             if board[i][j] == 1:
-                print("Q", end = " ")
-            else :
-                print(".", end = " ")
+                print("Q", end=" ")
+            else:
+                print(".", end=" ")
         print()
 
-#n=int(input("The no. of queens")) 
+
+# n=int(input("The no. of queens"))
 n = 8
-board = [[0 for i in range(n)]for j in range(n)]
+board = [[0 for i in range(n)] for j in range(n)]
 solve(board, 0)
 print("The total no. of solutions are :", len(solution))
diff --git a/backtracking/sum_of_subsets.py b/backtracking/sum_of_subsets.py
index b01bffbb651d..d96552d39997 100644
--- a/backtracking/sum_of_subsets.py
+++ b/backtracking/sum_of_subsets.py
@@ -1,36 +1,46 @@
-'''
+"""
 	The sum-of-subsetsproblem states that a set of non-negative integers, and a value M, 
 	determine all possible subsets of the given set whose summation sum equal to given M.
 
 	Summation of the chosen numbers must be equal to given number M and one number can 
 	be used only once.
-'''
+"""
+
 
 def generate_sum_of_subsets_soln(nums, max_sum):
-	result = []
-	path = []
-	num_index = 0
-	remaining_nums_sum = sum(nums)
-	create_state_space_tree(nums, max_sum, num_index, path,result, remaining_nums_sum)
-	return result
-
-def create_state_space_tree(nums,max_sum,num_index,path,result, remaining_nums_sum):
-	'''
+    result = []
+    path = []
+    num_index = 0
+    remaining_nums_sum = sum(nums)
+    create_state_space_tree(nums, max_sum, num_index, path, result, remaining_nums_sum)
+    return result
+
+
+def create_state_space_tree(nums, max_sum, num_index, path, result, remaining_nums_sum):
+    """
 	Creates a state space tree to iterate through each branch using DFS.
 	It terminates the branching of a node when any of the two conditions 
 	given below satisfy.
 	This algorithm follows depth-fist-search and backtracks when the node is not branchable.
 
-	'''
-	if sum(path) > max_sum or (remaining_nums_sum + sum(path)) < max_sum:
-		return
-	if sum(path) == max_sum:
-		result.append(path)
-		return
-	for num_index in range(num_index,len(nums)):
-		create_state_space_tree(nums, max_sum, num_index + 1, path + [nums[num_index]], result, remaining_nums_sum - nums[num_index])
+	"""
+    if sum(path) > max_sum or (remaining_nums_sum + sum(path)) < max_sum:
+        return
+    if sum(path) == max_sum:
+        result.append(path)
+        return
+    for num_index in range(num_index, len(nums)):
+        create_state_space_tree(
+            nums,
+            max_sum,
+            num_index + 1,
+            path + [nums[num_index]],
+            result,
+            remaining_nums_sum - nums[num_index],
+        )
+
 
-'''
+"""
 remove the comment to take an input from the user 
 
 print("Enter the elements")
@@ -38,8 +48,8 @@ def create_state_space_tree(nums,max_sum,num_index,path,result, remaining_nums_s
 print("Enter max_sum sum")
 max_sum = int(input())
 
-'''
+"""
 nums = [3, 34, 4, 12, 5, 2]
 max_sum = 9
-result = generate_sum_of_subsets_soln(nums,max_sum)
-print(*result)
\ No newline at end of file
+result = generate_sum_of_subsets_soln(nums, max_sum)
+print(*result)
diff --git a/boolean_algebra/quine_mc_cluskey.py b/boolean_algebra/quine_mc_cluskey.py
index b7ca8da437a3..7762d712a01a 100644
--- a/boolean_algebra/quine_mc_cluskey.py
+++ b/boolean_algebra/quine_mc_cluskey.py
@@ -1,151 +1,168 @@
 def compare_string(string1, string2):
-	"""
+    """
 	>>> compare_string('0010','0110')
 	'0_10'
 	
 	>>> compare_string('0110','1101')
 	-1
 	"""
-	l1 = list(string1); l2 = list(string2)
-	count = 0
-	for i in range(len(l1)):
-		if l1[i] != l2[i]:
-			count += 1
-			l1[i] = '_'
-	if count > 1:
-		return -1
-	else:
-		return("".join(l1))
+    l1 = list(string1)
+    l2 = list(string2)
+    count = 0
+    for i in range(len(l1)):
+        if l1[i] != l2[i]:
+            count += 1
+            l1[i] = "_"
+    if count > 1:
+        return -1
+    else:
+        return "".join(l1)
+
 
 def check(binary):
-	"""
+    """
 	>>> check(['0.00.01.5'])
 	['0.00.01.5']
 	"""
-	pi = []
-	while 1:
-		check1 = ['$']*len(binary)
-		temp = []
-		for i in range(len(binary)):
-			for j in range(i+1, len(binary)):
-				k=compare_string(binary[i], binary[j])
-				if k != -1:
-					check1[i] = '*'
-					check1[j] = '*'
-					temp.append(k)
-		for  i in range(len(binary)):
-			if check1[i] == '$':
-				pi.append(binary[i])
-		if len(temp) == 0:
-			return pi
-		binary = list(set(temp))
+    pi = []
+    while 1:
+        check1 = ["$"] * len(binary)
+        temp = []
+        for i in range(len(binary)):
+            for j in range(i + 1, len(binary)):
+                k = compare_string(binary[i], binary[j])
+                if k != -1:
+                    check1[i] = "*"
+                    check1[j] = "*"
+                    temp.append(k)
+        for i in range(len(binary)):
+            if check1[i] == "$":
+                pi.append(binary[i])
+        if len(temp) == 0:
+            return pi
+        binary = list(set(temp))
+
 
 def decimal_to_binary(no_of_variable, minterms):
-	"""
+    """
 	>>> decimal_to_binary(3,[1.5])
 	['0.00.01.5']
 	"""
-	temp = []
-	s = ''
-	for m in minterms:
-		for i in range(no_of_variable):
-			s = str(m%2) + s
-			m //= 2
-		temp.append(s)
-		s = ''
-	return temp
+    temp = []
+    s = ""
+    for m in minterms:
+        for i in range(no_of_variable):
+            s = str(m % 2) + s
+            m //= 2
+        temp.append(s)
+        s = ""
+    return temp
+
 
 def is_for_table(string1, string2, count):
-	"""
+    """
 	>>> is_for_table('__1','011',2)
 	True
 	
 	>>> is_for_table('01_','001',1)
 	False
 	"""
-	l1 = list(string1);l2=list(string2)
-	count_n = 0
-	for i in range(len(l1)):
-		if l1[i] != l2[i]:
-			count_n += 1
-	if count_n == count:
-		return True
-	else:
-		return False 
+    l1 = list(string1)
+    l2 = list(string2)
+    count_n = 0
+    for i in range(len(l1)):
+        if l1[i] != l2[i]:
+            count_n += 1
+    if count_n == count:
+        return True
+    else:
+        return False
+
 
 def selection(chart, prime_implicants):
-	"""
+    """
 	>>> selection([[1]],['0.00.01.5'])
 	['0.00.01.5']
 	
 	>>> selection([[1]],['0.00.01.5'])
 	['0.00.01.5']
 	"""
-	temp = []
-	select = [0]*len(chart)
-	for i in range(len(chart[0])):
-		count = 0
-		rem = -1
-		for j in range(len(chart)):
-			if chart[j][i] == 1:
-				count += 1
-				rem = j
-		if count == 1:
-			select[rem] = 1
-	for i in range(len(select)):
-		if select[i] == 1:
-			for j in range(len(chart[0])):
-				if chart[i][j] == 1:
-					for k in range(len(chart)):
-						chart[k][j] = 0 
-			temp.append(prime_implicants[i])
-	while 1:
-		max_n = 0; rem = -1; count_n = 0
-		for i in range(len(chart)):
-			count_n = chart[i].count(1)
-			if count_n > max_n:
-				max_n = count_n
-				rem = i
-		
-		if max_n == 0:
-			return temp
-		
-		temp.append(prime_implicants[rem])
-		
-		for i in range(len(chart[0])):
-			if chart[rem][i] == 1:
-				for j in range(len(chart)):
-					chart[j][i] = 0
-		
+    temp = []
+    select = [0] * len(chart)
+    for i in range(len(chart[0])):
+        count = 0
+        rem = -1
+        for j in range(len(chart)):
+            if chart[j][i] == 1:
+                count += 1
+                rem = j
+        if count == 1:
+            select[rem] = 1
+    for i in range(len(select)):
+        if select[i] == 1:
+            for j in range(len(chart[0])):
+                if chart[i][j] == 1:
+                    for k in range(len(chart)):
+                        chart[k][j] = 0
+            temp.append(prime_implicants[i])
+    while 1:
+        max_n = 0
+        rem = -1
+        count_n = 0
+        for i in range(len(chart)):
+            count_n = chart[i].count(1)
+            if count_n > max_n:
+                max_n = count_n
+                rem = i
+
+        if max_n == 0:
+            return temp
+
+        temp.append(prime_implicants[rem])
+
+        for i in range(len(chart[0])):
+            if chart[rem][i] == 1:
+                for j in range(len(chart)):
+                    chart[j][i] = 0
+
+
 def prime_implicant_chart(prime_implicants, binary):
-	"""
+    """
 	>>> prime_implicant_chart(['0.00.01.5'],['0.00.01.5'])
 	[[1]]
 	"""
-	chart = [[0 for x in range(len(binary))] for x in range(len(prime_implicants))]
-	for i in range(len(prime_implicants)):
-		count = prime_implicants[i].count('_')
-		for j in range(len(binary)):
-			if(is_for_table(prime_implicants[i], binary[j], count)):
-				chart[i][j] = 1
-	
-	return chart
+    chart = [[0 for x in range(len(binary))] for x in range(len(prime_implicants))]
+    for i in range(len(prime_implicants)):
+        count = prime_implicants[i].count("_")
+        for j in range(len(binary)):
+            if is_for_table(prime_implicants[i], binary[j], count):
+                chart[i][j] = 1
+
+    return chart
+
 
 def main():
-	no_of_variable = int(input("Enter the no. of variables\n"))
-	minterms = [int(x) for x in input("Enter the decimal representation of Minterms 'Spaces Seprated'\n").split()]
-	binary = decimal_to_binary(no_of_variable, minterms)
-	
-	prime_implicants = check(binary)
-	print("Prime Implicants are:")
-	print(prime_implicants)
-	chart = prime_implicant_chart(prime_implicants, binary)
-	
-	essential_prime_implicants = selection(chart,prime_implicants)
-	print("Essential Prime Implicants are:")
-	print(essential_prime_implicants)
-
-if __name__ == '__main__':
-	import doctest
-	doctest.testmod()
-	main()
+    no_of_variable = int(input("Enter the no. of variables\n"))
+    minterms = [
+        int(x)
+        for x in input(
+            "Enter the decimal representation of Minterms 'Spaces Seprated'\n"
+        ).split()
+    ]
+    binary = decimal_to_binary(no_of_variable, minterms)
+
+    prime_implicants = check(binary)
+    print("Prime Implicants are:")
+    print(prime_implicants)
+    chart = prime_implicant_chart(prime_implicants, binary)
+
+    essential_prime_implicants = selection(chart, prime_implicants)
+    print("Essential Prime Implicants are:")
+    print(essential_prime_implicants)
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()
+    main()
diff --git a/ciphers/affine_cipher.py b/ciphers/affine_cipher.py
index a5d94f087dbf..eb50acf8fc20 100644
--- a/ciphers/affine_cipher.py
+++ b/ciphers/affine_cipher.py
@@ -2,42 +2,56 @@
 
 SYMBOLS = r""" !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~"""
 
+
 def main():
-    message = input('Enter message: ')
-    key = int(input('Enter key [2000 - 9000]: '))
-    mode = input('Encrypt/Decrypt [E/D]: ')
-
-    if mode.lower().startswith('e'):
-              mode = 'encrypt'
-              translated = encryptMessage(key, message)
-    elif mode.lower().startswith('d'):
-              mode = 'decrypt'
-              translated = decryptMessage(key, message)
-    print('\n%sed text: \n%s' % (mode.title(), translated))
+    message = input("Enter message: ")
+    key = int(input("Enter key [2000 - 9000]: "))
+    mode = input("Encrypt/Decrypt [E/D]: ")
+
+    if mode.lower().startswith("e"):
+        mode = "encrypt"
+        translated = encryptMessage(key, message)
+    elif mode.lower().startswith("d"):
+        mode = "decrypt"
+        translated = decryptMessage(key, message)
+    print("\n%sed text: \n%s" % (mode.title(), translated))
+
 
 def getKeyParts(key):
     keyA = key // len(SYMBOLS)
     keyB = key % len(SYMBOLS)
     return (keyA, keyB)
 
+
 def checkKeys(keyA, keyB, mode):
-    if keyA == 1 and mode == 'encrypt':
-        sys.exit('The affine cipher becomes weak when key A is set to 1. Choose different key')
-    if keyB == 0 and mode == 'encrypt':
-        sys.exit('The affine cipher becomes weak when key A is set to 1. Choose different key')
+    if keyA == 1 and mode == "encrypt":
+        sys.exit(
+            "The affine cipher becomes weak when key A is set to 1. Choose different key"
+        )
+    if keyB == 0 and mode == "encrypt":
+        sys.exit(
+            "The affine cipher becomes weak when key A is set to 1. Choose different key"
+        )
     if keyA < 0 or keyB < 0 or keyB > len(SYMBOLS) - 1:
-        sys.exit('Key A must be greater than 0 and key B must be between 0 and %s.' % (len(SYMBOLS) - 1))
+        sys.exit(
+            "Key A must be greater than 0 and key B must be between 0 and %s."
+            % (len(SYMBOLS) - 1)
+        )
     if cryptoMath.gcd(keyA, len(SYMBOLS)) != 1:
-        sys.exit('Key A %s and the symbol set size %s are not relatively prime. Choose a different key.' % (keyA, len(SYMBOLS)))
+        sys.exit(
+            "Key A %s and the symbol set size %s are not relatively prime. Choose a different key."
+            % (keyA, len(SYMBOLS))
+        )
+
 
 def encryptMessage(key, message):
-    '''
+    """
     >>> encryptMessage(4545, 'The affine cipher is a type of monoalphabetic substitution cipher.')
     'VL}p MM{I}p~{HL}Gp{vp pFsH}pxMpyxIx JHL O}F{~pvuOvF{FuF{xIp~{HL}Gi'
-    '''
+    """
     keyA, keyB = getKeyParts(key)
-    checkKeys(keyA, keyB, 'encrypt')
-    cipherText = ''
+    checkKeys(keyA, keyB, "encrypt")
+    cipherText = ""
     for symbol in message:
         if symbol in SYMBOLS:
             symIndex = SYMBOLS.find(symbol)
@@ -46,14 +60,15 @@ def encryptMessage(key, message):
             cipherText += symbol
     return cipherText
 
+
 def decryptMessage(key, message):
-    '''
+    """
     >>> decryptMessage(4545, 'VL}p MM{I}p~{HL}Gp{vp pFsH}pxMpyxIx JHL O}F{~pvuOvF{FuF{xIp~{HL}Gi')
     'The affine cipher is a type of monoalphabetic substitution cipher.'
-    '''
+    """
     keyA, keyB = getKeyParts(key)
-    checkKeys(keyA, keyB, 'decrypt')
-    plainText = ''
+    checkKeys(keyA, keyB, "decrypt")
+    plainText = ""
     modInverseOfkeyA = cryptoMath.findModInverse(keyA, len(SYMBOLS))
     for symbol in message:
         if symbol in SYMBOLS:
@@ -63,6 +78,7 @@ def decryptMessage(key, message):
             plainText += symbol
     return plainText
 
+
 def getRandomKey():
     while True:
         keyA = random.randint(2, len(SYMBOLS))
@@ -70,7 +86,9 @@ def getRandomKey():
         if cryptoMath.gcd(keyA, len(SYMBOLS)) == 1:
             return keyA * len(SYMBOLS) + keyB
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
     import doctest
+
     doctest.testmod()
     main()
diff --git a/ciphers/atbash.py b/ciphers/atbash.py
index 9ed47e0874f8..4cf003859856 100644
--- a/ciphers/atbash.py
+++ b/ciphers/atbash.py
@@ -1,15 +1,15 @@
 def atbash():
-    output=""
+    output = ""
     for i in input("Enter the sentence to be encrypted ").strip():
         extract = ord(i)
         if 65 <= extract <= 90:
-            output += chr(155-extract)
+            output += chr(155 - extract)
         elif 97 <= extract <= 122:
-            output += chr(219-extract)
+            output += chr(219 - extract)
         else:
             output += i
     print(output)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     atbash()
diff --git a/ciphers/base16.py b/ciphers/base16.py
index 9bc0e5d8337a..0210315d54e6 100644
--- a/ciphers/base16.py
+++ b/ciphers/base16.py
@@ -1,11 +1,13 @@
 import base64
 
+
 def main():
-    inp = input('->')
-    encoded = inp.encode('utf-8') #encoded the input (we need a bytes like object)
-    b16encoded = base64.b16encode(encoded) #b16encoded the encoded string
+    inp = input("->")
+    encoded = inp.encode("utf-8")  # encoded the input (we need a bytes like object)
+    b16encoded = base64.b16encode(encoded)  # b16encoded the encoded string
     print(b16encoded)
-    print(base64.b16decode(b16encoded).decode('utf-8'))#decoded it
+    print(base64.b16decode(b16encoded).decode("utf-8"))  # decoded it
+
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
diff --git a/ciphers/base32.py b/ciphers/base32.py
index 2ac29f441e94..5bba8c4dd685 100644
--- a/ciphers/base32.py
+++ b/ciphers/base32.py
@@ -1,11 +1,13 @@
 import base64
 
+
 def main():
-    inp = input('->')
-    encoded = inp.encode('utf-8') #encoded the input (we need a bytes like object)
-    b32encoded = base64.b32encode(encoded) #b32encoded the encoded string
+    inp = input("->")
+    encoded = inp.encode("utf-8")  # encoded the input (we need a bytes like object)
+    b32encoded = base64.b32encode(encoded)  # b32encoded the encoded string
     print(b32encoded)
-    print(base64.b32decode(b32encoded).decode('utf-8'))#decoded it
+    print(base64.b32decode(b32encoded).decode("utf-8"))  # decoded it
+
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
diff --git a/ciphers/base64_cipher.py b/ciphers/base64_cipher.py
index fa3451c0cbae..9fca5b02679f 100644
--- a/ciphers/base64_cipher.py
+++ b/ciphers/base64_cipher.py
@@ -1,64 +1,71 @@
 def encodeBase64(text):
     base64chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
-    
-    r = "" #the result
-    c = 3 - len(text) % 3 #the length of padding
-    p = "=" * c #the padding
-    s = text + "\0" * c #the text to encode
-    
-    i = 0   
+
+    r = ""  # the result
+    c = 3 - len(text) % 3  # the length of padding
+    p = "=" * c  # the padding
+    s = text + "\0" * c  # the text to encode
+
+    i = 0
     while i < len(s):
         if i > 0 and ((i / 3 * 4) % 76) == 0:
             r = r + "\r\n"
-        
-        n = (ord(s[i]) << 16) + (ord(s[i+1]) << 8 ) + ord(s[i+2])
-        
+
+        n = (ord(s[i]) << 16) + (ord(s[i + 1]) << 8) + ord(s[i + 2])
+
         n1 = (n >> 18) & 63
         n2 = (n >> 12) & 63
-        n3 = (n >> 6)  & 63
+        n3 = (n >> 6) & 63
         n4 = n & 63
-        
+
         r += base64chars[n1] + base64chars[n2] + base64chars[n3] + base64chars[n4]
         i += 3
 
-    return r[0: len(r)-len(p)] + p
-    
+    return r[0 : len(r) - len(p)] + p
+
+
 def decodeBase64(text):
     base64chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
     s = ""
-    
+
     for i in text:
         if i in base64chars:
             s += i
             c = ""
         else:
-            if i == '=':
-                c += '='
-    
+            if i == "=":
+                c += "="
+
     p = ""
     if c == "=":
-        p = 'A'
+        p = "A"
     else:
         if c == "==":
             p = "AA"
-    
+
     r = ""
     s = s + p
-   
+
     i = 0
     while i < len(s):
-        n = (base64chars.index(s[i]) << 18) +  (base64chars.index(s[i+1]) << 12) +  (base64chars.index(s[i+2]) << 6) +base64chars.index(s[i+3])
-        
+        n = (
+            (base64chars.index(s[i]) << 18)
+            + (base64chars.index(s[i + 1]) << 12)
+            + (base64chars.index(s[i + 2]) << 6)
+            + base64chars.index(s[i + 3])
+        )
+
         r += chr((n >> 16) & 255) + chr((n >> 8) & 255) + chr(n & 255)
-        
+
         i += 4
-    
-    return r[0: len(r) - len(p)]
+
+    return r[0 : len(r) - len(p)]
+
 
 def main():
     print(encodeBase64("WELCOME to base64 encoding"))
     print(decodeBase64(encodeBase64("WELCOME to base64 encoding")))
-    
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
     main()
diff --git a/ciphers/base85.py b/ciphers/base85.py
index 5fd13837f662..ebfd0480f794 100644
--- a/ciphers/base85.py
+++ b/ciphers/base85.py
@@ -1,11 +1,13 @@
 import base64
 
+
 def main():
-    inp = input('->')
-    encoded = inp.encode('utf-8') #encoded the input (we need a bytes like object)
-    a85encoded = base64.a85encode(encoded) #a85encoded the encoded string
+    inp = input("->")
+    encoded = inp.encode("utf-8")  # encoded the input (we need a bytes like object)
+    a85encoded = base64.a85encode(encoded)  # a85encoded the encoded string
     print(a85encoded)
-    print(base64.a85decode(a85encoded).decode('utf-8'))#decoded it
+    print(base64.a85decode(a85encoded).decode("utf-8"))  # decoded it
+
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
diff --git a/ciphers/brute_force_caesar_cipher.py b/ciphers/brute_force_caesar_cipher.py
index 3e6e975c8297..2586803ba5ff 100644
--- a/ciphers/brute_force_caesar_cipher.py
+++ b/ciphers/brute_force_caesar_cipher.py
@@ -42,12 +42,15 @@ def decrypt(message):
                 translated = translated + symbol
         print("Decryption using Key #%s: %s" % (key, translated))
 
+
 def main():
     message = input("Encrypted message: ")
     message = message.upper()
     decrypt(message)
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
     import doctest
+
     doctest.testmod()
     main()
diff --git a/ciphers/caesar_cipher.py b/ciphers/caesar_cipher.py
index 95d65d404266..3f24e049afb0 100644
--- a/ciphers/caesar_cipher.py
+++ b/ciphers/caesar_cipher.py
@@ -1,5 +1,5 @@
 def encrypt(strng, key):
-    encrypted = ''
+    encrypted = ""
     for x in strng:
         indx = (ord(x) + key) % 256
         if indx > 126:
@@ -9,7 +9,7 @@ def encrypt(strng, key):
 
 
 def decrypt(strng, key):
-    decrypted = ''
+    decrypted = ""
     for x in strng:
         indx = (ord(x) - key) % 256
         if indx < 32:
@@ -17,9 +17,10 @@ def decrypt(strng, key):
         decrypted = decrypted + chr(indx)
     return decrypted
 
+
 def brute_force(strng):
     key = 1
-    decrypted = ''
+    decrypted = ""
     while key <= 94:
         for x in strng:
             indx = (ord(x) - key) % 256
@@ -27,39 +28,39 @@ def brute_force(strng):
                 indx = indx + 95
             decrypted = decrypted + chr(indx)
         print("Key: {}\t| Message: {}".format(key, decrypted))
-        decrypted = ''
+        decrypted = ""
         key += 1
     return None
 
 
 def main():
     while True:
-        print('-' * 10 + "\n**Menu**\n" + '-' * 10)
+        print("-" * 10 + "\n**Menu**\n" + "-" * 10)
         print("1.Encrpyt")
         print("2.Decrypt")
         print("3.BruteForce")
         print("4.Quit")
         choice = input("What would you like to do?: ")
-        if choice not in ['1', '2', '3', '4']:
+        if choice not in ["1", "2", "3", "4"]:
             print("Invalid choice, please enter a valid choice")
-        elif choice == '1':
+        elif choice == "1":
             strng = input("Please enter the string to be encrypted: ")
             key = int(input("Please enter off-set between 1-94: "))
             if key in range(1, 95):
                 print(encrypt(strng.lower(), key))
-        elif choice == '2':
+        elif choice == "2":
             strng = input("Please enter the string to be decrypted: ")
             key = int(input("Please enter off-set between 1-94: "))
-            if key in range(1,95):
+            if key in range(1, 95):
                 print(decrypt(strng, key))
-        elif choice == '3':
+        elif choice == "3":
             strng = input("Please enter the string to be decrypted: ")
             brute_force(strng)
             main()
-        elif choice == '4':
+        elif choice == "4":
             print("Goodbye.")
             break
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
diff --git a/ciphers/cryptomath_module.py b/ciphers/cryptomath_module.py
index 3e8e71b117ed..fc38e4bd2a22 100644
--- a/ciphers/cryptomath_module.py
+++ b/ciphers/cryptomath_module.py
@@ -3,6 +3,7 @@ def gcd(a, b):
         a, b = b % a, a
     return b
 
+
 def findModInverse(a, m):
     if gcd(a, m) != 1:
         return None
@@ -10,5 +11,5 @@ def findModInverse(a, m):
     v1, v2, v3 = 0, 1, m
     while v3 != 0:
         q = u3 // v3
-        v1, v2, v3, u1, u2, u3 = (u1 - q * v1), (u2 - q * v2), (u3 - q *v3), v1, v2, v3
-    return u1 % m     
+        v1, v2, v3, u1, u2, u3 = (u1 - q * v1), (u2 - q * v2), (u3 - q * v3), v1, v2, v3
+    return u1 % m
diff --git a/ciphers/elgamal_key_generator.py b/ciphers/elgamal_key_generator.py
index 6a8751f69524..cc6b297f2daf 100644
--- a/ciphers/elgamal_key_generator.py
+++ b/ciphers/elgamal_key_generator.py
@@ -7,9 +7,9 @@
 
 
 def main():
-    print('Making key files...')
-    makeKeyFiles('elgamal', 2048)
-    print('Key files generation successful')
+    print("Making key files...")
+    makeKeyFiles("elgamal", 2048)
+    print("Key files generation successful")
 
 
 # I have written my code naively same as definition of primitive root
@@ -19,7 +19,7 @@ def main():
 def primitiveRoot(p_val):
     print("Generating primitive root of p")
     while True:
-        g = random.randrange(3,p_val)
+        g = random.randrange(3, p_val)
         if pow(g, 2, p_val) == 1:
             continue
         if pow(g, p_val, p_val) == 1:
@@ -28,7 +28,7 @@ def primitiveRoot(p_val):
 
 
 def generateKey(keySize):
-    print('Generating prime p...')
+    print("Generating prime p...")
     p = rabinMiller.generateLargePrime(keySize)  # select large prime number.
     e_1 = primitiveRoot(p)  # one primitive root on modulo p.
     d = random.randrange(3, p)  # private_key -> have to be greater than 2 for safety.
@@ -41,23 +41,28 @@ def generateKey(keySize):
 
 
 def makeKeyFiles(name, keySize):
-    if os.path.exists('%s_pubkey.txt' % name) or os.path.exists('%s_privkey.txt' % name):
-        print('\nWARNING:')
-        print('"%s_pubkey.txt" or "%s_privkey.txt" already exists. \n'
-              'Use a different name or delete these files and re-run this program.' %
-              (name, name))
+    if os.path.exists("%s_pubkey.txt" % name) or os.path.exists(
+        "%s_privkey.txt" % name
+    ):
+        print("\nWARNING:")
+        print(
+            '"%s_pubkey.txt" or "%s_privkey.txt" already exists. \n'
+            "Use a different name or delete these files and re-run this program."
+            % (name, name)
+        )
         sys.exit()
 
     publicKey, privateKey = generateKey(keySize)
-    print('\nWriting public key to file %s_pubkey.txt...' % name)
-    with open('%s_pubkey.txt' % name, 'w') as fo:
-        fo.write('%d,%d,%d,%d' % (publicKey[0], publicKey[1], publicKey[2], publicKey[3]))
+    print("\nWriting public key to file %s_pubkey.txt..." % name)
+    with open("%s_pubkey.txt" % name, "w") as fo:
+        fo.write(
+            "%d,%d,%d,%d" % (publicKey[0], publicKey[1], publicKey[2], publicKey[3])
+        )
 
-    print('Writing private key to file %s_privkey.txt...' % name)
-    with open('%s_privkey.txt' % name, 'w') as fo:
-        fo.write('%d,%d' % (privateKey[0], privateKey[1]))
+    print("Writing private key to file %s_privkey.txt..." % name)
+    with open("%s_privkey.txt" % name, "w") as fo:
+        fo.write("%d,%d" % (privateKey[0], privateKey[1]))
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
-    
\ No newline at end of file
diff --git a/ciphers/hill_cipher.py b/ciphers/hill_cipher.py
index 89b88beed17e..e01b6a3f48a8 100644
--- a/ciphers/hill_cipher.py
+++ b/ciphers/hill_cipher.py
@@ -44,7 +44,7 @@
 def gcd(a, b):
     if a == 0:
         return b
-    return gcd(b%a, a)
+    return gcd(b % a, a)
 
 
 class HillCipher:
@@ -59,25 +59,29 @@ class HillCipher:
     modulus = numpy.vectorize(lambda x: x % 36)
 
     toInt = numpy.vectorize(lambda x: round(x))
-    
+
     def __init__(self, encrypt_key):
         """
         encrypt_key is an NxN numpy matrix
         """
-        self.encrypt_key = self.modulus(encrypt_key) # mod36 calc's on the encrypt key
-        self.checkDeterminant() # validate the determinant of the encryption key
+        self.encrypt_key = self.modulus(encrypt_key)  # mod36 calc's on the encrypt key
+        self.checkDeterminant()  # validate the determinant of the encryption key
         self.decrypt_key = None
         self.break_key = encrypt_key.shape[0]
 
     def checkDeterminant(self):
         det = round(numpy.linalg.det(self.encrypt_key))
-        
+
         if det < 0:
             det = det % len(self.key_string)
 
         req_l = len(self.key_string)
         if gcd(det, len(self.key_string)) != 1:
-            raise ValueError("discriminant modular {0} of encryption key({1}) is not co prime w.r.t {2}.\nTry another key.".format(req_l, det, req_l))
+            raise ValueError(
+                "discriminant modular {0} of encryption key({1}) is not co prime w.r.t {2}.\nTry another key.".format(
+                    req_l, det, req_l
+                )
+            )
 
     def processText(self, text):
         text = list(text.upper())
@@ -87,25 +91,27 @@ def processText(self, text):
         while len(text) % self.break_key != 0:
             text.append(last)
 
-        return ''.join(text)
-    
+        return "".join(text)
+
     def encrypt(self, text):
         text = self.processText(text.upper())
-        encrypted = ''
+        encrypted = ""
 
         for i in range(0, len(text) - self.break_key + 1, self.break_key):
-            batch = text[i:i+self.break_key]
+            batch = text[i : i + self.break_key]
             batch_vec = list(map(self.replaceLetters, batch))
             batch_vec = numpy.matrix([batch_vec]).T
-            batch_encrypted = self.modulus(self.encrypt_key.dot(batch_vec)).T.tolist()[0]
-            encrypted_batch = ''.join(list(map(self.replaceNumbers, batch_encrypted)))
+            batch_encrypted = self.modulus(self.encrypt_key.dot(batch_vec)).T.tolist()[
+                0
+            ]
+            encrypted_batch = "".join(list(map(self.replaceNumbers, batch_encrypted)))
             encrypted += encrypted_batch
 
         return encrypted
 
     def makeDecryptKey(self):
         det = round(numpy.linalg.det(self.encrypt_key))
-        
+
         if det < 0:
             det = det % len(self.key_string)
         det_inv = None
@@ -114,22 +120,27 @@ def makeDecryptKey(self):
                 det_inv = i
                 break
 
-        inv_key = det_inv * numpy.linalg.det(self.encrypt_key) *\
-                  numpy.linalg.inv(self.encrypt_key)
+        inv_key = (
+            det_inv
+            * numpy.linalg.det(self.encrypt_key)
+            * numpy.linalg.inv(self.encrypt_key)
+        )
 
         return self.toInt(self.modulus(inv_key))
-    
+
     def decrypt(self, text):
         self.decrypt_key = self.makeDecryptKey()
         text = self.processText(text.upper())
-        decrypted = ''
+        decrypted = ""
 
         for i in range(0, len(text) - self.break_key + 1, self.break_key):
-            batch = text[i:i+self.break_key]
+            batch = text[i : i + self.break_key]
             batch_vec = list(map(self.replaceLetters, batch))
             batch_vec = numpy.matrix([batch_vec]).T
-            batch_decrypted = self.modulus(self.decrypt_key.dot(batch_vec)).T.tolist()[0]
-            decrypted_batch = ''.join(list(map(self.replaceNumbers, batch_decrypted)))
+            batch_decrypted = self.modulus(self.decrypt_key.dot(batch_vec)).T.tolist()[
+                0
+            ]
+            decrypted_batch = "".join(list(map(self.replaceNumbers, batch_decrypted)))
             decrypted += decrypted_batch
 
         return decrypted
@@ -147,21 +158,22 @@ def main():
     hc = HillCipher(numpy.matrix(hill_matrix))
 
     print("Would you like to encrypt or decrypt some text? (1 or 2)")
-    option = input("""
+    option = input(
+        """
 1. Encrypt
 2. Decrypt
 """
-                   )
+    )
 
-    if option == '1':
+    if option == "1":
         text_e = input("What text would you like to encrypt?: ")
         print("Your encrypted text is:")
         print(hc.encrypt(text_e))
-    elif option == '2':
+    elif option == "2":
         text_d = input("What text would you like to decrypt?: ")
         print("Your decrypted text is:")
         print(hc.decrypt(text_d))
-    
+
 
 if __name__ == "__main__":
     main()
diff --git a/ciphers/morse_code_implementation.py b/ciphers/morse_code_implementation.py
index 5d0e7b2779b1..6df4632af4cb 100644
--- a/ciphers/morse_code_implementation.py
+++ b/ciphers/morse_code_implementation.py
@@ -2,68 +2,93 @@
 
 
 # Dictionary representing the morse code chart
-MORSE_CODE_DICT = { 'A':'.-', 'B':'-...',
-                    'C':'-.-.', 'D':'-..', 'E':'.',
-                    'F':'..-.', 'G':'--.', 'H':'....',
-                    'I':'..', 'J':'.---', 'K':'-.-',
-                    'L':'.-..', 'M':'--', 'N':'-.',
-                    'O':'---', 'P':'.--.', 'Q':'--.-',
-                    'R':'.-.', 'S':'...', 'T':'-',
-                    'U':'..-', 'V':'...-', 'W':'.--',
-                    'X':'-..-', 'Y':'-.--', 'Z':'--..',
-                    '1':'.----', '2':'..---', '3':'...--',
-                    '4':'....-', '5':'.....', '6':'-....',
-                    '7':'--...', '8':'---..', '9':'----.',
-                    '0':'-----', ', ':'--..--', '.':'.-.-.-',
-                    '?':'..--..', '/':'-..-.', '-':'-....-',
-                    '(':'-.--.', ')':'-.--.-'}
+MORSE_CODE_DICT = {
+    "A": ".-",
+    "B": "-...",
+    "C": "-.-.",
+    "D": "-..",
+    "E": ".",
+    "F": "..-.",
+    "G": "--.",
+    "H": "....",
+    "I": "..",
+    "J": ".---",
+    "K": "-.-",
+    "L": ".-..",
+    "M": "--",
+    "N": "-.",
+    "O": "---",
+    "P": ".--.",
+    "Q": "--.-",
+    "R": ".-.",
+    "S": "...",
+    "T": "-",
+    "U": "..-",
+    "V": "...-",
+    "W": ".--",
+    "X": "-..-",
+    "Y": "-.--",
+    "Z": "--..",
+    "1": ".----",
+    "2": "..---",
+    "3": "...--",
+    "4": "....-",
+    "5": ".....",
+    "6": "-....",
+    "7": "--...",
+    "8": "---..",
+    "9": "----.",
+    "0": "-----",
+    ", ": "--..--",
+    ".": ".-.-.-",
+    "?": "..--..",
+    "/": "-..-.",
+    "-": "-....-",
+    "(": "-.--.",
+    ")": "-.--.-",
+}
 
 
 def encrypt(message):
-    cipher = ''
+    cipher = ""
     for letter in message:
-        if letter != ' ':
+        if letter != " ":
 
-
-            cipher += MORSE_CODE_DICT[letter] + ' '
+            cipher += MORSE_CODE_DICT[letter] + " "
         else:
 
-            cipher += ' '
+            cipher += " "
 
     return cipher
 
 
 def decrypt(message):
 
-    message += ' '
+    message += " "
 
-    decipher = ''
-    citext = ''
+    decipher = ""
+    citext = ""
     for letter in message:
 
-        if (letter != ' '):
-
+        if letter != " ":
 
             i = 0
 
-
             citext += letter
 
         else:
 
             i += 1
 
+            if i == 2:
 
-            if i == 2 :
-
-
-                decipher += ' '
+                decipher += " "
             else:
 
-
-                decipher += list(MORSE_CODE_DICT.keys())[list(MORSE_CODE_DICT
-                .values()).index(citext)]
-                citext = ''
+                decipher += list(MORSE_CODE_DICT.keys())[
+                    list(MORSE_CODE_DICT.values()).index(citext)
+                ]
+                citext = ""
 
     return decipher
 
@@ -78,5 +103,5 @@ def main():
     print(result)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
diff --git a/ciphers/onepad_cipher.py b/ciphers/onepad_cipher.py
index 1dac270bda1f..5a410bfa638a 100644
--- a/ciphers/onepad_cipher.py
+++ b/ciphers/onepad_cipher.py
@@ -3,28 +3,28 @@
 
 class Onepad:
     def encrypt(self, text):
-        '''Function to encrypt text using psedo-random numbers'''
+        """Function to encrypt text using psedo-random numbers"""
         plain = [ord(i) for i in text]
         key = []
         cipher = []
         for i in plain:
             k = random.randint(1, 300)
-            c = (i+k)*k
+            c = (i + k) * k
             cipher.append(c)
             key.append(k)
         return cipher, key
 
     def decrypt(self, cipher, key):
-        '''Function to decrypt text using psedo-random numbers.'''
+        """Function to decrypt text using psedo-random numbers."""
         plain = []
         for i in range(len(key)):
-            p = int((cipher[i]-(key[i])**2)/key[i])
+            p = int((cipher[i] - (key[i]) ** 2) / key[i])
             plain.append(chr(p))
-        plain = ''.join([i for i in plain])
+        plain = "".join([i for i in plain])
         return plain
 
 
-if __name__ == '__main__':
-    c, k = Onepad().encrypt('Hello')
+if __name__ == "__main__":
+    c, k = Onepad().encrypt("Hello")
     print(c, k)
     print(Onepad().decrypt(c, k))
diff --git a/ciphers/playfair_cipher.py b/ciphers/playfair_cipher.py
index 20449b161963..030fe8155a69 100644
--- a/ciphers/playfair_cipher.py
+++ b/ciphers/playfair_cipher.py
@@ -1,14 +1,14 @@
 import string
 import itertools
 
+
 def chunker(seq, size):
     it = iter(seq)
     while True:
-       chunk = tuple(itertools.islice(it, size))
-       if not chunk:
-           return
-       yield chunk
-
+        chunk = tuple(itertools.islice(it, size))
+        if not chunk:
+            return
+        yield chunk
 
 
 def prepare_input(dirty):
@@ -16,32 +16,33 @@ def prepare_input(dirty):
     Prepare the plaintext by up-casing it
     and separating repeated letters with X's
     """
-    
-    dirty = ''.join([c.upper() for c in dirty if c in string.ascii_letters])
+
+    dirty = "".join([c.upper() for c in dirty if c in string.ascii_letters])
     clean = ""
-    
+
     if len(dirty) < 2:
         return dirty
 
-    for i in range(len(dirty)-1):
+    for i in range(len(dirty) - 1):
         clean += dirty[i]
-        
-        if dirty[i] == dirty[i+1]:
-            clean += 'X'
-    
+
+        if dirty[i] == dirty[i + 1]:
+            clean += "X"
+
     clean += dirty[-1]
 
     if len(clean) & 1:
-        clean += 'X'
+        clean += "X"
 
     return clean
 
+
 def generate_table(key):
 
     # I and J are used interchangeably to allow
     # us to use a 5x5 table (25 letters)
     alphabet = "ABCDEFGHIKLMNOPQRSTUVWXYZ"
-    # we're using a list instead of a '2d' array because it makes the math 
+    # we're using a list instead of a '2d' array because it makes the math
     # for setting up the table and doing the actual encoding/decoding simpler
     table = []
 
@@ -57,6 +58,7 @@ def generate_table(key):
 
     return table
 
+
 def encode(plaintext, key):
     table = generate_table(key)
     plaintext = prepare_input(plaintext)
@@ -68,14 +70,14 @@ def encode(plaintext, key):
         row2, col2 = divmod(table.index(char2), 5)
 
         if row1 == row2:
-            ciphertext += table[row1*5+(col1+1)%5]
-            ciphertext += table[row2*5+(col2+1)%5]
+            ciphertext += table[row1 * 5 + (col1 + 1) % 5]
+            ciphertext += table[row2 * 5 + (col2 + 1) % 5]
         elif col1 == col2:
-            ciphertext += table[((row1+1)%5)*5+col1]
-            ciphertext += table[((row2+1)%5)*5+col2]
-        else: # rectangle
-            ciphertext += table[row1*5+col2]
-            ciphertext += table[row2*5+col1]
+            ciphertext += table[((row1 + 1) % 5) * 5 + col1]
+            ciphertext += table[((row2 + 1) % 5) * 5 + col2]
+        else:  # rectangle
+            ciphertext += table[row1 * 5 + col2]
+            ciphertext += table[row2 * 5 + col1]
 
     return ciphertext
 
@@ -90,13 +92,13 @@ def decode(ciphertext, key):
         row2, col2 = divmod(table.index(char2), 5)
 
         if row1 == row2:
-            plaintext += table[row1*5+(col1-1)%5]
-            plaintext += table[row2*5+(col2-1)%5]
+            plaintext += table[row1 * 5 + (col1 - 1) % 5]
+            plaintext += table[row2 * 5 + (col2 - 1) % 5]
         elif col1 == col2:
-            plaintext += table[((row1-1)%5)*5+col1]
-            plaintext += table[((row2-1)%5)*5+col2]
-        else: # rectangle
-            plaintext += table[row1*5+col2]
-            plaintext += table[row2*5+col1]
+            plaintext += table[((row1 - 1) % 5) * 5 + col1]
+            plaintext += table[((row2 - 1) % 5) * 5 + col2]
+        else:  # rectangle
+            plaintext += table[row1 * 5 + col2]
+            plaintext += table[row2 * 5 + col1]
 
     return plaintext
diff --git a/ciphers/rabin_miller.py b/ciphers/rabin_miller.py
index 21378cff6885..c544abdf9acc 100644
--- a/ciphers/rabin_miller.py
+++ b/ciphers/rabin_miller.py
@@ -2,6 +2,7 @@
 
 import random
 
+
 def rabinMiller(num):
     s = num - 1
     t = 0
@@ -23,24 +24,181 @@ def rabinMiller(num):
                     v = (v ** 2) % num
     return True
 
+
 def isPrime(num):
-    if (num < 2):
+    if num < 2:
         return False
 
-    lowPrimes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59,
-                 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127,
-                 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191,
-                 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257,
-                 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331,
-                 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401,
-                 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467,
-                 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563,
-                 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631,
-                 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709,
-                 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797,
-                 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877,
-                 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967,
-                 971, 977, 983, 991, 997]
+    lowPrimes = [
+        2,
+        3,
+        5,
+        7,
+        11,
+        13,
+        17,
+        19,
+        23,
+        29,
+        31,
+        37,
+        41,
+        43,
+        47,
+        53,
+        59,
+        61,
+        67,
+        71,
+        73,
+        79,
+        83,
+        89,
+        97,
+        101,
+        103,
+        107,
+        109,
+        113,
+        127,
+        131,
+        137,
+        139,
+        149,
+        151,
+        157,
+        163,
+        167,
+        173,
+        179,
+        181,
+        191,
+        193,
+        197,
+        199,
+        211,
+        223,
+        227,
+        229,
+        233,
+        239,
+        241,
+        251,
+        257,
+        263,
+        269,
+        271,
+        277,
+        281,
+        283,
+        293,
+        307,
+        311,
+        313,
+        317,
+        331,
+        337,
+        347,
+        349,
+        353,
+        359,
+        367,
+        373,
+        379,
+        383,
+        389,
+        397,
+        401,
+        409,
+        419,
+        421,
+        431,
+        433,
+        439,
+        443,
+        449,
+        457,
+        461,
+        463,
+        467,
+        479,
+        487,
+        491,
+        499,
+        503,
+        509,
+        521,
+        523,
+        541,
+        547,
+        557,
+        563,
+        569,
+        571,
+        577,
+        587,
+        593,
+        599,
+        601,
+        607,
+        613,
+        617,
+        619,
+        631,
+        641,
+        643,
+        647,
+        653,
+        659,
+        661,
+        673,
+        677,
+        683,
+        691,
+        701,
+        709,
+        719,
+        727,
+        733,
+        739,
+        743,
+        751,
+        757,
+        761,
+        769,
+        773,
+        787,
+        797,
+        809,
+        811,
+        821,
+        823,
+        827,
+        829,
+        839,
+        853,
+        857,
+        859,
+        863,
+        877,
+        881,
+        883,
+        887,
+        907,
+        911,
+        919,
+        929,
+        937,
+        941,
+        947,
+        953,
+        967,
+        971,
+        977,
+        983,
+        991,
+        997,
+    ]
 
     if num in lowPrimes:
         return True
@@ -51,13 +209,15 @@ def isPrime(num):
 
     return rabinMiller(num)
 
-def generateLargePrime(keysize = 1024):
+
+def generateLargePrime(keysize=1024):
     while True:
         num = random.randrange(2 ** (keysize - 1), 2 ** (keysize))
         if isPrime(num):
             return num
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
     num = generateLargePrime()
-    print(('Prime number:', num))
-    print(('isPrime:', isPrime(num)))
+    print(("Prime number:", num))
+    print(("isPrime:", isPrime(num)))
diff --git a/ciphers/rot13.py b/ciphers/rot13.py
index 208de4890e67..a7b546511967 100644
--- a/ciphers/rot13.py
+++ b/ciphers/rot13.py
@@ -1,17 +1,17 @@
 def dencrypt(s, n):
-    out = ''
+    out = ""
     for c in s:
-        if c >= 'A' and c <= 'Z':
-            out += chr(ord('A') + (ord(c) - ord('A') + n) % 26)
-        elif c >= 'a' and c <= 'z':
-            out += chr(ord('a') + (ord(c) - ord('a') + n) % 26)
+        if c >= "A" and c <= "Z":
+            out += chr(ord("A") + (ord(c) - ord("A") + n) % 26)
+        elif c >= "a" and c <= "z":
+            out += chr(ord("a") + (ord(c) - ord("a") + n) % 26)
         else:
             out += c
     return out
 
 
 def main():
-    s0 = 'HELLO'
+    s0 = "HELLO"
 
     s1 = dencrypt(s0, 13)
     print(s1)  # URYYB
@@ -20,5 +20,5 @@ def main():
     print(s2)  # HELLO
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
diff --git a/ciphers/rsa_cipher.py b/ciphers/rsa_cipher.py
index 02e5d95d1e95..a9b2dcc55daa 100644
--- a/ciphers/rsa_cipher.py
+++ b/ciphers/rsa_cipher.py
@@ -3,41 +3,42 @@
 DEFAULT_BLOCK_SIZE = 128
 BYTE_SIZE = 256
 
+
 def main():
-    filename = 'encrypted_file.txt'
-    response = input(r'Encrypte\Decrypt [e\d]: ')
+    filename = "encrypted_file.txt"
+    response = input(r"Encrypte\Decrypt [e\d]: ")
 
-    if response.lower().startswith('e'):
-        mode = 'encrypt'
-    elif response.lower().startswith('d'):
-        mode = 'decrypt'
+    if response.lower().startswith("e"):
+        mode = "encrypt"
+    elif response.lower().startswith("d"):
+        mode = "decrypt"
 
-    if mode == 'encrypt':
-        if not os.path.exists('rsa_pubkey.txt'):
-            rkg.makeKeyFiles('rsa', 1024)
+    if mode == "encrypt":
+        if not os.path.exists("rsa_pubkey.txt"):
+            rkg.makeKeyFiles("rsa", 1024)
 
-        message = input('\nEnter message: ')
-        pubKeyFilename = 'rsa_pubkey.txt'
-        print('Encrypting and writing to %s...' % (filename))
+        message = input("\nEnter message: ")
+        pubKeyFilename = "rsa_pubkey.txt"
+        print("Encrypting and writing to %s..." % (filename))
         encryptedText = encryptAndWriteToFile(filename, pubKeyFilename, message)
 
-        print('\nEncrypted text:')
+        print("\nEncrypted text:")
         print(encryptedText)
 
-    elif mode == 'decrypt':
-        privKeyFilename = 'rsa_privkey.txt'
-        print('Reading from %s and decrypting...' % (filename))
+    elif mode == "decrypt":
+        privKeyFilename = "rsa_privkey.txt"
+        print("Reading from %s and decrypting..." % (filename))
         decryptedText = readFromFileAndDecrypt(filename, privKeyFilename)
-        print('writing decryption to rsa_decryption.txt...')
-        with open('rsa_decryption.txt', 'w') as dec:
+        print("writing decryption to rsa_decryption.txt...")
+        with open("rsa_decryption.txt", "w") as dec:
             dec.write(decryptedText)
 
-        print('\nDecryption:')
+        print("\nDecryption:")
         print(decryptedText)
 
 
 def getBlocksFromText(message, blockSize=DEFAULT_BLOCK_SIZE):
-    messageBytes = message.encode('ascii')
+    messageBytes = message.encode("ascii")
 
     blockInts = []
     for blockStart in range(0, len(messageBytes), blockSize):
@@ -58,7 +59,7 @@ def getTextFromBlocks(blockInts, messageLength, blockSize=DEFAULT_BLOCK_SIZE):
                 blockInt = blockInt % (BYTE_SIZE ** i)
                 blockMessage.insert(0, chr(asciiNumber))
         message.extend(blockMessage)
-    return ''.join(message)
+    return "".join(message)
 
 
 def encryptMessage(message, key, blockSize=DEFAULT_BLOCK_SIZE):
@@ -81,22 +82,27 @@ def decryptMessage(encryptedBlocks, messageLength, key, blockSize=DEFAULT_BLOCK_
 def readKeyFile(keyFilename):
     with open(keyFilename) as fo:
         content = fo.read()
-    keySize, n, EorD = content.split(',')
+    keySize, n, EorD = content.split(",")
     return (int(keySize), int(n), int(EorD))
 
 
-def encryptAndWriteToFile(messageFilename, keyFilename, message, blockSize=DEFAULT_BLOCK_SIZE):
+def encryptAndWriteToFile(
+    messageFilename, keyFilename, message, blockSize=DEFAULT_BLOCK_SIZE
+):
     keySize, n, e = readKeyFile(keyFilename)
     if keySize < blockSize * 8:
-        sys.exit('ERROR: Block size is %s bits and key size is %s bits. The RSA cipher requires the block size to be equal to or greater than the key size. Either decrease the block size or use different keys.' % (blockSize * 8, keySize))
+        sys.exit(
+            "ERROR: Block size is %s bits and key size is %s bits. The RSA cipher requires the block size to be equal to or greater than the key size. Either decrease the block size or use different keys."
+            % (blockSize * 8, keySize)
+        )
 
     encryptedBlocks = encryptMessage(message, (n, e), blockSize)
 
     for i in range(len(encryptedBlocks)):
         encryptedBlocks[i] = str(encryptedBlocks[i])
-    encryptedContent = ','.join(encryptedBlocks)
-    encryptedContent = '%s_%s_%s' % (len(message), blockSize, encryptedContent)
-    with open(messageFilename, 'w') as fo:
+    encryptedContent = ",".join(encryptedBlocks)
+    encryptedContent = "%s_%s_%s" % (len(message), blockSize, encryptedContent)
+    with open(messageFilename, "w") as fo:
         fo.write(encryptedContent)
     return encryptedContent
 
@@ -105,18 +111,22 @@ def readFromFileAndDecrypt(messageFilename, keyFilename):
     keySize, n, d = readKeyFile(keyFilename)
     with open(messageFilename) as fo:
         content = fo.read()
-    messageLength, blockSize, encryptedMessage = content.split('_')
+    messageLength, blockSize, encryptedMessage = content.split("_")
     messageLength = int(messageLength)
     blockSize = int(blockSize)
 
     if keySize < blockSize * 8:
-        sys.exit('ERROR: Block size is %s bits and key size is %s bits. The RSA cipher requires the block size to be equal to or greater than the key size. Did you specify the correct key file and encrypted file?' % (blockSize * 8, keySize))
+        sys.exit(
+            "ERROR: Block size is %s bits and key size is %s bits. The RSA cipher requires the block size to be equal to or greater than the key size. Did you specify the correct key file and encrypted file?"
+            % (blockSize * 8, keySize)
+        )
 
     encryptedBlocks = []
-    for block in encryptedMessage.split(','):
+    for block in encryptedMessage.split(","):
         encryptedBlocks.append(int(block))
 
     return decryptMessage(encryptedBlocks, messageLength, (n, d), blockSize)
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
     main()
diff --git a/ciphers/rsa_key_generator.py b/ciphers/rsa_key_generator.py
index 7cd7163b68d5..ce7c1f3dd12b 100644
--- a/ciphers/rsa_key_generator.py
+++ b/ciphers/rsa_key_generator.py
@@ -1,45 +1,54 @@
 import random, sys, os
 import rabin_miller as rabinMiller, cryptomath_module as cryptoMath
 
+
 def main():
-    print('Making key files...')
-    makeKeyFiles('rsa', 1024)
-    print('Key files generation successful.')
+    print("Making key files...")
+    makeKeyFiles("rsa", 1024)
+    print("Key files generation successful.")
+
 
 def generateKey(keySize):
-    print('Generating prime p...')
+    print("Generating prime p...")
     p = rabinMiller.generateLargePrime(keySize)
-    print('Generating prime q...')
+    print("Generating prime q...")
     q = rabinMiller.generateLargePrime(keySize)
     n = p * q
 
-    print('Generating e that is relatively prime to (p - 1) * (q - 1)...')
+    print("Generating e that is relatively prime to (p - 1) * (q - 1)...")
     while True:
         e = random.randrange(2 ** (keySize - 1), 2 ** (keySize))
         if cryptoMath.gcd(e, (p - 1) * (q - 1)) == 1:
             break
 
-    print('Calculating d that is mod inverse of e...')
+    print("Calculating d that is mod inverse of e...")
     d = cryptoMath.findModInverse(e, (p - 1) * (q - 1))
 
     publicKey = (n, e)
     privateKey = (n, d)
     return (publicKey, privateKey)
 
+
 def makeKeyFiles(name, keySize):
-    if os.path.exists('%s_pubkey.txt' % (name)) or os.path.exists('%s_privkey.txt' % (name)):
-        print('\nWARNING:')
-        print('"%s_pubkey.txt" or "%s_privkey.txt" already exists. \nUse a different name or delete these files and re-run this program.' % (name, name))
+    if os.path.exists("%s_pubkey.txt" % (name)) or os.path.exists(
+        "%s_privkey.txt" % (name)
+    ):
+        print("\nWARNING:")
+        print(
+            '"%s_pubkey.txt" or "%s_privkey.txt" already exists. \nUse a different name or delete these files and re-run this program.'
+            % (name, name)
+        )
         sys.exit()
 
     publicKey, privateKey = generateKey(keySize)
-    print('\nWriting public key to file %s_pubkey.txt...' % name)
-    with open('%s_pubkey.txt' % name, 'w') as fo:
-        fo.write('%s,%s,%s' % (keySize, publicKey[0], publicKey[1]))
+    print("\nWriting public key to file %s_pubkey.txt..." % name)
+    with open("%s_pubkey.txt" % name, "w") as fo:
+        fo.write("%s,%s,%s" % (keySize, publicKey[0], publicKey[1]))
+
+    print("Writing private key to file %s_privkey.txt..." % name)
+    with open("%s_privkey.txt" % name, "w") as fo:
+        fo.write("%s,%s,%s" % (keySize, privateKey[0], privateKey[1]))
 
-    print('Writing private key to file %s_privkey.txt...' % name)
-    with open('%s_privkey.txt' % name, 'w') as fo:
-        fo.write('%s,%s,%s' % (keySize, privateKey[0], privateKey[1]))
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
diff --git a/ciphers/simple_substitution_cipher.py b/ciphers/simple_substitution_cipher.py
index 5da07f8526b9..12511cc39bbc 100644
--- a/ciphers/simple_substitution_cipher.py
+++ b/ciphers/simple_substitution_cipher.py
@@ -1,22 +1,24 @@
 import sys, random
 
-LETTERS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+LETTERS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+
 
 def main():
-    message = input('Enter message: ')
-    key = 'LFWOAYUISVKMNXPBDCRJTQEGHZ'
-    resp = input('Encrypt/Decrypt [e/d]: ')
+    message = input("Enter message: ")
+    key = "LFWOAYUISVKMNXPBDCRJTQEGHZ"
+    resp = input("Encrypt/Decrypt [e/d]: ")
 
     checkValidKey(key)
 
-    if resp.lower().startswith('e'):
-        mode = 'encrypt'
+    if resp.lower().startswith("e"):
+        mode = "encrypt"
         translated = encryptMessage(key, message)
-    elif resp.lower().startswith('d'):
-        mode = 'decrypt'
+    elif resp.lower().startswith("d"):
+        mode = "decrypt"
         translated = decryptMessage(key, message)
 
-    print('\n%sion: \n%s' % (mode.title(), translated))
+    print("\n%sion: \n%s" % (mode.title(), translated))
+
 
 def checkValidKey(key):
     keyList = list(key)
@@ -25,28 +27,31 @@ def checkValidKey(key):
     lettersList.sort()
 
     if keyList != lettersList:
-        sys.exit('Error in the key or symbol set.')
+        sys.exit("Error in the key or symbol set.")
+
 
 def encryptMessage(key, message):
     """
     >>> encryptMessage('LFWOAYUISVKMNXPBDCRJTQEGHZ', 'Harshil Darji')
     'Ilcrism Olcvs'
     """
-    return translateMessage(key, message, 'encrypt')
+    return translateMessage(key, message, "encrypt")
+
 
 def decryptMessage(key, message):
     """
     >>> decryptMessage('LFWOAYUISVKMNXPBDCRJTQEGHZ', 'Ilcrism Olcvs')
     'Harshil Darji'
     """
-    return translateMessage(key, message, 'decrypt')
+    return translateMessage(key, message, "decrypt")
+
 
 def translateMessage(key, message, mode):
-    translated = ''
+    translated = ""
     charsA = LETTERS
     charsB = key
 
-    if mode == 'decrypt':
+    if mode == "decrypt":
         charsA, charsB = charsB, charsA
 
     for symbol in message:
@@ -61,10 +66,12 @@ def translateMessage(key, message, mode):
 
     return translated
 
+
 def getRandomKey():
     key = list(LETTERS)
     random.shuffle(key)
-    return ''.join(key)
+    return "".join(key)
+
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
diff --git a/ciphers/trafid_cipher.py b/ciphers/trafid_cipher.py
index 53f4d288bfe2..0add9ee74beb 100644
--- a/ciphers/trafid_cipher.py
+++ b/ciphers/trafid_cipher.py
@@ -1,4 +1,5 @@
-#https://en.wikipedia.org/wiki/Trifid_cipher
+# https://en.wikipedia.org/wiki/Trifid_cipher
+
 
 def __encryptPart(messagePart, character2Number):
     one, two, three = "", "", ""
@@ -12,7 +13,8 @@ def __encryptPart(messagePart, character2Number):
         two += each[1]
         three += each[2]
 
-    return one+two+three
+    return one + two + three
+
 
 def __decryptPart(messagePart, character2Number):
     tmp, thisPart = "", ""
@@ -29,20 +31,49 @@ def __decryptPart(messagePart, character2Number):
 
     return result[0], result[1], result[2]
 
+
 def __prepare(message, alphabet):
-    #Validate message and alphabet, set to upper and remove spaces
+    # Validate message and alphabet, set to upper and remove spaces
     alphabet = alphabet.replace(" ", "").upper()
     message = message.replace(" ", "").upper()
 
-    #Check length and characters
+    # Check length and characters
     if len(alphabet) != 27:
         raise KeyError("Length of alphabet has to be 27.")
     for each in message:
         if each not in alphabet:
             raise ValueError("Each message character has to be included in alphabet!")
 
-    #Generate dictionares
-    numbers = ("111","112","113","121","122","123","131","132","133","211","212","213","221","222","223","231","232","233","311","312","313","321","322","323","331","332","333")
+    # Generate dictionares
+    numbers = (
+        "111",
+        "112",
+        "113",
+        "121",
+        "122",
+        "123",
+        "131",
+        "132",
+        "133",
+        "211",
+        "212",
+        "213",
+        "221",
+        "222",
+        "223",
+        "231",
+        "232",
+        "233",
+        "311",
+        "312",
+        "313",
+        "321",
+        "322",
+        "323",
+        "331",
+        "332",
+        "333",
+    )
     character2Number = {}
     number2Character = {}
     for letter, number in zip(alphabet, numbers):
@@ -51,36 +82,39 @@ def __prepare(message, alphabet):
 
     return message, alphabet, character2Number, number2Character
 
-def encryptMessage(message, alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ.", period=5):
+
+def encryptMessage(message, alphabet="ABCDEFGHIJKLMNOPQRSTUVWXYZ.", period=5):
     message, alphabet, character2Number, number2Character = __prepare(message, alphabet)
     encrypted, encrypted_numeric = "", ""
 
-    for i in range(0, len(message)+1, period):
-        encrypted_numeric += __encryptPart(message[i:i+period], character2Number)
+    for i in range(0, len(message) + 1, period):
+        encrypted_numeric += __encryptPart(message[i : i + period], character2Number)
 
     for i in range(0, len(encrypted_numeric), 3):
-        encrypted += number2Character[encrypted_numeric[i:i+3]]
+        encrypted += number2Character[encrypted_numeric[i : i + 3]]
 
     return encrypted
 
-def decryptMessage(message, alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ.", period=5):
+
+def decryptMessage(message, alphabet="ABCDEFGHIJKLMNOPQRSTUVWXYZ.", period=5):
     message, alphabet, character2Number, number2Character = __prepare(message, alphabet)
     decrypted_numeric = []
     decrypted = ""
 
-    for i in range(0, len(message)+1, period):
-        a,b,c = __decryptPart(message[i:i+period], character2Number)
+    for i in range(0, len(message) + 1, period):
+        a, b, c = __decryptPart(message[i : i + period], character2Number)
 
         for j in range(0, len(a)):
-            decrypted_numeric.append(a[j]+b[j]+c[j])
+            decrypted_numeric.append(a[j] + b[j] + c[j])
 
     for each in decrypted_numeric:
         decrypted += number2Character[each]
 
     return decrypted
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
     msg = "DEFEND THE EAST WALL OF THE CASTLE."
-    encrypted = encryptMessage(msg,"EPSDUCVWYM.ZLKXNBTFGORIJHAQ")
+    encrypted = encryptMessage(msg, "EPSDUCVWYM.ZLKXNBTFGORIJHAQ")
     decrypted = decryptMessage(encrypted, "EPSDUCVWYM.ZLKXNBTFGORIJHAQ")
     print("Encrypted: {}\nDecrypted: {}".format(encrypted, decrypted))
diff --git a/ciphers/transposition_cipher.py b/ciphers/transposition_cipher.py
index 1c2ed0aa0452..b6c9195b5dee 100644
--- a/ciphers/transposition_cipher.py
+++ b/ciphers/transposition_cipher.py
@@ -1,30 +1,33 @@
 import math
 
+
 def main():
-    message = input('Enter message: ')
-    key = int(input('Enter key [2-%s]: ' % (len(message) - 1)))
-    mode = input('Encryption/Decryption [e/d]: ')
+    message = input("Enter message: ")
+    key = int(input("Enter key [2-%s]: " % (len(message) - 1)))
+    mode = input("Encryption/Decryption [e/d]: ")
 
-    if mode.lower().startswith('e'):
+    if mode.lower().startswith("e"):
         text = encryptMessage(key, message)
-    elif mode.lower().startswith('d'):
+    elif mode.lower().startswith("d"):
         text = decryptMessage(key, message)
 
     # Append pipe symbol (vertical bar) to identify spaces at the end.
-    print('Output:\n%s' %(text + '|'))
+    print("Output:\n%s" % (text + "|"))
+
 
 def encryptMessage(key, message):
     """
     >>> encryptMessage(6, 'Harshil Darji')
     'Hlia rDsahrij'
     """
-    cipherText = [''] * key
+    cipherText = [""] * key
     for col in range(key):
         pointer = col
         while pointer < len(message):
             cipherText[col] += message[pointer]
             pointer += key
-    return ''.join(cipherText)
+    return "".join(cipherText)
+
 
 def decryptMessage(key, message):
     """
@@ -35,19 +38,26 @@ def decryptMessage(key, message):
     numRows = key
     numShadedBoxes = (numCols * numRows) - len(message)
     plainText = [""] * numCols
-    col = 0; row = 0;
+    col = 0
+    row = 0
 
     for symbol in message:
         plainText[col] += symbol
         col += 1
 
-        if (col == numCols) or (col == numCols - 1) and (row >= numRows - numShadedBoxes):
+        if (
+            (col == numCols)
+            or (col == numCols - 1)
+            and (row >= numRows - numShadedBoxes)
+        ):
             col = 0
             row += 1
 
     return "".join(plainText)
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
     import doctest
+
     doctest.testmod()
     main()
diff --git a/ciphers/transposition_cipher_encrypt_decrypt_file.py b/ciphers/transposition_cipher_encrypt_decrypt_file.py
index 8ebfc1ea7e0c..775df354e117 100644
--- a/ciphers/transposition_cipher_encrypt_decrypt_file.py
+++ b/ciphers/transposition_cipher_encrypt_decrypt_file.py
@@ -1,36 +1,38 @@
 import time, os, sys
 import transposition_cipher as transCipher
 
+
 def main():
-    inputFile = 'Prehistoric Men.txt'
-    outputFile = 'Output.txt'
-    key = int(input('Enter key: '))
-    mode = input('Encrypt/Decrypt [e/d]: ')
+    inputFile = "Prehistoric Men.txt"
+    outputFile = "Output.txt"
+    key = int(input("Enter key: "))
+    mode = input("Encrypt/Decrypt [e/d]: ")
 
     if not os.path.exists(inputFile):
-        print('File %s does not exist. Quitting...' % inputFile)
+        print("File %s does not exist. Quitting..." % inputFile)
         sys.exit()
     if os.path.exists(outputFile):
-        print('Overwrite %s? [y/n]' % outputFile)
-        response = input('> ')
-        if not response.lower().startswith('y'):
+        print("Overwrite %s? [y/n]" % outputFile)
+        response = input("> ")
+        if not response.lower().startswith("y"):
             sys.exit()
 
     startTime = time.time()
-    if mode.lower().startswith('e'):
+    if mode.lower().startswith("e"):
         with open(inputFile) as f:
             content = f.read()
         translated = transCipher.encryptMessage(key, content)
-    elif mode.lower().startswith('d'):
+    elif mode.lower().startswith("d"):
         with open(outputFile) as f:
             content = f.read()
-        translated =transCipher .decryptMessage(key, content)
+        translated = transCipher.decryptMessage(key, content)
 
-    with open(outputFile, 'w') as outputObj:
+    with open(outputFile, "w") as outputObj:
         outputObj.write(translated)
 
     totalTime = round(time.time() - startTime, 2)
-    print(('Done (', totalTime, 'seconds )'))
+    print(("Done (", totalTime, "seconds )"))
+
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
diff --git a/ciphers/vigenere_cipher.py b/ciphers/vigenere_cipher.py
index 95eeb431109f..6c10e7d773f2 100644
--- a/ciphers/vigenere_cipher.py
+++ b/ciphers/vigenere_cipher.py
@@ -1,33 +1,37 @@
-LETTERS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+LETTERS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+
 
 def main():
-    message = input('Enter message: ')
-    key = input('Enter key [alphanumeric]: ')
-    mode = input('Encrypt/Decrypt [e/d]: ')
+    message = input("Enter message: ")
+    key = input("Enter key [alphanumeric]: ")
+    mode = input("Encrypt/Decrypt [e/d]: ")
 
-    if mode.lower().startswith('e'):
-        mode = 'encrypt'
+    if mode.lower().startswith("e"):
+        mode = "encrypt"
         translated = encryptMessage(key, message)
-    elif mode.lower().startswith('d'):
-        mode = 'decrypt'
+    elif mode.lower().startswith("d"):
+        mode = "decrypt"
         translated = decryptMessage(key, message)
 
-    print('\n%sed message:' % mode.title())
+    print("\n%sed message:" % mode.title())
     print(translated)
 
+
 def encryptMessage(key, message):
-    '''
+    """
     >>> encryptMessage('HDarji', 'This is Harshil Darji from Dharmaj.')
     'Akij ra Odrjqqs Gaisq muod Mphumrs.'
-    '''
-    return translateMessage(key, message, 'encrypt')
+    """
+    return translateMessage(key, message, "encrypt")
+
 
 def decryptMessage(key, message):
-    '''
+    """
     >>> decryptMessage('HDarji', 'Akij ra Odrjqqs Gaisq muod Mphumrs.')
     'This is Harshil Darji from Dharmaj.'
-    '''
-    return translateMessage(key, message, 'decrypt')
+    """
+    return translateMessage(key, message, "decrypt")
+
 
 def translateMessage(key, message, mode):
     translated = []
@@ -37,9 +41,9 @@ def translateMessage(key, message, mode):
     for symbol in message:
         num = LETTERS.find(symbol.upper())
         if num != -1:
-            if mode == 'encrypt':
+            if mode == "encrypt":
                 num += LETTERS.find(key[keyIndex])
-            elif mode == 'decrypt':
+            elif mode == "decrypt":
                 num -= LETTERS.find(key[keyIndex])
 
             num %= len(LETTERS)
@@ -54,7 +58,8 @@ def translateMessage(key, message, mode):
                 keyIndex = 0
         else:
             translated.append(symbol)
-    return ''.join(translated)
+    return "".join(translated)
+
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
diff --git a/ciphers/xor_cipher.py b/ciphers/xor_cipher.py
index 8bb94212c15a..7d8dbe41fdea 100644
--- a/ciphers/xor_cipher.py
+++ b/ciphers/xor_cipher.py
@@ -16,121 +16,120 @@
 	- encrypt_file : boolean
 	- decrypt_file : boolean
 """
-class XORCipher(object):
 
-	def __init__(self, key = 0):
-		"""
+
+class XORCipher(object):
+    def __init__(self, key=0):
+        """
 			simple constructor that receives a key or uses
 			default key = 0
 		"""
 
-		#private field
-		self.__key = key
+        # private field
+        self.__key = key
 
-	def encrypt(self, content, key):
-		"""
+    def encrypt(self, content, key):
+        """
 			input: 'content' of type string and 'key' of type int
 			output: encrypted string 'content' as a list of chars
 			if key not passed the method uses the key by the constructor.
 			otherwise key = 1
 		"""
 
-		# precondition
-		assert (isinstance(key,int) and isinstance(content,str))
+        # precondition
+        assert isinstance(key, int) and isinstance(content, str)
 
-		key = key or self.__key or 1
+        key = key or self.__key or 1
 
-		# make sure key can be any size
-		while (key > 255):
-			key -= 255
+        # make sure key can be any size
+        while key > 255:
+            key -= 255
 
-		# This will be returned
-		ans = []
+        # This will be returned
+        ans = []
 
-		for ch in content:
-			ans.append(chr(ord(ch) ^ key))
+        for ch in content:
+            ans.append(chr(ord(ch) ^ key))
 
-		return ans
+        return ans
 
-	def decrypt(self,content,key):
-		"""
+    def decrypt(self, content, key):
+        """
 			input: 'content' of type list and 'key' of type int
 			output: decrypted string 'content' as a list of chars
 			if key not passed the method uses the key by the constructor.
 			otherwise key = 1
 		"""
 
-		# precondition
-		assert (isinstance(key,int) and isinstance(content,list))
+        # precondition
+        assert isinstance(key, int) and isinstance(content, list)
 
-		key = key or self.__key or 1
+        key = key or self.__key or 1
 
-		# make sure key can be any size
-		while (key > 255):
-			key -= 255
+        # make sure key can be any size
+        while key > 255:
+            key -= 255
 
-		# This will be returned
-		ans = []
+        # This will be returned
+        ans = []
 
-		for ch in content:
-			ans.append(chr(ord(ch) ^ key))
+        for ch in content:
+            ans.append(chr(ord(ch) ^ key))
 
-		return ans
+        return ans
 
-
-	def encrypt_string(self,content, key = 0):
-		"""
+    def encrypt_string(self, content, key=0):
+        """
 			input: 'content' of type string and 'key' of type int
 			output: encrypted string 'content'
 			if key not passed the method uses the key by the constructor.
 			otherwise key = 1
 		"""
 
-		# precondition
-		assert (isinstance(key,int) and isinstance(content,str))
+        # precondition
+        assert isinstance(key, int) and isinstance(content, str)
 
-		key = key or self.__key or 1
+        key = key or self.__key or 1
 
-		# make sure key can be any size
-		while (key > 255):
-			key -= 255
+        # make sure key can be any size
+        while key > 255:
+            key -= 255
 
-		# This will be returned
-		ans = ""
+        # This will be returned
+        ans = ""
 
-		for ch in content:
-			ans += chr(ord(ch) ^ key)
+        for ch in content:
+            ans += chr(ord(ch) ^ key)
 
-		return ans
+        return ans
 
-	def decrypt_string(self,content,key = 0):
-		"""
+    def decrypt_string(self, content, key=0):
+        """
 			input: 'content' of type string and 'key' of type int
 			output: decrypted string 'content'
 			if key not passed the method uses the key by the constructor.
 			otherwise key = 1
 		"""
 
-		# precondition
-		assert (isinstance(key,int) and isinstance(content,str))
-
-		key = key or self.__key or 1
+        # precondition
+        assert isinstance(key, int) and isinstance(content, str)
 
-		# make sure key can be any size
-		while (key > 255):
-			key -= 255
+        key = key or self.__key or 1
 
-		# This will be returned
-		ans = ""
+        # make sure key can be any size
+        while key > 255:
+            key -= 255
 
-		for ch in content:
-			ans += chr(ord(ch) ^ key)
+        # This will be returned
+        ans = ""
 
-		return ans
+        for ch in content:
+            ans += chr(ord(ch) ^ key)
 
+        return ans
 
-	def encrypt_file(self, file, key = 0):
-		"""
+    def encrypt_file(self, file, key=0):
+        """
 			input: filename (str) and a key (int)
 			output: returns true if encrypt process was
 			successful otherwise false
@@ -138,25 +137,24 @@ def encrypt_file(self, file, key = 0):
 			otherwise key = 1
 		"""
 
-		#precondition
-		assert (isinstance(file,str) and isinstance(key,int))
-
-		try:
-			with open(file,"r") as fin:
-				with open("encrypt.out","w+") as fout:
+        # precondition
+        assert isinstance(file, str) and isinstance(key, int)
 
-					# actual encrypt-process
-					for line in fin:
-						fout.write(self.encrypt_string(line,key))
+        try:
+            with open(file, "r") as fin:
+                with open("encrypt.out", "w+") as fout:
 
-		except:
-			return False
+                    # actual encrypt-process
+                    for line in fin:
+                        fout.write(self.encrypt_string(line, key))
 
-		return True
+        except:
+            return False
 
+        return True
 
-	def decrypt_file(self,file, key):
-		"""
+    def decrypt_file(self, file, key):
+        """
 			input: filename (str) and a key (int)
 			output: returns true if decrypt process was
 			successful otherwise false
@@ -164,23 +162,21 @@ def decrypt_file(self,file, key):
 			otherwise key = 1
 		"""
 
-		#precondition
-		assert (isinstance(file,str) and isinstance(key,int))
-
-		try:
-			with open(file,"r") as fin:
-				with open("decrypt.out","w+") as fout:
-
-					# actual encrypt-process
-					for line in fin:
-						fout.write(self.decrypt_string(line,key))
+        # precondition
+        assert isinstance(file, str) and isinstance(key, int)
 
-		except:
-			return False
+        try:
+            with open(file, "r") as fin:
+                with open("decrypt.out", "w+") as fout:
 
-		return True
+                    # actual encrypt-process
+                    for line in fin:
+                        fout.write(self.decrypt_string(line, key))
 
+        except:
+            return False
 
+        return True
 
 
 # Tests
diff --git a/compression/burrows_wheeler.py b/compression/burrows_wheeler.py
index fabeab39adf8..50ee62aa0cb3 100644
--- a/compression/burrows_wheeler.py
+++ b/compression/burrows_wheeler.py
@@ -141,15 +141,10 @@ def reverse_bwt(bwt_string: str, idx_original_string: int) -> str:
             )
         )
     if idx_original_string < 0:
-        raise ValueError(
-            "The parameter idx_original_string must not be lower than 0."
-        )
+        raise ValueError("The parameter idx_original_string must not be lower than 0.")
     if idx_original_string >= len(bwt_string):
         raise ValueError(
-            (
-                "The parameter idx_original_string must be lower than"
-                " len(bwt_string)."
-            )
+            ("The parameter idx_original_string must be lower than" " len(bwt_string).")
         )
 
     ordered_rotations = [""] * len(bwt_string)
@@ -166,9 +161,7 @@ def reverse_bwt(bwt_string: str, idx_original_string: int) -> str:
     result = bwt_transform(s)
     bwt_output_msg = "Burrows Wheeler tranform for string '{}' results in '{}'"
     print(bwt_output_msg.format(s, result["bwt_string"]))
-    original_string = reverse_bwt(
-        result["bwt_string"], result["idx_original_string"]
-    )
+    original_string = reverse_bwt(result["bwt_string"], result["idx_original_string"])
     fmt = (
         "Reversing Burrows Wheeler tranform for entry '{}' we get original"
         " string '{}'"
diff --git a/compression/huffman.py b/compression/huffman.py
index 7417551ba209..73c084351c85 100644
--- a/compression/huffman.py
+++ b/compression/huffman.py
@@ -1,5 +1,6 @@
 import sys
 
+
 class Letter:
     def __init__(self, letter, freq):
         self.letter = letter
@@ -7,7 +8,7 @@ def __init__(self, letter, freq):
         self.bitstring = ""
 
     def __repr__(self):
-        return f'{self.letter}:{self.freq}'
+        return f"{self.letter}:{self.freq}"
 
 
 class TreeNode:
@@ -31,6 +32,7 @@ def parse_file(file_path):
             chars[c] = chars[c] + 1 if c in chars.keys() else 1
     return sorted([Letter(c, f) for c, f in chars.items()], key=lambda l: l.freq)
 
+
 def build_tree(letters):
     """
     Run through the list of Letters and build the min heap
@@ -45,6 +47,7 @@ def build_tree(letters):
         letters.sort(key=lambda l: l.freq)
     return letters[0]
 
+
 def traverse_tree(root, bitstring):
     """
     Recursively traverse the Huffman Tree to set each
@@ -58,6 +61,7 @@ def traverse_tree(root, bitstring):
     letters += traverse_tree(root.right, bitstring + "1")
     return letters
 
+
 def huffman(file_path):
     """
     Parse the file, build the tree, then run through the file
@@ -67,7 +71,7 @@ def huffman(file_path):
     letters_list = parse_file(file_path)
     root = build_tree(letters_list)
     letters = traverse_tree(root, "")
-    print(f'Huffman Coding of {file_path}: ')
+    print(f"Huffman Coding of {file_path}: ")
     with open(file_path) as f:
         while True:
             c = f.read(1)
@@ -77,6 +81,7 @@ def huffman(file_path):
             print(le.bitstring, end=" ")
     print()
 
+
 if __name__ == "__main__":
     # pass the file path to the huffman function
     huffman(sys.argv[1])
diff --git a/compression/peak_signal_to_noise_ratio.py b/compression/peak_signal_to_noise_ratio.py
index b0efb1462dcc..418832a8127c 100644
--- a/compression/peak_signal_to_noise_ratio.py
+++ b/compression/peak_signal_to_noise_ratio.py
@@ -9,6 +9,7 @@
 import cv2
 import numpy as np
 
+
 def psnr(original, contrast):
     mse = np.mean((original - contrast) ** 2)
     if mse == 0:
@@ -21,11 +22,13 @@ def psnr(original, contrast):
 def main():
     dir_path = os.path.dirname(os.path.realpath(__file__))
     # Loading images (original image and compressed image)
-    original = cv2.imread(os.path.join(dir_path, 'image_data/original_image.png'))
-    contrast = cv2.imread(os.path.join(dir_path, 'image_data/compressed_image.png'), 1)
+    original = cv2.imread(os.path.join(dir_path, "image_data/original_image.png"))
+    contrast = cv2.imread(os.path.join(dir_path, "image_data/compressed_image.png"), 1)
 
-    original2 = cv2.imread(os.path.join(dir_path, 'image_data/PSNR-example-base.png'))
-    contrast2 = cv2.imread(os.path.join(dir_path, 'image_data/PSNR-example-comp-10.jpg'), 1)
+    original2 = cv2.imread(os.path.join(dir_path, "image_data/PSNR-example-base.png"))
+    contrast2 = cv2.imread(
+        os.path.join(dir_path, "image_data/PSNR-example-comp-10.jpg"), 1
+    )
 
     # Value expected: 29.73dB
     print("-- First Test --")
@@ -36,5 +39,5 @@ def main():
     print(f"PSNR value is {psnr(original2, contrast2)} dB")
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
diff --git a/conversions/decimal_to_binary.py b/conversions/decimal_to_binary.py
index 934cf0dfb363..ad4ba166745d 100644
--- a/conversions/decimal_to_binary.py
+++ b/conversions/decimal_to_binary.py
@@ -55,4 +55,5 @@ def decimal_to_binary(num):
 
 if __name__ == "__main__":
     import doctest
+
     doctest.testmod()
diff --git a/conversions/decimal_to_hexadecimal.py b/conversions/decimal_to_hexadecimal.py
index e6435f1ef570..a70e3c7b97bf 100644
--- a/conversions/decimal_to_hexadecimal.py
+++ b/conversions/decimal_to_hexadecimal.py
@@ -2,24 +2,25 @@
 
 # set decimal value for each hexadecimal digit
 values = {
-    0:'0',
-    1:'1',
-    2:'2',
-    3:'3',
-    4:'4',
-    5:'5',
-    6:'6',
-    7:'7',
-    8:'8',
-    9:'9',
-    10:'a',
-    11:'b',
-    12:'c',
-    13:'d',
-    14:'e',
-    15:'f'
+    0: "0",
+    1: "1",
+    2: "2",
+    3: "3",
+    4: "4",
+    5: "5",
+    6: "6",
+    7: "7",
+    8: "8",
+    9: "9",
+    10: "a",
+    11: "b",
+    12: "c",
+    13: "d",
+    14: "e",
+    15: "f",
 }
 
+
 def decimal_to_hexadecimal(decimal):
     """
         take integer decimal value, return hexadecimal representation as str beginning with 0x
@@ -56,7 +57,7 @@ def decimal_to_hexadecimal(decimal):
         True
     """
     assert type(decimal) in (int, float) and decimal == int(decimal)
-    hexadecimal = ''
+    hexadecimal = ""
     negative = False
     if decimal < 0:
         negative = True
@@ -64,11 +65,13 @@ def decimal_to_hexadecimal(decimal):
     while decimal > 0:
         decimal, remainder = divmod(decimal, 16)
         hexadecimal = values[remainder] + hexadecimal
-    hexadecimal = '0x' + hexadecimal
+    hexadecimal = "0x" + hexadecimal
     if negative:
-        hexadecimal = '-' + hexadecimal
+        hexadecimal = "-" + hexadecimal
     return hexadecimal
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
     import doctest
+
     doctest.testmod()
diff --git a/conversions/decimal_to_octal.py b/conversions/decimal_to_octal.py
index 187a0300e33a..0b005429d9d7 100644
--- a/conversions/decimal_to_octal.py
+++ b/conversions/decimal_to_octal.py
@@ -16,7 +16,7 @@ def decimal_to_octal(num):
         counter += 1
         num = math.floor(num / 8)  # basically /= 8 without remainder if any
         # This formatting removes trailing '.0' from `octal`.
-    return'{0:g}'.format(float(octal))
+    return "{0:g}".format(float(octal))
 
 
 def main():
@@ -34,5 +34,5 @@ def main():
     print("\n")
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
diff --git a/data_structures/binary_tree/avl_tree.py b/data_structures/binary_tree/avl_tree.py
index ff44963d1690..31d12c811105 100644
--- a/data_structures/binary_tree/avl_tree.py
+++ b/data_structures/binary_tree/avl_tree.py
@@ -1,71 +1,88 @@
 # -*- coding: utf-8 -*-
-'''
+"""
 An auto-balanced binary tree!
-'''
+"""
 import math
 import random
+
+
 class my_queue:
     def __init__(self):
         self.data = []
         self.head = 0
         self.tail = 0
+
     def isEmpty(self):
         return self.head == self.tail
-    def push(self,data):
+
+    def push(self, data):
         self.data.append(data)
         self.tail = self.tail + 1
+
     def pop(self):
         ret = self.data[self.head]
         self.head = self.head + 1
         return ret
+
     def count(self):
         return self.tail - self.head
+
     def print(self):
         print(self.data)
         print("**************")
-        print(self.data[self.head:self.tail])
-        
+        print(self.data[self.head : self.tail])
+
+
 class my_node:
-    def __init__(self,data):
+    def __init__(self, data):
         self.data = data
         self.left = None
         self.right = None
         self.height = 1
+
     def getdata(self):
         return self.data
+
     def getleft(self):
         return self.left
+
     def getright(self):
         return self.right
+
     def getheight(self):
         return self.height
-    def setdata(self,data):
+
+    def setdata(self, data):
         self.data = data
         return
-    def setleft(self,node):
+
+    def setleft(self, node):
         self.left = node
         return
-    def setright(self,node):
+
+    def setright(self, node):
         self.right = node
         return
-    def setheight(self,height):
+
+    def setheight(self, height):
         self.height = height
         return
 
+
 def getheight(node):
     if node is None:
         return 0
     return node.getheight()
 
-def my_max(a,b):
+
+def my_max(a, b):
     if a > b:
         return a
     return b
 
 
-
 def leftrotation(node):
-    r'''
+    r"""
             A                      B
            / \                    / \
           B   C                  Bl  A
@@ -75,33 +92,35 @@ def leftrotation(node):
      UB
   
     UB = unbalanced node  
-    '''
-    print("left rotation node:",node.getdata())
+    """
+    print("left rotation node:", node.getdata())
     ret = node.getleft()
     node.setleft(ret.getright())
     ret.setright(node)
-    h1 = my_max(getheight(node.getright()),getheight(node.getleft())) + 1
+    h1 = my_max(getheight(node.getright()), getheight(node.getleft())) + 1
     node.setheight(h1)
-    h2 = my_max(getheight(ret.getright()),getheight(ret.getleft())) + 1         
+    h2 = my_max(getheight(ret.getright()), getheight(ret.getleft())) + 1
     ret.setheight(h2)
     return ret
 
+
 def rightrotation(node):
-    '''
+    """
         a mirror symmetry rotation of the leftrotation
-    '''
-    print("right rotation node:",node.getdata())
+    """
+    print("right rotation node:", node.getdata())
     ret = node.getright()
     node.setright(ret.getleft())
     ret.setleft(node)
-    h1 = my_max(getheight(node.getright()),getheight(node.getleft())) + 1
+    h1 = my_max(getheight(node.getright()), getheight(node.getleft())) + 1
     node.setheight(h1)
-    h2 = my_max(getheight(ret.getright()),getheight(ret.getleft())) + 1         
+    h2 = my_max(getheight(ret.getright()), getheight(ret.getleft())) + 1
     ret.setheight(h2)
     return ret
 
+
 def rlrotation(node):
-    r'''
+    r"""
             A              A                    Br      
            / \            / \                  /  \
           B   C    RR    Br  C       LR       B    A
@@ -110,51 +129,60 @@ def rlrotation(node):
              \        /
              UB     Bl
     RR = rightrotation   LR = leftrotation
-    '''
+    """
     node.setleft(rightrotation(node.getleft()))
     return leftrotation(node)
 
+
 def lrrotation(node):
     node.setright(leftrotation(node.getright()))
     return rightrotation(node)
 
 
-def insert_node(node,data):
+def insert_node(node, data):
     if node is None:
         return my_node(data)
     if data < node.getdata():
-        node.setleft(insert_node(node.getleft(),data))
-        if getheight(node.getleft()) - getheight(node.getright()) == 2: #an unbalance detected
-            if data < node.getleft().getdata():       #new node is the left child of the left child
+        node.setleft(insert_node(node.getleft(), data))
+        if (
+            getheight(node.getleft()) - getheight(node.getright()) == 2
+        ):  # an unbalance detected
+            if (
+                data < node.getleft().getdata()
+            ):  # new node is the left child of the left child
                 node = leftrotation(node)
             else:
-                node = rlrotation(node)             #new node is the right child of the left child
+                node = rlrotation(node)  # new node is the right child of the left child
     else:
-        node.setright(insert_node(node.getright(),data))
+        node.setright(insert_node(node.getright(), data))
         if getheight(node.getright()) - getheight(node.getleft()) == 2:
             if data < node.getright().getdata():
                 node = lrrotation(node)
             else:
                 node = rightrotation(node)
-    h1 = my_max(getheight(node.getright()),getheight(node.getleft())) + 1
+    h1 = my_max(getheight(node.getright()), getheight(node.getleft())) + 1
     node.setheight(h1)
     return node
 
+
 def getRightMost(root):
     while root.getright() is not None:
         root = root.getright()
     return root.getdata()
+
+
 def getLeftMost(root):
     while root.getleft() is not None:
         root = root.getleft()
     return root.getdata()
 
-def del_node(root,data):
+
+def del_node(root, data):
     if root.getdata() == data:
         if root.getleft() is not None and root.getright() is not None:
             temp_data = getLeftMost(root.getright())
             root.setdata(temp_data)
-            root.setright(del_node(root.getright(),temp_data))
+            root.setright(del_node(root.getright(), temp_data))
         elif root.getleft() is not None:
             root = root.getleft()
         else:
@@ -164,12 +192,12 @@ def del_node(root,data):
             print("No such data")
             return root
         else:
-            root.setleft(del_node(root.getleft(),data))
+            root.setleft(del_node(root.getleft(), data))
     elif root.getdata() < data:
         if root.getright() is None:
             return root
         else:
-            root.setright(del_node(root.getright(),data))
+            root.setright(del_node(root.getright(), data))
     if root is None:
         return root
     if getheight(root.getright()) - getheight(root.getleft()) == 2:
@@ -182,27 +210,31 @@ def del_node(root,data):
             root = leftrotation(root)
         else:
             root = rlrotation(root)
-    height = my_max(getheight(root.getright()),getheight(root.getleft())) + 1
+    height = my_max(getheight(root.getright()), getheight(root.getleft())) + 1
     root.setheight(height)
     return root
 
+
 class AVLtree:
     def __init__(self):
         self.root = None
+
     def getheight(self):
-#        print("yyy")
+        #        print("yyy")
         return getheight(self.root)
-    def insert(self,data):
-        print("insert:"+str(data))
-        self.root = insert_node(self.root,data)
-        
-    def del_node(self,data):
-        print("delete:"+str(data))
+
+    def insert(self, data):
+        print("insert:" + str(data))
+        self.root = insert_node(self.root, data)
+
+    def del_node(self, data):
+        print("delete:" + str(data))
         if self.root is None:
             print("Tree is empty!")
             return
-        self.root = del_node(self.root,data)
-    def traversale(self): #a level traversale, gives a more intuitive look on the tree
+        self.root = del_node(self.root, data)
+
+    def traversale(self):  # a level traversale, gives a more intuitive look on the tree
         q = my_queue()
         q.push(self.root)
         layer = self.getheight()
@@ -211,21 +243,21 @@ def traversale(self): #a level traversale, gives a more intuitive look on the tr
         cnt = 0
         while not q.isEmpty():
             node = q.pop()
-            space = " "*int(math.pow(2,layer-1))
-            print(space,end = "")
+            space = " " * int(math.pow(2, layer - 1))
+            print(space, end="")
             if node is None:
-                print("*",end = "")
+                print("*", end="")
                 q.push(None)
                 q.push(None)
             else:
-                print(node.getdata(),end = "")
+                print(node.getdata(), end="")
                 q.push(node.getleft())
                 q.push(node.getright())
-            print(space,end = "")
+            print(space, end="")
             cnt = cnt + 1
             for i in range(100):
-                if cnt == math.pow(2,i) - 1:
-                    layer = layer -1 
+                if cnt == math.pow(2, i) - 1:
+                    layer = layer - 1
                     if layer == 0:
                         print()
                         print("*************************************")
@@ -235,11 +267,13 @@ def traversale(self): #a level traversale, gives a more intuitive look on the tr
         print()
         print("*************************************")
         return
-    
+
     def test(self):
         getheight(None)
         print("****")
         self.getheight()
+
+
 if __name__ == "__main__":
     t = AVLtree()
     t.traversale()
@@ -248,7 +282,7 @@ def test(self):
     for i in l:
         t.insert(i)
         t.traversale()
-        
+
     random.shuffle(l)
     for i in l:
         t.del_node(i)
diff --git a/data_structures/binary_tree/basic_binary_tree.py b/data_structures/binary_tree/basic_binary_tree.py
index 7c6240fb4dd4..6b7de7803704 100644
--- a/data_structures/binary_tree/basic_binary_tree.py
+++ b/data_structures/binary_tree/basic_binary_tree.py
@@ -1,12 +1,13 @@
-class Node: # This is the Class Node with constructor that contains data variable to type data and left,right pointers.
+class Node:  # This is the Class Node with constructor that contains data variable to type data and left,right pointers.
     def __init__(self, data):
         self.data = data
         self.left = None
         self.right = None
 
-def display(tree): #In Order traversal of the tree
 
-    if tree is None: 
+def display(tree):  # In Order traversal of the tree
+
+    if tree is None:
         return
 
     if tree.left is not None:
@@ -19,7 +20,10 @@ def display(tree): #In Order traversal of the tree
 
     return
 
-def depth_of_tree(tree): #This is the recursive function to find the depth of binary tree.
+
+def depth_of_tree(
+    tree
+):  # This is the recursive function to find the depth of binary tree.
     if tree is None:
         return 0
     else:
@@ -31,18 +35,20 @@ def depth_of_tree(tree): #This is the recursive function to find the depth of bi
             return 1 + depth_r_tree
 
 
-def is_full_binary_tree(tree): # This functions returns that is it full binary tree or not?
+def is_full_binary_tree(
+    tree
+):  # This functions returns that is it full binary tree or not?
     if tree is None:
         return True
     if (tree.left is None) and (tree.right is None):
         return True
     if (tree.left is not None) and (tree.right is not None):
-        return (is_full_binary_tree(tree.left) and is_full_binary_tree(tree.right))
+        return is_full_binary_tree(tree.left) and is_full_binary_tree(tree.right)
     else:
         return False
 
 
-def main(): # Main func for testing.
+def main():  # Main func for testing.
     tree = Node(1)
     tree.left = Node(2)
     tree.right = Node(3)
@@ -59,5 +65,5 @@ def main(): # Main func for testing.
     display(tree)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
diff --git a/data_structures/binary_tree/binary_search_tree.py b/data_structures/binary_tree/binary_search_tree.py
index 634b6cbcc231..c6e037880bb6 100644
--- a/data_structures/binary_tree/binary_search_tree.py
+++ b/data_structures/binary_tree/binary_search_tree.py
@@ -1,13 +1,14 @@
-'''
+"""
 A binary search Tree
-'''
-class Node:
+"""
+
 
+class Node:
     def __init__(self, label, parent):
         self.label = label
         self.left = None
         self.right = None
-        #Added in order to delete a node easier
+        # Added in order to delete a node easier
         self.parent = parent
 
     def getLabel(self):
@@ -34,8 +35,8 @@ def getParent(self):
     def setParent(self, parent):
         self.parent = parent
 
-class BinarySearchTree:
 
+class BinarySearchTree:
     def __init__(self):
         self.root = None
 
@@ -46,90 +47,90 @@ def insert(self, label):
         if self.empty():
             self.root = new_node
         else:
-            #If Tree is not empty
+            # If Tree is not empty
             curr_node = self.root
-            #While we don't get to a leaf
+            # While we don't get to a leaf
             while curr_node is not None:
-                #We keep reference of the parent node
+                # We keep reference of the parent node
                 parent_node = curr_node
-                #If node label is less than current node
+                # If node label is less than current node
                 if new_node.getLabel() < curr_node.getLabel():
-                #We go left
+                    # We go left
                     curr_node = curr_node.getLeft()
                 else:
-                    #Else we go right
+                    # Else we go right
                     curr_node = curr_node.getRight()
-            #We insert the new node in a leaf
+            # We insert the new node in a leaf
             if new_node.getLabel() < parent_node.getLabel():
                 parent_node.setLeft(new_node)
             else:
                 parent_node.setRight(new_node)
-            #Set parent to the new node
+            # Set parent to the new node
             new_node.setParent(parent_node)
 
     def delete(self, label):
-        if (not self.empty()):
-            #Look for the node with that label
+        if not self.empty():
+            # Look for the node with that label
             node = self.getNode(label)
-            #If the node exists
-            if(node is not None):
-                #If it has no children
-                if(node.getLeft() is None and node.getRight() is None):
+            # If the node exists
+            if node is not None:
+                # If it has no children
+                if node.getLeft() is None and node.getRight() is None:
                     self.__reassignNodes(node, None)
                     node = None
-                #Has only right children
-                elif(node.getLeft() is None and node.getRight() is not None):
+                # Has only right children
+                elif node.getLeft() is None and node.getRight() is not None:
                     self.__reassignNodes(node, node.getRight())
-                #Has only left children
-                elif(node.getLeft() is not None and node.getRight() is None):
+                # Has only left children
+                elif node.getLeft() is not None and node.getRight() is None:
                     self.__reassignNodes(node, node.getLeft())
-                #Has two children
+                # Has two children
                 else:
-                    #Gets the max value of the left branch
+                    # Gets the max value of the left branch
                     tmpNode = self.getMax(node.getLeft())
-                    #Deletes the tmpNode
+                    # Deletes the tmpNode
                     self.delete(tmpNode.getLabel())
-                    #Assigns the value to the node to delete and keesp tree structure
+                    # Assigns the value to the node to delete and keesp tree structure
                     node.setLabel(tmpNode.getLabel())
 
     def getNode(self, label):
         curr_node = None
-        #If the tree is not empty
-        if(not self.empty()):
-            #Get tree root
+        # If the tree is not empty
+        if not self.empty():
+            # Get tree root
             curr_node = self.getRoot()
-            #While we don't find the node we look for
-            #I am using lazy evaluation here to avoid NoneType Attribute error
+            # While we don't find the node we look for
+            # I am using lazy evaluation here to avoid NoneType Attribute error
             while curr_node is not None and curr_node.getLabel() is not label:
-                #If node label is less than current node
+                # If node label is less than current node
                 if label < curr_node.getLabel():
-                    #We go left
+                    # We go left
                     curr_node = curr_node.getLeft()
                 else:
-                    #Else we go right
+                    # Else we go right
                     curr_node = curr_node.getRight()
         return curr_node
 
-    def getMax(self, root = None):
-        if(root is not None):
+    def getMax(self, root=None):
+        if root is not None:
             curr_node = root
         else:
-            #We go deep on the right branch
+            # We go deep on the right branch
             curr_node = self.getRoot()
-        if(not self.empty()):
-            while(curr_node.getRight() is not None):
+        if not self.empty():
+            while curr_node.getRight() is not None:
                 curr_node = curr_node.getRight()
         return curr_node
 
-    def getMin(self, root = None):
-        if(root is not None):
+    def getMin(self, root=None):
+        if root is not None:
             curr_node = root
         else:
-            #We go deep on the left branch
+            # We go deep on the left branch
             curr_node = self.getRoot()
-        if(not self.empty()):
+        if not self.empty():
             curr_node = self.getRoot()
-            while(curr_node.getLeft() is not None):
+            while curr_node.getLeft() is not None:
                 curr_node = curr_node.getLeft()
         return curr_node
 
@@ -150,34 +151,34 @@ def getRoot(self):
         return self.root
 
     def __isRightChildren(self, node):
-        if(node == node.getParent().getRight()):
+        if node == node.getParent().getRight():
             return True
         return False
 
     def __reassignNodes(self, node, newChildren):
-        if(newChildren is not None):
+        if newChildren is not None:
             newChildren.setParent(node.getParent())
-        if(node.getParent() is not None):
-            #If it is the Right Children
-            if(self.__isRightChildren(node)):
+        if node.getParent() is not None:
+            # If it is the Right Children
+            if self.__isRightChildren(node):
                 node.getParent().setRight(newChildren)
             else:
-                #Else it is the left children
+                # Else it is the left children
                 node.getParent().setLeft(newChildren)
 
-    #This function traversal the tree. By default it returns an
-    #In order traversal list. You can pass a function to traversal
-    #The tree as needed by client code
-    def traversalTree(self, traversalFunction = None, root = None):
-        if(traversalFunction is None):
-            #Returns a list of nodes in preOrder by default
+    # This function traversal the tree. By default it returns an
+    # In order traversal list. You can pass a function to traversal
+    # The tree as needed by client code
+    def traversalTree(self, traversalFunction=None, root=None):
+        if traversalFunction is None:
+            # Returns a list of nodes in preOrder by default
             return self.__InOrderTraversal(self.root)
         else:
-            #Returns a list of nodes in the order that the users wants to
+            # Returns a list of nodes in the order that the users wants to
             return traversalFunction(self.root)
 
-    #Returns an string of all the nodes labels in the list
-    #In Order Traversal
+    # Returns an string of all the nodes labels in the list
+    # In Order Traversal
     def __str__(self):
         list = self.__InOrderTraversal(self.root)
         str = ""
@@ -185,6 +186,7 @@ def __str__(self):
             str = str + " " + x.getLabel().__str__()
         return str
 
+
 def InPreOrder(curr_node):
     nodeList = []
     if curr_node is not None:
@@ -193,8 +195,9 @@ def InPreOrder(curr_node):
         nodeList = nodeList + InPreOrder(curr_node.getRight())
     return nodeList
 
+
 def testBinarySearchTree():
-    r'''
+    r"""
     Example
                   8
                  / \
@@ -203,15 +206,15 @@ def testBinarySearchTree():
               1   6    14
                  / \   /
                 4   7 13
-    '''
+    """
 
-    r'''
+    r"""
     Example After Deletion
                   7
                  / \
                 1   4
 
-    '''
+    """
     t = BinarySearchTree()
     t.insert(8)
     t.insert(3)
@@ -223,20 +226,20 @@ def testBinarySearchTree():
     t.insert(4)
     t.insert(7)
 
-    #Prints all the elements of the list in order traversal
+    # Prints all the elements of the list in order traversal
     print(t.__str__())
 
-    if(t.getNode(6) is not None):
+    if t.getNode(6) is not None:
         print("The label 6 exists")
     else:
         print("The label 6 doesn't exist")
 
-    if(t.getNode(-1) is not None):
+    if t.getNode(-1) is not None:
         print("The label -1 exists")
     else:
         print("The label -1 doesn't exist")
 
-    if(not t.empty()):
+    if not t.empty():
         print(("Max Value: ", t.getMax().getLabel()))
         print(("Min Value: ", t.getMin().getLabel()))
 
@@ -247,11 +250,12 @@ def testBinarySearchTree():
     t.delete(6)
     t.delete(14)
 
-    #Gets all the elements of the tree In pre order
-    #And it prints them
+    # Gets all the elements of the tree In pre order
+    # And it prints them
     list = t.traversalTree(InPreOrder, t.root)
     for x in list:
         print(x)
 
+
 if __name__ == "__main__":
     testBinarySearchTree()
diff --git a/data_structures/binary_tree/fenwick_tree.py b/data_structures/binary_tree/fenwick_tree.py
index 30a87fbd7fcf..54f0f07ac68d 100644
--- a/data_structures/binary_tree/fenwick_tree.py
+++ b/data_structures/binary_tree/fenwick_tree.py
@@ -1,28 +1,28 @@
 class FenwickTree:
-
-    def __init__(self, SIZE): # create fenwick tree with size SIZE
+    def __init__(self, SIZE):  # create fenwick tree with size SIZE
         self.Size = SIZE
-        self.ft = [0 for i in range (0,SIZE)]
+        self.ft = [0 for i in range(0, SIZE)]
 
-    def update(self, i, val): # update data (adding) in index i in O(lg N)
-        while (i < self.Size):
+    def update(self, i, val):  # update data (adding) in index i in O(lg N)
+        while i < self.Size:
             self.ft[i] += val
             i += i & (-i)
 
-    def query(self, i): # query cumulative data from index 0 to i in O(lg N)
+    def query(self, i):  # query cumulative data from index 0 to i in O(lg N)
         ret = 0
-        while (i > 0):
+        while i > 0:
             ret += self.ft[i]
             i -= i & (-i)
         return ret
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
     f = FenwickTree(100)
-    f.update(1,20)
-    f.update(4,4)
+    f.update(1, 20)
+    f.update(4, 4)
     print(f.query(1))
     print(f.query(3))
     print(f.query(4))
-    f.update(2,-5)
+    f.update(2, -5)
     print(f.query(1))
     print(f.query(3))
diff --git a/data_structures/binary_tree/lazy_segment_tree.py b/data_structures/binary_tree/lazy_segment_tree.py
index bbe37a6eb97f..acd551b41b96 100644
--- a/data_structures/binary_tree/lazy_segment_tree.py
+++ b/data_structures/binary_tree/lazy_segment_tree.py
@@ -1,34 +1,38 @@
 import math
 
-class SegmentTree:
 
+class SegmentTree:
     def __init__(self, N):
         self.N = N
-        self.st = [0 for i in range(0,4*N)] # approximate the overall size of segment tree with array N
-        self.lazy = [0 for i in range(0,4*N)] # create array to store lazy update
-        self.flag = [0 for i in range(0,4*N)] # flag for lazy update
+        self.st = [
+            0 for i in range(0, 4 * N)
+        ]  # approximate the overall size of segment tree with array N
+        self.lazy = [0 for i in range(0, 4 * N)]  # create array to store lazy update
+        self.flag = [0 for i in range(0, 4 * N)]  # flag for lazy update
 
     def left(self, idx):
-        return idx*2
+        return idx * 2
 
     def right(self, idx):
-        return idx*2 + 1
+        return idx * 2 + 1
 
     def build(self, idx, l, r, A):
-        if l==r:
-            self.st[idx] = A[l-1]
-        else :
-            mid = (l+r)//2
-            self.build(self.left(idx),l,mid, A)
-            self.build(self.right(idx),mid+1,r, A)
-            self.st[idx] = max(self.st[self.left(idx)] , self.st[self.right(idx)])
+        if l == r:
+            self.st[idx] = A[l - 1]
+        else:
+            mid = (l + r) // 2
+            self.build(self.left(idx), l, mid, A)
+            self.build(self.right(idx), mid + 1, r, A)
+            self.st[idx] = max(self.st[self.left(idx)], self.st[self.right(idx)])
 
     # update with O(lg N) (Normal segment tree without lazy update will take O(Nlg N) for each update)
-    def update(self, idx, l, r, a, b, val): # update(1, 1, N, a, b, v) for update val v to [a,b]
+    def update(
+        self, idx, l, r, a, b, val
+    ):  # update(1, 1, N, a, b, v) for update val v to [a,b]
         if self.flag[idx] == True:
             self.st[idx] = self.lazy[idx]
             self.flag[idx] = False
-            if l!=r:
+            if l != r:
                 self.lazy[self.left(idx)] = self.lazy[idx]
                 self.lazy[self.right(idx)] = self.lazy[idx]
                 self.flag[self.left(idx)] = True
@@ -36,22 +40,22 @@ def update(self, idx, l, r, a, b, val): # update(1, 1, N, a, b, v) for update va
 
         if r < a or l > b:
             return True
-        if l >= a and r <= b :
+        if l >= a and r <= b:
             self.st[idx] = val
-            if l!=r:
+            if l != r:
                 self.lazy[self.left(idx)] = val
                 self.lazy[self.right(idx)] = val
                 self.flag[self.left(idx)] = True
                 self.flag[self.right(idx)] = True
             return True
-        mid = (l+r)//2
-        self.update(self.left(idx),l,mid,a,b,val)
-        self.update(self.right(idx),mid+1,r,a,b,val)
-        self.st[idx] = max(self.st[self.left(idx)] , self.st[self.right(idx)])
+        mid = (l + r) // 2
+        self.update(self.left(idx), l, mid, a, b, val)
+        self.update(self.right(idx), mid + 1, r, a, b, val)
+        self.st[idx] = max(self.st[self.left(idx)], self.st[self.right(idx)])
         return True
 
     # query with O(lg N)
-    def query(self, idx, l, r, a, b): #query(1, 1, N, a, b) for query max of [a,b]
+    def query(self, idx, l, r, a, b):  # query(1, 1, N, a, b) for query max of [a,b]
         if self.flag[idx] == True:
             self.st[idx] = self.lazy[idx]
             self.flag[idx] = False
@@ -64,27 +68,27 @@ def query(self, idx, l, r, a, b): #query(1, 1, N, a, b) for query max of [a,b]
             return -math.inf
         if l >= a and r <= b:
             return self.st[idx]
-        mid = (l+r)//2
-        q1 = self.query(self.left(idx),l,mid,a,b)
-        q2 = self.query(self.right(idx),mid+1,r,a,b)
-        return max(q1,q2)
+        mid = (l + r) // 2
+        q1 = self.query(self.left(idx), l, mid, a, b)
+        q2 = self.query(self.right(idx), mid + 1, r, a, b)
+        return max(q1, q2)
 
     def showData(self):
         showList = []
-        for i in range(1,N+1):
+        for i in range(1, N + 1):
             showList += [self.query(1, 1, self.N, i, i)]
         print(showList)
 
 
-if __name__ == '__main__':
-    A = [1,2,-4,7,3,-5,6,11,-20,9,14,15,5,2,-8]
+if __name__ == "__main__":
+    A = [1, 2, -4, 7, 3, -5, 6, 11, -20, 9, 14, 15, 5, 2, -8]
     N = 15
     segt = SegmentTree(N)
-    segt.build(1,1,N,A)
-    print(segt.query(1,1,N,4,6))
-    print(segt.query(1,1,N,7,11))
-    print(segt.query(1,1,N,7,12))
-    segt.update(1,1,N,1,3,111)
-    print(segt.query(1,1,N,1,15))
-    segt.update(1,1,N,7,8,235)
+    segt.build(1, 1, N, A)
+    print(segt.query(1, 1, N, 4, 6))
+    print(segt.query(1, 1, N, 7, 11))
+    print(segt.query(1, 1, N, 7, 12))
+    segt.update(1, 1, N, 1, 3, 111)
+    print(segt.query(1, 1, N, 1, 15))
+    segt.update(1, 1, N, 7, 8, 235)
     segt.showData()
diff --git a/data_structures/binary_tree/lca.py b/data_structures/binary_tree/lca.py
index 9c9d8ca629c7..c18f1e944bab 100644
--- a/data_structures/binary_tree/lca.py
+++ b/data_structures/binary_tree/lca.py
@@ -75,7 +75,7 @@ def main():
         10: [],
         11: [],
         12: [],
-        13: []
+        13: [],
     }
     level, parent = bfs(level, parent, max_node, graph, 1)
     parent = creatSparse(max_node, parent)
diff --git a/data_structures/binary_tree/red_black_tree.py b/data_structures/binary_tree/red_black_tree.py
index 526f5ec27987..908f13cd581e 100644
--- a/data_structures/binary_tree/red_black_tree.py
+++ b/data_structures/binary_tree/red_black_tree.py
@@ -700,7 +700,6 @@ def main():
 
     print_results("Tree traversal", test_tree_chaining())
 
-
     print("Testing tree balancing...")
     print("This should only be a few seconds.")
     test_insertion_speed()
diff --git a/data_structures/binary_tree/segment_tree.py b/data_structures/binary_tree/segment_tree.py
index da3d15f26b6a..ad9476b4514b 100644
--- a/data_structures/binary_tree/segment_tree.py
+++ b/data_structures/binary_tree/segment_tree.py
@@ -1,10 +1,12 @@
 import math
 
-class SegmentTree:
 
+class SegmentTree:
     def __init__(self, A):
         self.N = len(A)
-        self.st = [0] * (4 * self.N) # approximate the overall size of segment tree with array N
+        self.st = [0] * (
+            4 * self.N
+        )  # approximate the overall size of segment tree with array N
         self.build(1, 0, self.N - 1)
 
     def left(self, idx):
@@ -20,51 +22,55 @@ def build(self, idx, l, r):
             mid = (l + r) // 2
             self.build(self.left(idx), l, mid)
             self.build(self.right(idx), mid + 1, r)
-            self.st[idx] = max(self.st[self.left(idx)] , self.st[self.right(idx)])
+            self.st[idx] = max(self.st[self.left(idx)], self.st[self.right(idx)])
 
     def update(self, a, b, val):
         return self.update_recursive(1, 0, self.N - 1, a - 1, b - 1, val)
 
-    def update_recursive(self, idx, l, r, a, b, val): # update(1, 1, N, a, b, v) for update val v to [a,b]
+    def update_recursive(
+        self, idx, l, r, a, b, val
+    ):  # update(1, 1, N, a, b, v) for update val v to [a,b]
         if r < a or l > b:
             return True
-        if l == r :
+        if l == r:
             self.st[idx] = val
             return True
-        mid = (l+r)//2
+        mid = (l + r) // 2
         self.update_recursive(self.left(idx), l, mid, a, b, val)
-        self.update_recursive(self.right(idx), mid+1, r, a, b, val)
-        self.st[idx] = max(self.st[self.left(idx)] , self.st[self.right(idx)])
+        self.update_recursive(self.right(idx), mid + 1, r, a, b, val)
+        self.st[idx] = max(self.st[self.left(idx)], self.st[self.right(idx)])
         return True
 
     def query(self, a, b):
         return self.query_recursive(1, 0, self.N - 1, a - 1, b - 1)
 
-    def query_recursive(self, idx, l, r, a, b): #query(1, 1, N, a, b) for query max of [a,b]
+    def query_recursive(
+        self, idx, l, r, a, b
+    ):  # query(1, 1, N, a, b) for query max of [a,b]
         if r < a or l > b:
             return -math.inf
         if l >= a and r <= b:
             return self.st[idx]
-        mid = (l+r)//2
+        mid = (l + r) // 2
         q1 = self.query_recursive(self.left(idx), l, mid, a, b)
         q2 = self.query_recursive(self.right(idx), mid + 1, r, a, b)
         return max(q1, q2)
 
     def showData(self):
         showList = []
-        for i in range(1,N+1):
+        for i in range(1, N + 1):
             showList += [self.query(i, i)]
         print(showList)
 
 
-if __name__ == '__main__':
-    A = [1,2,-4,7,3,-5,6,11,-20,9,14,15,5,2,-8]
+if __name__ == "__main__":
+    A = [1, 2, -4, 7, 3, -5, 6, 11, -20, 9, 14, 15, 5, 2, -8]
     N = 15
     segt = SegmentTree(A)
     print(segt.query(4, 6))
     print(segt.query(7, 11))
     print(segt.query(7, 12))
-    segt.update(1,3,111)
+    segt.update(1, 3, 111)
     print(segt.query(1, 15))
-    segt.update(7,8,235)
+    segt.update(7, 8, 235)
     segt.showData()
diff --git a/data_structures/binary_tree/treap.py b/data_structures/binary_tree/treap.py
index 0399ff67030a..5d34abc3c931 100644
--- a/data_structures/binary_tree/treap.py
+++ b/data_structures/binary_tree/treap.py
@@ -7,6 +7,7 @@ class Node:
     Treap's node
     Treap is a binary tree by key and heap by priority
     """
+
     def __init__(self, key: int):
         self.key = key
         self.prior = random()
diff --git a/data_structures/hashing/double_hash.py b/data_structures/hashing/double_hash.py
index 7a0ce0b3a67b..6c3699cc9950 100644
--- a/data_structures/hashing/double_hash.py
+++ b/data_structures/hashing/double_hash.py
@@ -8,13 +8,17 @@ class DoubleHash(HashTable):
     """
         Hash Table example with open addressing and Double Hash
     """
+
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
 
     def __hash_function_2(self, value, data):
 
-        next_prime_gt = next_prime(value % self.size_table) \
-            if not check_prime(value % self.size_table) else value % self.size_table  #gt = bigger than
+        next_prime_gt = (
+            next_prime(value % self.size_table)
+            if not check_prime(value % self.size_table)
+            else value % self.size_table
+        )  # gt = bigger than
         return next_prime_gt - (data % next_prime_gt)
 
     def __hash_double_function(self, key, data, increment):
@@ -25,9 +29,14 @@ def _colision_resolution(self, key, data=None):
         new_key = self.hash_function(data)
 
         while self.values[new_key] is not None and self.values[new_key] != key:
-            new_key = self.__hash_double_function(key, data, i) if \
-                self.balanced_factor() >= self.lim_charge else None
-            if new_key is None: break 
-            else: i += 1
+            new_key = (
+                self.__hash_double_function(key, data, i)
+                if self.balanced_factor() >= self.lim_charge
+                else None
+            )
+            if new_key is None:
+                break
+            else:
+                i += 1
 
         return new_key
diff --git a/data_structures/hashing/hash_table.py b/data_structures/hashing/hash_table.py
index f0de128d1ad1..ab473dc52324 100644
--- a/data_structures/hashing/hash_table.py
+++ b/data_structures/hashing/hash_table.py
@@ -19,8 +19,9 @@ def keys(self):
         return self._keys
 
     def balanced_factor(self):
-        return sum([1 for slot in self.values
-                    if slot is not None]) / (self.size_table * self.charge_factor)
+        return sum([1 for slot in self.values if slot is not None]) / (
+            self.size_table * self.charge_factor
+        )
 
     def hash_function(self, key):
         return key % self.size_table
@@ -46,8 +47,7 @@ def _set_value(self, key, data):
     def _colision_resolution(self, key, data=None):
         new_key = self.hash_function(key + 1)
 
-        while self.values[new_key] is not None \
-                and self.values[new_key] != key:
+        while self.values[new_key] is not None and self.values[new_key] != key:
 
             if self.values.count(None) > 0:
                 new_key = self.hash_function(new_key + 1)
@@ -61,7 +61,7 @@ def rehashing(self):
         survivor_values = [value for value in self.values if value is not None]
         self.size_table = next_prime(self.size_table, factor=2)
         self._keys.clear()
-        self.values = [None] * self.size_table #hell's pointers D: don't DRY ;/
+        self.values = [None] * self.size_table  # hell's pointers D: don't DRY ;/
         map(self.insert_data, survivor_values)
 
     def insert_data(self, data):
@@ -80,5 +80,3 @@ def insert_data(self, data):
             else:
                 self.rehashing()
                 self.insert_data(data)
-
-
diff --git a/data_structures/hashing/hash_table_with_linked_list.py b/data_structures/hashing/hash_table_with_linked_list.py
index a45876df49bd..236985b69ac6 100644
--- a/data_structures/hashing/hash_table_with_linked_list.py
+++ b/data_structures/hashing/hash_table_with_linked_list.py
@@ -7,18 +7,20 @@ def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
 
     def _set_value(self, key, data):
-        self.values[key] = deque([]) if self.values[key] is None else self.values[key]  
+        self.values[key] = deque([]) if self.values[key] is None else self.values[key]
         self.values[key].appendleft(data)
         self._keys[key] = self.values[key]
 
     def balanced_factor(self):
-        return sum([self.charge_factor - len(slot) for slot in self.values])\
-               / self.size_table * self.charge_factor
-    
+        return (
+            sum([self.charge_factor - len(slot) for slot in self.values])
+            / self.size_table
+            * self.charge_factor
+        )
+
     def _colision_resolution(self, key, data=None):
-        if not (len(self.values[key]) == self.charge_factor
-                and self.values.count(None) == 0):
+        if not (
+            len(self.values[key]) == self.charge_factor and self.values.count(None) == 0
+        ):
             return key
         return super()._colision_resolution(key, data)
-
-
diff --git a/data_structures/hashing/number_theory/prime_numbers.py b/data_structures/hashing/number_theory/prime_numbers.py
index 8a521bc45758..2a966e0da7f2 100644
--- a/data_structures/hashing/number_theory/prime_numbers.py
+++ b/data_structures/hashing/number_theory/prime_numbers.py
@@ -5,25 +5,25 @@
 
 
 def check_prime(number):
-        """
+    """
             it's not the best solution
         """
-        special_non_primes = [0,1,2]
-        if number in special_non_primes[:2]:
-            return 2
-        elif number == special_non_primes[-1]:
-            return 3
-            
-        return all([number % i for i in range(2, number)])
+    special_non_primes = [0, 1, 2]
+    if number in special_non_primes[:2]:
+        return 2
+    elif number == special_non_primes[-1]:
+        return 3
+
+    return all([number % i for i in range(2, number)])
 
 
 def next_prime(value, factor=1, **kwargs):
     value = factor * value
     first_value_val = value
-    
+
     while not check_prime(value):
         value += 1 if not ("desc" in kwargs.keys() and kwargs["desc"] is True) else -1
-    
+
     if value == first_value_val:
         return next_prime(value + 1, **kwargs)
     return value
diff --git a/data_structures/hashing/quadratic_probing.py b/data_structures/hashing/quadratic_probing.py
index 1e61100a81fa..ac966e1cd67e 100644
--- a/data_structures/hashing/quadratic_probing.py
+++ b/data_structures/hashing/quadratic_probing.py
@@ -7,18 +7,21 @@ class QuadraticProbing(HashTable):
     """
         Basic Hash Table example with open addressing using Quadratic Probing 
     """
+
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
 
     def _colision_resolution(self, key, data=None):
         i = 1
-        new_key = self.hash_function(key + i*i)
+        new_key = self.hash_function(key + i * i)
 
-        while self.values[new_key] is not None \
-                and self.values[new_key] != key:
+        while self.values[new_key] is not None and self.values[new_key] != key:
             i += 1
-            new_key = self.hash_function(key + i*i) if not \
-                self.balanced_factor() >= self.lim_charge else None
+            new_key = (
+                self.hash_function(key + i * i)
+                if not self.balanced_factor() >= self.lim_charge
+                else None
+            )
 
             if new_key is None:
                 break
diff --git a/data_structures/heap/binomial_heap.py b/data_structures/heap/binomial_heap.py
index 0154390d7707..e1a005487e34 100644
--- a/data_structures/heap/binomial_heap.py
+++ b/data_structures/heap/binomial_heap.py
@@ -26,9 +26,7 @@ def mergeTrees(self, other):
             In-place merge of two binomial trees of equal size. 
             Returns the root of the resulting tree
         """
-        assert (
-            self.left_tree_size == other.left_tree_size
-        ), "Unequal Sizes of Blocks"
+        assert self.left_tree_size == other.left_tree_size, "Unequal Sizes of Blocks"
 
         if self.val < other.val:
             other.left = self.right
@@ -36,9 +34,7 @@ def mergeTrees(self, other):
             if self.right:
                 self.right.parent = other
             self.right = other
-            self.left_tree_size = (
-                self.left_tree_size * 2 + 1
-            )
+            self.left_tree_size = self.left_tree_size * 2 + 1
             return self
         else:
             self.left = other.right
@@ -46,9 +42,7 @@ def mergeTrees(self, other):
             if other.right:
                 other.right.parent = self
             other.right = self
-            other.left_tree_size = (
-                other.left_tree_size * 2 + 1
-            )
+            other.left_tree_size = other.left_tree_size * 2 + 1
             return other
 
 
@@ -132,9 +126,7 @@ class BinomialHeap:
         
     """
 
-    def __init__(
-        self, bottom_root=None, min_node=None, heap_size=0
-    ):
+    def __init__(self, bottom_root=None, min_node=None, heap_size=0):
         self.size = heap_size
         self.bottom_root = bottom_root
         self.min_node = min_node
@@ -165,10 +157,7 @@ def mergeHeaps(self, other):
         combined_roots_list = []
         i, j = self.bottom_root, other.bottom_root
         while i or j:
-            if i and (
-                (not j)
-                or i.left_tree_size < j.left_tree_size
-            ):
+            if i and ((not j) or i.left_tree_size < j.left_tree_size):
                 combined_roots_list.append((i, True))
                 i = i.parent
             else:
@@ -176,29 +165,17 @@ def mergeHeaps(self, other):
                 j = j.parent
         # Insert links between them
         for i in range(len(combined_roots_list) - 1):
-            if (
-                combined_roots_list[i][1]
-                != combined_roots_list[i + 1][1]
-            ):
-                combined_roots_list[i][
-                    0
-                ].parent = combined_roots_list[i + 1][0]
-                combined_roots_list[i + 1][
-                    0
-                ].left = combined_roots_list[i][0]
+            if combined_roots_list[i][1] != combined_roots_list[i + 1][1]:
+                combined_roots_list[i][0].parent = combined_roots_list[i + 1][0]
+                combined_roots_list[i + 1][0].left = combined_roots_list[i][0]
         # Consecutively merge roots with same left_tree_size
         i = combined_roots_list[0][0]
         while i.parent:
             if (
-                (
-                    i.left_tree_size
-                    == i.parent.left_tree_size
-                )
-                and (not i.parent.parent)
+                (i.left_tree_size == i.parent.left_tree_size) and (not i.parent.parent)
             ) or (
                 i.left_tree_size == i.parent.left_tree_size
-                and i.left_tree_size
-                != i.parent.parent.left_tree_size
+                and i.left_tree_size != i.parent.parent.left_tree_size
             ):
 
                 # Neighbouring Nodes
@@ -264,9 +241,7 @@ def insert(self, val):
                 next_node = self.bottom_root.parent.parent
 
                 # Merge
-                self.bottom_root = self.bottom_root.mergeTrees(
-                    self.bottom_root.parent
-                )
+                self.bottom_root = self.bottom_root.mergeTrees(self.bottom_root.parent)
 
                 # Update Links
                 self.bottom_root.parent = next_node
@@ -337,9 +312,7 @@ def deleteMin(self):
             if bottom_of_new.val < min_of_new.val:
                 min_of_new = bottom_of_new
         # Corner case of single root on top left path
-        if (not self.min_node.left) and (
-            not self.min_node.parent
-        ):
+        if (not self.min_node.left) and (not self.min_node.parent):
             self.size = size_of_new
             self.bottom_root = bottom_of_new
             self.min_node = min_of_new
@@ -348,9 +321,7 @@ def deleteMin(self):
         # Remaining cases
         # Construct heap of right subtree
         newHeap = BinomialHeap(
-            bottom_root=bottom_of_new,
-            min_node=min_of_new,
-            heap_size=size_of_new,
+            bottom_root=bottom_of_new, min_node=min_of_new, heap_size=size_of_new
         )
 
         # Update size
@@ -411,12 +382,8 @@ def __traversal(self, curr_node, preorder, level=0):
         """
         if curr_node:
             preorder.append((curr_node.val, level))
-            self.__traversal(
-                curr_node.left, preorder, level + 1
-            )
-            self.__traversal(
-                curr_node.right, preorder, level + 1
-            )
+            self.__traversal(curr_node.left, preorder, level + 1)
+            self.__traversal(curr_node.right, preorder, level + 1)
         else:
             preorder.append(("#", level))
 
@@ -429,10 +396,7 @@ def __str__(self):
             return ""
         preorder_heap = self.preOrder()
 
-        return "\n".join(
-            ("-" * level + str(value))
-            for value, level in preorder_heap
-        )
+        return "\n".join(("-" * level + str(value)) for value, level in preorder_heap)
 
 
 # Unit Tests
diff --git a/data_structures/heap/heap.py b/data_structures/heap/heap.py
index 2373d71bb897..b020ab067cc8 100644
--- a/data_structures/heap/heap.py
+++ b/data_structures/heap/heap.py
@@ -2,83 +2,85 @@
 
 # This heap class start from here.
 class Heap:
-	def __init__(self): # Default constructor of heap class.
-	    self.h = []
-	    self.currsize = 0
+    def __init__(self):  # Default constructor of heap class.
+        self.h = []
+        self.currsize = 0
 
-	def leftChild(self,i):
-		if 2*i+1 < self.currsize:
-			return 2*i+1
-		return None
+    def leftChild(self, i):
+        if 2 * i + 1 < self.currsize:
+            return 2 * i + 1
+        return None
 
-	def rightChild(self,i):
-		if 2*i+2 < self.currsize:
-			return 2*i+2
-		return None
+    def rightChild(self, i):
+        if 2 * i + 2 < self.currsize:
+            return 2 * i + 2
+        return None
 
-	def maxHeapify(self,node):
-		if node < self.currsize:
-			m = node
-			lc = self.leftChild(node)
-			rc = self.rightChild(node)
-			if lc is not None and self.h[lc] > self.h[m]:
-				m = lc
-			if rc is not None and self.h[rc] > self.h[m]:
-				m = rc
-			if m!=node:
-				temp = self.h[node]
-				self.h[node] = self.h[m]
-				self.h[m] = temp
-				self.maxHeapify(m)
+    def maxHeapify(self, node):
+        if node < self.currsize:
+            m = node
+            lc = self.leftChild(node)
+            rc = self.rightChild(node)
+            if lc is not None and self.h[lc] > self.h[m]:
+                m = lc
+            if rc is not None and self.h[rc] > self.h[m]:
+                m = rc
+            if m != node:
+                temp = self.h[node]
+                self.h[node] = self.h[m]
+                self.h[m] = temp
+                self.maxHeapify(m)
 
-	def buildHeap(self,a): #This function is used to build the heap from the data container 'a'.
-		self.currsize = len(a)
-		self.h = list(a)
-		for i in range(self.currsize//2,-1,-1):
-			self.maxHeapify(i)
+    def buildHeap(
+        self, a
+    ):  # This function is used to build the heap from the data container 'a'.
+        self.currsize = len(a)
+        self.h = list(a)
+        for i in range(self.currsize // 2, -1, -1):
+            self.maxHeapify(i)
 
-	def getMax(self): #This function is used to get maximum value from the heap.
-		if self.currsize >= 1:
-			me = self.h[0]
-			temp = self.h[0]
-			self.h[0] = self.h[self.currsize-1]
-			self.h[self.currsize-1] = temp
-			self.currsize -= 1
-			self.maxHeapify(0)
-			return me
-		return None
+    def getMax(self):  # This function is used to get maximum value from the heap.
+        if self.currsize >= 1:
+            me = self.h[0]
+            temp = self.h[0]
+            self.h[0] = self.h[self.currsize - 1]
+            self.h[self.currsize - 1] = temp
+            self.currsize -= 1
+            self.maxHeapify(0)
+            return me
+        return None
 
-	def heapSort(self): #This function is used to sort the heap.
-		size = self.currsize
-		while self.currsize-1 >= 0:
-			temp = self.h[0]
-			self.h[0] = self.h[self.currsize-1]
-			self.h[self.currsize-1] = temp
-			self.currsize -= 1
-			self.maxHeapify(0)
-		self.currsize = size
+    def heapSort(self):  # This function is used to sort the heap.
+        size = self.currsize
+        while self.currsize - 1 >= 0:
+            temp = self.h[0]
+            self.h[0] = self.h[self.currsize - 1]
+            self.h[self.currsize - 1] = temp
+            self.currsize -= 1
+            self.maxHeapify(0)
+        self.currsize = size
 
-	def insert(self,data): #This function is used to insert data in the heap.
-		self.h.append(data)
-		curr = self.currsize
-		self.currsize+=1
-		while self.h[curr] > self.h[curr/2]:
-			temp = self.h[curr/2]
-			self.h[curr/2] = self.h[curr]
-			self.h[curr] = temp
-			curr = curr/2
+    def insert(self, data):  # This function is used to insert data in the heap.
+        self.h.append(data)
+        curr = self.currsize
+        self.currsize += 1
+        while self.h[curr] > self.h[curr / 2]:
+            temp = self.h[curr / 2]
+            self.h[curr / 2] = self.h[curr]
+            self.h[curr] = temp
+            curr = curr / 2
 
-	def display(self): #This function is used to print the heap.
-		print(self.h)
+    def display(self):  # This function is used to print the heap.
+        print(self.h)
 
-def main():
-	l = list(map(int, input().split()))
-	h = Heap()
-	h.buildHeap(l)
-	h.heapSort()
-	h.display()
 
-if __name__=='__main__':
-	main()
+def main():
+    l = list(map(int, input().split()))
+    h = Heap()
+    h.buildHeap(l)
+    h.heapSort()
+    h.display()
 
 
+if __name__ == "__main__":
+    main()
diff --git a/data_structures/linked_list/__init__.py b/data_structures/linked_list/__init__.py
index 6d50f23c1f1a..a050adba42b2 100644
--- a/data_structures/linked_list/__init__.py
+++ b/data_structures/linked_list/__init__.py
@@ -3,6 +3,7 @@ def __init__(self, item, next):
         self.item = item
         self.next = next
 
+
 class LinkedList:
     def __init__(self):
         self.head = None
diff --git a/data_structures/linked_list/doubly_linked_list.py b/data_structures/linked_list/doubly_linked_list.py
index 23d91383fa0e..38fff867b416 100644
--- a/data_structures/linked_list/doubly_linked_list.py
+++ b/data_structures/linked_list/doubly_linked_list.py
@@ -1,76 +1,81 @@
-'''
+"""
 - A linked list is similar to an array, it holds values. However, links in a linked list do not have indexes.
 - This is an example of a double ended, doubly linked list.
 - Each link references the next link and the previous one.
 - A Doubly Linked List (DLL) contains an extra pointer, typically called previous pointer, together with next pointer and data which are there in singly linked list.
- - Advantages over SLL - IT can be traversed in both forward and backward direction.,Delete operation is more efficent'''
+ - Advantages over SLL - IT can be traversed in both forward and backward direction.,Delete operation is more efficent"""
 
 
-class LinkedList:           #making main class named linked list
+class LinkedList:  # making main class named linked list
     def __init__(self):
         self.head = None
         self.tail = None
 
     def insertHead(self, x):
-        newLink = Link(x)                            #Create a new link with a value attached to it
-        if(self.isEmpty() == True):                  #Set the first element added to be the tail
+        newLink = Link(x)  # Create a new link with a value attached to it
+        if self.isEmpty() == True:  # Set the first element added to be the tail
             self.tail = newLink
         else:
-            self.head.previous = newLink             # newLink <-- currenthead(head)
-        newLink.next = self.head                     # newLink <--> currenthead(head)
-        self.head = newLink                          # newLink(head) <--> oldhead
+            self.head.previous = newLink  # newLink <-- currenthead(head)
+        newLink.next = self.head  # newLink <--> currenthead(head)
+        self.head = newLink  # newLink(head) <--> oldhead
 
     def deleteHead(self):
         temp = self.head
-        self.head = self.head.next                   # oldHead <--> 2ndElement(head)
-        self.head.previous = None                    # oldHead --> 2ndElement(head) nothing pointing at it so the old head will be removed
-        if(self.head is None):
-            self.tail = None                         #if empty linked list
+        self.head = self.head.next  # oldHead <--> 2ndElement(head)
+        self.head.previous = (
+            None
+        )  # oldHead --> 2ndElement(head) nothing pointing at it so the old head will be removed
+        if self.head is None:
+            self.tail = None  # if empty linked list
         return temp
 
     def insertTail(self, x):
         newLink = Link(x)
-        newLink.next = None                         # currentTail(tail)    newLink -->
-        self.tail.next = newLink                    # currentTail(tail) --> newLink -->
-        newLink.previous = self.tail                #currentTail(tail) <--> newLink -->
-        self.tail = newLink                         # oldTail <--> newLink(tail) -->
+        newLink.next = None  # currentTail(tail)    newLink -->
+        self.tail.next = newLink  # currentTail(tail) --> newLink -->
+        newLink.previous = self.tail  # currentTail(tail) <--> newLink -->
+        self.tail = newLink  # oldTail <--> newLink(tail) -->
 
     def deleteTail(self):
         temp = self.tail
-        self.tail = self.tail.previous              # 2ndLast(tail) <--> oldTail --> None
-        self.tail.next = None                       # 2ndlast(tail) --> None
+        self.tail = self.tail.previous  # 2ndLast(tail) <--> oldTail --> None
+        self.tail.next = None  # 2ndlast(tail) --> None
         return temp
 
     def delete(self, x):
         current = self.head
 
-        while(current.value != x):                  # Find the position to delete
+        while current.value != x:  # Find the position to delete
             current = current.next
 
-        if(current == self.head):
+        if current == self.head:
             self.deleteHead()
 
-        elif(current == self.tail):
+        elif current == self.tail:
             self.deleteTail()
 
-        else: #Before: 1 <--> 2(current) <--> 3
-            current.previous.next = current.next # 1 --> 3
-            current.next.previous = current.previous # 1 <--> 3
+        else:  # Before: 1 <--> 2(current) <--> 3
+            current.previous.next = current.next  # 1 --> 3
+            current.next.previous = current.previous  # 1 <--> 3
 
-    def isEmpty(self):                               #Will return True if the list is empty
-        return(self.head is None)
+    def isEmpty(self):  # Will return True if the list is empty
+        return self.head is None
 
-    def display(self):                                #Prints contents of the list
+    def display(self):  # Prints contents of the list
         current = self.head
-        while(current != None):
+        while current != None:
             current.displayLink()
             current = current.next
         print()
 
+
 class Link:
-    next = None                                       #This points to the link in front of the new link
-    previous = None                                   #This points to the link behind the new link
+    next = None  # This points to the link in front of the new link
+    previous = None  # This points to the link behind the new link
+
     def __init__(self, x):
         self.value = x
+
     def displayLink(self):
         print("{}".format(self.value), end=" ")
diff --git a/data_structures/linked_list/singly_linked_list.py b/data_structures/linked_list/singly_linked_list.py
index 5943b88d5964..16436ff90274 100644
--- a/data_structures/linked_list/singly_linked_list.py
+++ b/data_structures/linked_list/singly_linked_list.py
@@ -6,21 +6,22 @@ def __init__(self, data):
 
 class Linked_List:
     def __init__(self):
-        self.Head = None    # Initialize Head to None
+        self.Head = None  # Initialize Head to None
 
     def insert_tail(self, data):
-        if(self.Head is None): self.insert_head(data)    #If this is first node, call insert_head
+        if self.Head is None:
+            self.insert_head(data)  # If this is first node, call insert_head
         else:
             temp = self.Head
-            while(temp.next != None):    #traverse to last node
+            while temp.next != None:  # traverse to last node
                 temp = temp.next
-            temp.next = Node(data)    #create node & link to tail
+            temp.next = Node(data)  # create node & link to tail
 
     def insert_head(self, data):
-        newNod = Node(data)    # create a new node
+        newNod = Node(data)  # create a new node
         if self.Head != None:
-            newNod.next = self.Head     # link newNode to head
-        self.Head = newNod    # make NewNode as Head
+            newNod.next = self.Head  # link newNode to head
+        self.Head = newNod  # make NewNode as Head
 
     def printList(self):  # print every node data
         tamp = self.Head
@@ -38,12 +39,15 @@ def delete_head(self):  # delete from head
     def delete_tail(self):  # delete from tail
         tamp = self.Head
         if self.Head != None:
-            if(self.Head.next is None):    # if Head is the only Node in the Linked List
+            if self.Head.next is None:  # if Head is the only Node in the Linked List
                 self.Head = None
             else:
                 while tamp.next.next is not None:  # find the 2nd last element
                     tamp = tamp.next
-                tamp.next, tamp = None, tamp.next    #(2nd last element).next = None and tamp = last element
+                tamp.next, tamp = (
+                    None,
+                    tamp.next,
+                )  # (2nd last element).next = None and tamp = last element
         return tamp
 
     def isEmpty(self):
@@ -65,21 +69,22 @@ def reverse(self):
         # Return prev in order to put the head at the end
         self.Head = prev
 
+
 def main():
     A = Linked_List()
     print("Inserting 1st at Head")
-    a1=input()
+    a1 = input()
     A.insert_head(a1)
     print("Inserting 2nd at Head")
-    a2=input()
+    a2 = input()
     A.insert_head(a2)
     print("\nPrint List : ")
     A.printList()
     print("\nInserting 1st at Tail")
-    a3=input()
+    a3 = input()
     A.insert_tail(a3)
     print("Inserting 2nd at Tail")
-    a4=input()
+    a4 = input()
     A.insert_tail(a4)
     print("\nPrint List : ")
     A.printList()
@@ -94,5 +99,6 @@ def main():
     print("\nPrint List : ")
     A.printList()
 
-if __name__ == '__main__':
-	main()
+
+if __name__ == "__main__":
+    main()
diff --git a/data_structures/linked_list/swap_nodes.py b/data_structures/linked_list/swap_nodes.py
index ce2543bc46d8..a6a50091e3e0 100644
--- a/data_structures/linked_list/swap_nodes.py
+++ b/data_structures/linked_list/swap_nodes.py
@@ -1,6 +1,6 @@
 class Node:
     def __init__(self, data):
-        self.data = data;
+        self.data = data
         self.next = None
 
 
@@ -14,13 +14,13 @@ def print_list(self):
             print(temp.data)
             temp = temp.next
 
-# adding nodes
+    # adding nodes
     def push(self, new_data):
         new_node = Node(new_data)
         new_node.next = self.head
         self.head = new_node
 
-# swapping nodes
+    # swapping nodes
     def swapNodes(self, d1, d2):
         prevD1 = None
         prevD2 = None
@@ -53,11 +53,11 @@ def swapNodes(self, d1, d2):
             D1.next = D2.next
             D2.next = temp
 
-# swapping code ends here
 
+# swapping code ends here
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     list = Linkedlist()
     list.push(5)
     list.push(4)
@@ -70,6 +70,3 @@ def swapNodes(self, d1, d2):
     list.swapNodes(1, 4)
     print("After swapping")
     list.print_list()
-
-
-
diff --git a/data_structures/queue/double_ended_queue.py b/data_structures/queue/double_ended_queue.py
index a3cfa7230710..dd003b7c98ac 100644
--- a/data_structures/queue/double_ended_queue.py
+++ b/data_structures/queue/double_ended_queue.py
@@ -5,11 +5,11 @@
 import collections
 
 # initializing deque
-de = collections.deque([1, 2, 3,])
+de = collections.deque([1, 2, 3])
 
 # using extend() to add numbers to right end
 # adds 4,5,6 to right end
-de.extend([4,5,6])
+de.extend([4, 5, 6])
 
 # printing modified deque
 print("The deque after extending deque at end is : ")
@@ -17,7 +17,7 @@
 
 # using extendleft() to add numbers to left end
 # adds 7,8,9 to right end
-de.extendleft([7,8,9])
+de.extendleft([7, 8, 9])
 
 # printing modified deque
 print("The deque after extending deque at beginning is : ")
diff --git a/data_structures/queue/queue_on_list.py b/data_structures/queue/queue_on_list.py
index 2ec9bac8398a..bb44e08ad6c5 100644
--- a/data_structures/queue/queue_on_list.py
+++ b/data_structures/queue/queue_on_list.py
@@ -1,46 +1,52 @@
 """Queue represented by a python list"""
-class Queue():
+
+
+class Queue:
     def __init__(self):
         self.entries = []
         self.length = 0
-        self.front=0
+        self.front = 0
 
     def __str__(self):
-        printed = '<' + str(self.entries)[1:-1] + '>'
+        printed = "<" + str(self.entries)[1:-1] + ">"
         return printed
 
     """Enqueues {@code item}
     @param item
         item to enqueue"""
+
     def put(self, item):
         self.entries.append(item)
         self.length = self.length + 1
 
-
     """Dequeues {@code item}
     @requirement: |self.length| > 0
     @return dequeued
         item that was dequeued"""
+
     def get(self):
         self.length = self.length - 1
         dequeued = self.entries[self.front]
-        #self.front-=1
-        #self.entries = self.entries[self.front:]
+        # self.front-=1
+        # self.entries = self.entries[self.front:]
         self.entries = self.entries[1:]
         return dequeued
 
     """Rotates the queue {@code rotation} times
     @param rotation
         number of times to rotate queue"""
+
     def rotate(self, rotation):
         for i in range(rotation):
             self.put(self.get())
 
     """Enqueues {@code item}
     @return item at front of self.entries"""
+
     def front(self):
         return self.entries[0]
 
     """Returns the length of this.entries"""
+
     def size(self):
         return self.length
diff --git a/data_structures/queue/queue_on_pseudo_stack.py b/data_structures/queue/queue_on_pseudo_stack.py
index b69fbcc988f7..7fa2fb2566af 100644
--- a/data_structures/queue/queue_on_pseudo_stack.py
+++ b/data_structures/queue/queue_on_pseudo_stack.py
@@ -1,16 +1,19 @@
 """Queue represented by a pseudo stack (represented by a list with pop and append)"""
-class Queue():
+
+
+class Queue:
     def __init__(self):
         self.stack = []
         self.length = 0
 
     def __str__(self):
-        printed = '<' + str(self.stack)[1:-1] + '>'
+        printed = "<" + str(self.stack)[1:-1] + ">"
         return printed
 
     """Enqueues {@code item}
     @param item
         item to enqueue"""
+
     def put(self, item):
         self.stack.append(item)
         self.length = self.length + 1
@@ -19,17 +22,19 @@ def put(self, item):
     @requirement: |self.length| > 0
     @return dequeued
         item that was dequeued"""
+
     def get(self):
         self.rotate(1)
-        dequeued = self.stack[self.length-1]
+        dequeued = self.stack[self.length - 1]
         self.stack = self.stack[:-1]
-        self.rotate(self.length-1)
-        self.length = self.length -1
+        self.rotate(self.length - 1)
+        self.length = self.length - 1
         return dequeued
 
     """Rotates the queue {@code rotation} times
     @param rotation
         number of times to rotate queue"""
+
     def rotate(self, rotation):
         for i in range(rotation):
             temp = self.stack[0]
@@ -39,12 +44,14 @@ def rotate(self, rotation):
 
     """Reports item at the front of self
     @return item at front of self.stack"""
+
     def front(self):
         front = self.get()
         self.put(front)
-        self.rotate(self.length-1)
+        self.rotate(self.length - 1)
         return front
 
     """Returns the length of this.stack"""
+
     def size(self):
         return self.length
diff --git a/data_structures/stacks/__init__.py b/data_structures/stacks/__init__.py
index f7e92ae2d269..f6995cf98977 100644
--- a/data_structures/stacks/__init__.py
+++ b/data_structures/stacks/__init__.py
@@ -1,23 +1,22 @@
 class Stack:
+    def __init__(self):
+        self.stack = []
+        self.top = 0
 
-   def __init__(self):
-      self.stack = []
-      self.top = 0
+    def is_empty(self):
+        return self.top == 0
 
-   def is_empty(self):
-      return (self.top == 0)
+    def push(self, item):
+        if self.top < len(self.stack):
+            self.stack[self.top] = item
+        else:
+            self.stack.append(item)
 
-   def push(self, item):
-      if self.top < len(self.stack):
-         self.stack[self.top] = item
-      else:
-         self.stack.append(item)
+        self.top += 1
 
-      self.top += 1
-
-   def pop(self):
-      if self.is_empty():
-         return None
-      else:
-         self.top -= 1
-         return self.stack[self.top]
+    def pop(self):
+        if self.is_empty():
+            return None
+        else:
+            self.top -= 1
+            return self.stack[self.top]
diff --git a/data_structures/stacks/balanced_parentheses.py b/data_structures/stacks/balanced_parentheses.py
index 3f43ccbf5760..7aacd5969277 100644
--- a/data_structures/stacks/balanced_parentheses.py
+++ b/data_structures/stacks/balanced_parentheses.py
@@ -1,23 +1,23 @@
 from .stack import Stack
 
-__author__ = 'Omkar Pathak'
+__author__ = "Omkar Pathak"
 
 
 def balanced_parentheses(parentheses):
     """ Use a stack to check if a string of parentheses is balanced."""
     stack = Stack(len(parentheses))
     for parenthesis in parentheses:
-        if parenthesis == '(':
+        if parenthesis == "(":
             stack.push(parenthesis)
-        elif parenthesis == ')':
+        elif parenthesis == ")":
             if stack.is_empty():
                 return False
             stack.pop()
     return stack.is_empty()
 
 
-if __name__ == '__main__':
-    examples = ['((()))', '((())', '(()))']
-    print('Balanced parentheses demonstration:\n')
+if __name__ == "__main__":
+    examples = ["((()))", "((())", "(()))"]
+    print("Balanced parentheses demonstration:\n")
     for example in examples:
-        print(example + ': ' + str(balanced_parentheses(example)))
+        print(example + ": " + str(balanced_parentheses(example)))
diff --git a/data_structures/stacks/infix_to_postfix_conversion.py b/data_structures/stacks/infix_to_postfix_conversion.py
index 84a5d1480a24..61114402377a 100644
--- a/data_structures/stacks/infix_to_postfix_conversion.py
+++ b/data_structures/stacks/infix_to_postfix_conversion.py
@@ -2,7 +2,7 @@
 
 from .stack import Stack
 
-__author__ = 'Omkar Pathak'
+__author__ = "Omkar Pathak"
 
 
 def is_operand(char):
@@ -15,9 +15,7 @@ def precedence(char):
 
     https://en.wikipedia.org/wiki/Order_of_operations
     """
-    dictionary = {'+': 1, '-': 1,
-                  '*': 2, '/': 2,
-                  '^': 3}
+    dictionary = {"+": 1, "-": 1, "*": 2, "/": 2, "^": 3}
     return dictionary.get(char, -1)
 
 
@@ -34,29 +32,28 @@ def infix_to_postfix(expression):
     for char in expression:
         if is_operand(char):
             postfix.append(char)
-        elif char not in {'(', ')'}:
-            while (not stack.is_empty()
-                    and precedence(char) <= precedence(stack.peek())):
+        elif char not in {"(", ")"}:
+            while not stack.is_empty() and precedence(char) <= precedence(stack.peek()):
                 postfix.append(stack.pop())
             stack.push(char)
-        elif char == '(':
+        elif char == "(":
             stack.push(char)
-        elif char == ')':
-            while not stack.is_empty() and stack.peek() != '(':
+        elif char == ")":
+            while not stack.is_empty() and stack.peek() != "(":
                 postfix.append(stack.pop())
             # Pop '(' from stack. If there is no '(', there is a mismatched
             # parentheses.
-            if stack.peek() != '(':
-                raise ValueError('Mismatched parentheses')
+            if stack.peek() != "(":
+                raise ValueError("Mismatched parentheses")
             stack.pop()
     while not stack.is_empty():
         postfix.append(stack.pop())
-    return ' '.join(postfix)
+    return " ".join(postfix)
 
 
-if __name__ == '__main__':
-    expression = 'a+b*(c^d-e)^(f+g*h)-i'
+if __name__ == "__main__":
+    expression = "a+b*(c^d-e)^(f+g*h)-i"
 
-    print('Infix to Postfix Notation demonstration:\n')
-    print('Infix notation: ' + expression)
-    print('Postfix notation: ' + infix_to_postfix(expression))
+    print("Infix to Postfix Notation demonstration:\n")
+    print("Infix notation: " + expression)
+    print("Postfix notation: " + infix_to_postfix(expression))
diff --git a/data_structures/stacks/infix_to_prefix_conversion.py b/data_structures/stacks/infix_to_prefix_conversion.py
index da5fc261fb9f..4f0e1ab8adfa 100644
--- a/data_structures/stacks/infix_to_prefix_conversion.py
+++ b/data_structures/stacks/infix_to_prefix_conversion.py
@@ -14,48 +14,82 @@
 	 a+b^c (Infix) ->  +a^bc (Prefix)
 """
 
+
 def infix_2_postfix(Infix):
     Stack = []
     Postfix = []
-    priority = {'^':3, '*':2, '/':2, '%':2, '+':1, '-':1}       # Priority of each operator
-    print_width = len(Infix) if(len(Infix)>7) else 7
+    priority = {
+        "^": 3,
+        "*": 2,
+        "/": 2,
+        "%": 2,
+        "+": 1,
+        "-": 1,
+    }  # Priority of each operator
+    print_width = len(Infix) if (len(Infix) > 7) else 7
 
     # Print table header for output
-    print('Symbol'.center(8), 'Stack'.center(print_width), 'Postfix'.center(print_width), sep = " | ")
-    print('-'*(print_width*3+7))
+    print(
+        "Symbol".center(8),
+        "Stack".center(print_width),
+        "Postfix".center(print_width),
+        sep=" | ",
+    )
+    print("-" * (print_width * 3 + 7))
 
     for x in Infix:
-        if(x.isalpha() or x.isdigit()): Postfix.append(x)       # if x is Alphabet / Digit, add it to Postfix
-        elif(x == '('): Stack.append(x)                         # if x is "(" push to Stack
-        elif(x == ')'):                                         # if x is ")" pop stack until "(" is encountered
-            while(Stack[-1] != '('):
-                Postfix.append( Stack.pop() )                   #Pop stack & add the content to Postfix
+        if x.isalpha() or x.isdigit():
+            Postfix.append(x)  # if x is Alphabet / Digit, add it to Postfix
+        elif x == "(":
+            Stack.append(x)  # if x is "(" push to Stack
+        elif x == ")":  # if x is ")" pop stack until "(" is encountered
+            while Stack[-1] != "(":
+                Postfix.append(Stack.pop())  # Pop stack & add the content to Postfix
             Stack.pop()
         else:
-            if(len(Stack)==0): Stack.append(x)                  #If stack is empty, push x to stack
+            if len(Stack) == 0:
+                Stack.append(x)  # If stack is empty, push x to stack
             else:
-                while( len(Stack) > 0 and priority[x] <= priority[Stack[-1]]):      # while priority of x is not greater than priority of element in the stack
-                    Postfix.append( Stack.pop() )                                   # pop stack & add to Postfix
-                Stack.append(x)                                 # push x to stack
+                while (
+                    len(Stack) > 0 and priority[x] <= priority[Stack[-1]]
+                ):  # while priority of x is not greater than priority of element in the stack
+                    Postfix.append(Stack.pop())  # pop stack & add to Postfix
+                Stack.append(x)  # push x to stack
+
+        print(
+            x.center(8),
+            ("".join(Stack)).ljust(print_width),
+            ("".join(Postfix)).ljust(print_width),
+            sep=" | ",
+        )  # Output in tabular format
 
-        print(x.center(8), (''.join(Stack)).ljust(print_width), (''.join(Postfix)).ljust(print_width), sep = " | ")         # Output in tabular format
+    while len(Stack) > 0:  # while stack is not empty
+        Postfix.append(Stack.pop())  # pop stack & add to Postfix
+        print(
+            " ".center(8),
+            ("".join(Stack)).ljust(print_width),
+            ("".join(Postfix)).ljust(print_width),
+            sep=" | ",
+        )  # Output in tabular format
 
-    while(len(Stack) > 0):                                  # while stack is not empty
-        Postfix.append( Stack.pop() )                       # pop stack & add to Postfix
-        print(' '.center(8), (''.join(Stack)).ljust(print_width), (''.join(Postfix)).ljust(print_width), sep = " | ")         # Output in tabular format
+    return "".join(Postfix)  # return Postfix as str
 
-    return "".join(Postfix)             # return Postfix as str
 
 def infix_2_prefix(Infix):
-    Infix = list(Infix[::-1])       # reverse the infix equation
-    
+    Infix = list(Infix[::-1])  # reverse the infix equation
+
     for i in range(len(Infix)):
-        if(Infix[i] == '('): Infix[i] = ')'         # change "(" to ")"
-        elif(Infix[i] == ')'): Infix[i] = '('       # change ")" to "("
-    
-    return (infix_2_postfix("".join(Infix)))[::-1]  # call infix_2_postfix on Infix, return reverse of Postfix
+        if Infix[i] == "(":
+            Infix[i] = ")"  # change "(" to ")"
+        elif Infix[i] == ")":
+            Infix[i] = "("  # change ")" to "("
+
+    return (infix_2_postfix("".join(Infix)))[
+        ::-1
+    ]  # call infix_2_postfix on Infix, return reverse of Postfix
+
 
 if __name__ == "__main__":
-    Infix = input("\nEnter an Infix Equation = ")       #Input an Infix equation
-    Infix = "".join(Infix.split())                      #Remove spaces from the input
+    Infix = input("\nEnter an Infix Equation = ")  # Input an Infix equation
+    Infix = "".join(Infix.split())  # Remove spaces from the input
     print("\n\t", Infix, "(Infix) -> ", infix_2_prefix(Infix), "(Prefix)")
diff --git a/data_structures/stacks/next_greater_element.py b/data_structures/stacks/next_greater_element.py
index 2e67f1764a5a..02a86196f5bf 100644
--- a/data_structures/stacks/next_greater_element.py
+++ b/data_structures/stacks/next_greater_element.py
@@ -4,13 +4,14 @@ def printNGE(arr):
     for i in range(0, len(arr), 1):
 
         next = -1
-        for j in range(i+1, len(arr), 1):
+        for j in range(i + 1, len(arr), 1):
             if arr[i] < arr[j]:
                 next = arr[j]
                 break
 
         print(str(arr[i]) + " -- " + str(next))
 
+
 # Driver program to test above function
-arr = [11,13,21,3]
+arr = [11, 13, 21, 3]
 printNGE(arr)
diff --git a/data_structures/stacks/postfix_evaluation.py b/data_structures/stacks/postfix_evaluation.py
index 1786e71dd383..0f3d5c76d6a3 100644
--- a/data_structures/stacks/postfix_evaluation.py
+++ b/data_structures/stacks/postfix_evaluation.py
@@ -19,32 +19,52 @@
 
 import operator as op
 
+
 def Solve(Postfix):
     Stack = []
-    Div = lambda x, y: int(x/y)     # integer division operation
-    Opr = {'^':op.pow, '*':op.mul, '/':Div, '+':op.add, '-':op.sub}     # operators & their respective operation
+    Div = lambda x, y: int(x / y)  # integer division operation
+    Opr = {
+        "^": op.pow,
+        "*": op.mul,
+        "/": Div,
+        "+": op.add,
+        "-": op.sub,
+    }  # operators & their respective operation
 
     # print table header
-    print('Symbol'.center(8), 'Action'.center(12), 'Stack', sep = " | ")
-    print('-'*(30+len(Postfix)))
+    print("Symbol".center(8), "Action".center(12), "Stack", sep=" | ")
+    print("-" * (30 + len(Postfix)))
 
     for x in Postfix:
-        if( x.isdigit() ):          # if x in digit
-            Stack.append(x)         # append x to stack
-            print(x.rjust(8), ('push('+x+')').ljust(12), ','.join(Stack), sep = " | ")      # output in tabular format
+        if x.isdigit():  # if x in digit
+            Stack.append(x)  # append x to stack
+            print(
+                x.rjust(8), ("push(" + x + ")").ljust(12), ",".join(Stack), sep=" | "
+            )  # output in tabular format
         else:
-            B = Stack.pop()             # pop stack
-            print("".rjust(8), ('pop('+B+')').ljust(12), ','.join(Stack), sep = " | ")      # output in tabular format
+            B = Stack.pop()  # pop stack
+            print(
+                "".rjust(8), ("pop(" + B + ")").ljust(12), ",".join(Stack), sep=" | "
+            )  # output in tabular format
 
-            A = Stack.pop()             # pop stack
-            print("".rjust(8), ('pop('+A+')').ljust(12), ','.join(Stack), sep = " | ")      # output in tabular format
+            A = Stack.pop()  # pop stack
+            print(
+                "".rjust(8), ("pop(" + A + ")").ljust(12), ",".join(Stack), sep=" | "
+            )  # output in tabular format
 
-            Stack.append( str(Opr[x](int(A), int(B))) )         # evaluate the 2 values poped from stack & push result to stack
-            print(x.rjust(8), ('push('+A+x+B+')').ljust(12), ','.join(Stack), sep = " | ")      # output in tabular format
+            Stack.append(
+                str(Opr[x](int(A), int(B)))
+            )  # evaluate the 2 values poped from stack & push result to stack
+            print(
+                x.rjust(8),
+                ("push(" + A + x + B + ")").ljust(12),
+                ",".join(Stack),
+                sep=" | ",
+            )  # output in tabular format
 
     return int(Stack[0])
 
 
 if __name__ == "__main__":
-    Postfix = input("\n\nEnter a Postfix Equation (space separated) = ").split(' ')
+    Postfix = input("\n\nEnter a Postfix Equation (space separated) = ").split(" ")
     print("\n\tResult = ", Solve(Postfix))
diff --git a/data_structures/stacks/stack.py b/data_structures/stacks/stack.py
index 387367db2fcc..9f5b279710c6 100644
--- a/data_structures/stacks/stack.py
+++ b/data_structures/stacks/stack.py
@@ -1,4 +1,4 @@
-__author__ = 'Omkar Pathak'
+__author__ = "Omkar Pathak"
 
 
 class Stack(object):
@@ -32,7 +32,7 @@ def pop(self):
         if self.stack:
             return self.stack.pop()
         else:
-            raise IndexError('pop from an empty stack')
+            raise IndexError("pop from an empty stack")
 
     def peek(self):
         """ Peek at the top-most element of the stack."""
@@ -52,17 +52,17 @@ class StackOverflowError(BaseException):
     pass
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     stack = Stack()
     for i in range(10):
         stack.push(i)
 
-    print('Stack demonstration:\n')
-    print('Initial stack: ' + str(stack))
-    print('pop(): ' + str(stack.pop()))
-    print('After pop(), the stack is now: ' + str(stack))
-    print('peek(): ' + str(stack.peek()))
+    print("Stack demonstration:\n")
+    print("Initial stack: " + str(stack))
+    print("pop(): " + str(stack.pop()))
+    print("After pop(), the stack is now: " + str(stack))
+    print("peek(): " + str(stack.peek()))
     stack.push(100)
-    print('After push(100), the stack is now: ' + str(stack))
-    print('is_empty(): ' + str(stack.is_empty()))
-    print('size(): ' + str(stack.size()))
+    print("After push(100), the stack is now: " + str(stack))
+    print("is_empty(): " + str(stack.is_empty()))
+    print("size(): " + str(stack.size()))
diff --git a/data_structures/stacks/stock_span_problem.py b/data_structures/stacks/stock_span_problem.py
index 47d916fde9ed..45cd6bae1282 100644
--- a/data_structures/stacks/stock_span_problem.py
+++ b/data_structures/stacks/stock_span_problem.py
@@ -1,11 +1,13 @@
-'''
+"""
 The stock span problem is a financial problem where we have a series of n daily
 price quotes for a stock and we need to calculate span of stock's price for all n days.
 
 The span Si of the stock's price on a given day i is defined as the maximum
 number of consecutive days just before the given day, for which the price of the stock
 on the current day is less than or equal to its price on the given day.
-'''
+"""
+
+
 def calculateSpan(price, S):
 
     n = len(price)
@@ -21,14 +23,14 @@ def calculateSpan(price, S):
 
         # Pop elements from stack whlie stack is not
         # empty and top of stack is smaller than price[i]
-        while( len(st) > 0 and price[st[0]] <= price[i]):
+        while len(st) > 0 and price[st[0]] <= price[i]:
             st.pop()
 
         # If stack becomes empty, then price[i] is greater
         # than all elements on left of it, i.e. price[0],
         # price[1], ..price[i-1]. Else the price[i]  is
         # greater than elements after top of stack
-        S[i] = i+1 if len(st) <= 0 else (i - st[0])
+        S[i] = i + 1 if len(st) <= 0 else (i - st[0])
 
         # Push this element to stack
         st.append(i)
@@ -36,13 +38,13 @@ def calculateSpan(price, S):
 
 # A utility function to print elements of array
 def printArray(arr, n):
-    for i in range(0,n):
-        print(arr[i],end =" ")
+    for i in range(0, n):
+        print(arr[i], end=" ")
 
 
 # Driver program to test above function
 price = [10, 4, 5, 90, 120, 80]
-S = [0 for i in range(len(price)+1)]
+S = [0 for i in range(len(price) + 1)]
 
 # Fill the span values in array S[]
 calculateSpan(price, S)
diff --git a/digital_image_processing/edge_detection/canny.py b/digital_image_processing/edge_detection/canny.py
index 7fde75a90a48..6f98fee6308e 100644
--- a/digital_image_processing/edge_detection/canny.py
+++ b/digital_image_processing/edge_detection/canny.py
@@ -8,8 +8,12 @@
 
 def gen_gaussian_kernel(k_size, sigma):
     center = k_size // 2
-    x, y = np.mgrid[0 - center:k_size - center, 0 - center:k_size - center]
-    g = 1 / (2 * np.pi * sigma) * np.exp(-(np.square(x) + np.square(y)) / (2 * np.square(sigma)))
+    x, y = np.mgrid[0 - center : k_size - center, 0 - center : k_size - center]
+    g = (
+        1
+        / (2 * np.pi * sigma)
+        * np.exp(-(np.square(x) + np.square(y)) / (2 * np.square(sigma)))
+    )
     return g
 
 
@@ -34,27 +38,33 @@ def canny(image, threshold_low=15, threshold_high=30, weak=128, strong=255):
 
             if (
                 0 <= direction < 22.5
-                    or 15 * PI / 8 <= direction <= 2 * PI
-                    or 7 * PI / 8 <= direction <= 9 * PI / 8
+                or 15 * PI / 8 <= direction <= 2 * PI
+                or 7 * PI / 8 <= direction <= 9 * PI / 8
             ):
                 W = sobel_grad[row, col - 1]
                 E = sobel_grad[row, col + 1]
                 if sobel_grad[row, col] >= W and sobel_grad[row, col] >= E:
                     dst[row, col] = sobel_grad[row, col]
 
-            elif (PI / 8 <= direction < 3 * PI / 8) or (9 * PI / 8 <= direction < 11 * PI / 8):
+            elif (PI / 8 <= direction < 3 * PI / 8) or (
+                9 * PI / 8 <= direction < 11 * PI / 8
+            ):
                 SW = sobel_grad[row + 1, col - 1]
                 NE = sobel_grad[row - 1, col + 1]
                 if sobel_grad[row, col] >= SW and sobel_grad[row, col] >= NE:
                     dst[row, col] = sobel_grad[row, col]
 
-            elif (3 * PI / 8 <= direction < 5 * PI / 8) or (11 * PI / 8 <= direction < 13 * PI / 8):
+            elif (3 * PI / 8 <= direction < 5 * PI / 8) or (
+                11 * PI / 8 <= direction < 13 * PI / 8
+            ):
                 N = sobel_grad[row - 1, col]
                 S = sobel_grad[row + 1, col]
                 if sobel_grad[row, col] >= N and sobel_grad[row, col] >= S:
                     dst[row, col] = sobel_grad[row, col]
 
-            elif (5 * PI / 8 <= direction < 7 * PI / 8) or (13 * PI / 8 <= direction < 15 * PI / 8):
+            elif (5 * PI / 8 <= direction < 7 * PI / 8) or (
+                13 * PI / 8 <= direction < 15 * PI / 8
+            ):
                 NW = sobel_grad[row - 1, col - 1]
                 SE = sobel_grad[row + 1, col + 1]
                 if sobel_grad[row, col] >= NW and sobel_grad[row, col] >= SE:
@@ -82,14 +92,14 @@ def canny(image, threshold_low=15, threshold_high=30, weak=128, strong=255):
         for col in range(1, image_col):
             if dst[row, col] == weak:
                 if 255 in (
-                        dst[row, col + 1],
-                        dst[row, col - 1],
-                        dst[row - 1, col],
-                        dst[row + 1, col],
-                        dst[row - 1, col - 1],
-                        dst[row + 1, col - 1],
-                        dst[row - 1, col + 1],
-                        dst[row + 1, col + 1],
+                    dst[row, col + 1],
+                    dst[row, col - 1],
+                    dst[row - 1, col],
+                    dst[row + 1, col],
+                    dst[row - 1, col - 1],
+                    dst[row + 1, col - 1],
+                    dst[row - 1, col + 1],
+                    dst[row + 1, col + 1],
                 ):
                     dst[row, col] = strong
                 else:
@@ -98,10 +108,10 @@ def canny(image, threshold_low=15, threshold_high=30, weak=128, strong=255):
     return dst
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     # read original image in gray mode
-    lena = cv2.imread(r'../image_data/lena.jpg', 0)
+    lena = cv2.imread(r"../image_data/lena.jpg", 0)
     # canny edge detection
     canny_dst = canny(lena)
-    cv2.imshow('canny', canny_dst)
+    cv2.imshow("canny", canny_dst)
     cv2.waitKey(0)
diff --git a/digital_image_processing/filters/convolve.py b/digital_image_processing/filters/convolve.py
index b7600d74c294..ec500d940366 100644
--- a/digital_image_processing/filters/convolve.py
+++ b/digital_image_processing/filters/convolve.py
@@ -13,7 +13,7 @@ def im2col(image, block_size):
     row = 0
     for i in range(0, dst_height):
         for j in range(0, dst_width):
-            window = ravel(image[i:i + block_size[0], j:j + block_size[1]])
+            window = ravel(image[i : i + block_size[0], j : j + block_size[1]])
             image_array[row, :] = window
             row += 1
 
@@ -23,9 +23,9 @@ def im2col(image, block_size):
 def img_convolve(image, filter_kernel):
     height, width = image.shape[0], image.shape[1]
     k_size = filter_kernel.shape[0]
-    pad_size = k_size//2
+    pad_size = k_size // 2
     # Pads image with the edge values of array.
-    image_tmp = pad(image, pad_size, mode='edge')
+    image_tmp = pad(image, pad_size, mode="edge")
 
     # im2col, turn the k_size*k_size pixels into a row and np.vstack all rows
     image_array = im2col(image_tmp, (k_size, k_size))
@@ -37,13 +37,13 @@ def img_convolve(image, filter_kernel):
     return dst
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     # read original image
-    img = imread(r'../image_data/lena.jpg')
+    img = imread(r"../image_data/lena.jpg")
     # turn image in gray scale value
     gray = cvtColor(img, COLOR_BGR2GRAY)
     # Laplace operator
     Laplace_kernel = array([[0, 1, 0], [1, -4, 1], [0, 1, 0]])
     out = img_convolve(gray, Laplace_kernel).astype(uint8)
-    imshow('Laplacian', out)
+    imshow("Laplacian", out)
     waitKey(0)
diff --git a/digital_image_processing/filters/gaussian_filter.py b/digital_image_processing/filters/gaussian_filter.py
index ff85ce047220..b800f0a7edc8 100644
--- a/digital_image_processing/filters/gaussian_filter.py
+++ b/digital_image_processing/filters/gaussian_filter.py
@@ -7,23 +7,23 @@
 
 def gen_gaussian_kernel(k_size, sigma):
     center = k_size // 2
-    x, y = mgrid[0-center:k_size-center, 0-center:k_size-center]
-    g = 1/(2*pi*sigma) * exp(-(square(x) + square(y))/(2*square(sigma)))
+    x, y = mgrid[0 - center : k_size - center, 0 - center : k_size - center]
+    g = 1 / (2 * pi * sigma) * exp(-(square(x) + square(y)) / (2 * square(sigma)))
     return g
 
 
 def gaussian_filter(image, k_size, sigma):
     height, width = image.shape[0], image.shape[1]
     # dst image height and width
-    dst_height = height-k_size+1
-    dst_width = width-k_size+1
+    dst_height = height - k_size + 1
+    dst_width = width - k_size + 1
 
     # im2col, turn the k_size*k_size pixels into a row and np.vstack all rows
-    image_array = zeros((dst_height*dst_width, k_size*k_size))
+    image_array = zeros((dst_height * dst_width, k_size * k_size))
     row = 0
     for i in range(0, dst_height):
         for j in range(0, dst_width):
-            window = ravel(image[i:i + k_size, j:j + k_size])
+            window = ravel(image[i : i + k_size, j : j + k_size])
             image_array[row, :] = window
             row += 1
 
@@ -37,9 +37,9 @@ def gaussian_filter(image, k_size, sigma):
     return dst
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     # read original image
-    img = imread(r'../image_data/lena.jpg')
+    img = imread(r"../image_data/lena.jpg")
     # turn image in gray scale value
     gray = cvtColor(img, COLOR_BGR2GRAY)
 
@@ -48,6 +48,6 @@ def gaussian_filter(image, k_size, sigma):
     gaussian5x5 = gaussian_filter(gray, 5, sigma=0.8)
 
     # show result images
-    imshow('gaussian filter with 3x3 mask', gaussian3x3)
-    imshow('gaussian filter with 5x5 mask', gaussian5x5)
+    imshow("gaussian filter with 3x3 mask", gaussian3x3)
+    imshow("gaussian filter with 5x5 mask", gaussian5x5)
     waitKey()
diff --git a/digital_image_processing/filters/median_filter.py b/digital_image_processing/filters/median_filter.py
index 4b21b96b080b..151ef8a55df1 100644
--- a/digital_image_processing/filters/median_filter.py
+++ b/digital_image_processing/filters/median_filter.py
@@ -19,16 +19,16 @@ def median_filter(gray_img, mask=3):
     for i in range(bd, gray_img.shape[0] - bd):
         for j in range(bd, gray_img.shape[1] - bd):
             # get mask according with mask
-            kernel = ravel(gray_img[i - bd:i + bd + 1, j - bd:j + bd + 1])
+            kernel = ravel(gray_img[i - bd : i + bd + 1, j - bd : j + bd + 1])
             # calculate mask median
             median = sort(kernel)[int8(divide((multiply(mask, mask)), 2) + 1)]
             median_img[i, j] = median
     return median_img
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     # read original image
-    img = imread('../image_data/lena.jpg')
+    img = imread("../image_data/lena.jpg")
     # turn image in gray scale value
     gray = cvtColor(img, COLOR_BGR2GRAY)
 
@@ -37,6 +37,6 @@ def median_filter(gray_img, mask=3):
     median5x5 = median_filter(gray, 5)
 
     # show result images
-    imshow('median filter with 3x3 mask', median3x3)
-    imshow('median filter with 5x5 mask', median5x5)
+    imshow("median filter with 3x3 mask", median3x3)
+    imshow("median filter with 5x5 mask", median5x5)
     waitKey(0)
diff --git a/digital_image_processing/filters/sobel_filter.py b/digital_image_processing/filters/sobel_filter.py
index f3ef407d49e5..822d49fe38a1 100644
--- a/digital_image_processing/filters/sobel_filter.py
+++ b/digital_image_processing/filters/sobel_filter.py
@@ -13,26 +13,26 @@ def sobel_filter(image):
     dst_x = np.abs(img_convolve(image, kernel_x))
     dst_y = np.abs(img_convolve(image, kernel_y))
     # modify the pix within [0, 255]
-    dst_x = dst_x * 255/np.max(dst_x)
-    dst_y = dst_y * 255/np.max(dst_y)
+    dst_x = dst_x * 255 / np.max(dst_x)
+    dst_y = dst_y * 255 / np.max(dst_y)
 
     dst_xy = np.sqrt((np.square(dst_x)) + (np.square(dst_y)))
-    dst_xy = dst_xy * 255/np.max(dst_xy)
+    dst_xy = dst_xy * 255 / np.max(dst_xy)
     dst = dst_xy.astype(np.uint8)
 
     theta = np.arctan2(dst_y, dst_x)
     return dst, theta
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     # read original image
-    img = imread('../image_data/lena.jpg')
+    img = imread("../image_data/lena.jpg")
     # turn image in gray scale value
     gray = cvtColor(img, COLOR_BGR2GRAY)
 
     sobel_grad, sobel_theta = sobel_filter(gray)
 
     # show result images
-    imshow('sobel filter', sobel_grad)
-    imshow('sobel theta', sobel_theta)
+    imshow("sobel filter", sobel_grad)
+    imshow("sobel theta", sobel_theta)
     waitKey(0)
diff --git a/divide_and_conquer/closest_pair_of_points.py b/divide_and_conquer/closest_pair_of_points.py
index 11dac7e0ab2a..eecf53a7450e 100644
--- a/divide_and_conquer/closest_pair_of_points.py
+++ b/divide_and_conquer/closest_pair_of_points.py
@@ -28,15 +28,15 @@ def euclidean_distance_sqr(point1, point2):
     return (point1[0] - point2[0]) ** 2 + (point1[1] - point2[1]) ** 2
 
 
-def column_based_sort(array, column = 0):
+def column_based_sort(array, column=0):
     """
     >>> column_based_sort([(5, 1), (4, 2), (3, 0)], 1)
     [(3, 0), (5, 1), (4, 2)]
     """
-    return sorted(array, key = lambda x: x[column])
+    return sorted(array, key=lambda x: x[column])
 
 
-def dis_between_closest_pair(points, points_counts, min_dis = float("inf")):
+def dis_between_closest_pair(points, points_counts, min_dis=float("inf")):
     """
     brute force approach to find distance between closest pair points
 
@@ -52,14 +52,14 @@ def dis_between_closest_pair(points, points_counts, min_dis = float("inf")):
     """
 
     for i in range(points_counts - 1):
-        for j in range(i+1, points_counts):
+        for j in range(i + 1, points_counts):
             current_dis = euclidean_distance_sqr(points[i], points[j])
             if current_dis < min_dis:
                 min_dis = current_dis
     return min_dis
 
 
-def dis_between_closest_in_strip(points, points_counts, min_dis = float("inf")):
+def dis_between_closest_in_strip(points, points_counts, min_dis=float("inf")):
     """
     closest pair of points in strip
 
@@ -74,7 +74,7 @@ def dis_between_closest_in_strip(points, points_counts, min_dis = float("inf")):
     """
 
     for i in range(min(6, points_counts - 1), points_counts):
-        for j in range(max(0, i-6), i):
+        for j in range(max(0, i - 6), i):
             current_dis = euclidean_distance_sqr(points[i], points[j])
             if current_dis < min_dis:
                 min_dis = current_dis
@@ -99,13 +99,13 @@ def closest_pair_of_points_sqr(points_sorted_on_x, points_sorted_on_y, points_co
         return dis_between_closest_pair(points_sorted_on_x, points_counts)
 
     # recursion
-    mid = points_counts//2
-    closest_in_left = closest_pair_of_points_sqr(points_sorted_on_x,
-                                                 points_sorted_on_y[:mid],
-                                                 mid)
-    closest_in_right = closest_pair_of_points_sqr(points_sorted_on_y,
-                                                  points_sorted_on_y[mid:],
-                                                  points_counts - mid)
+    mid = points_counts // 2
+    closest_in_left = closest_pair_of_points_sqr(
+        points_sorted_on_x, points_sorted_on_y[:mid], mid
+    )
+    closest_in_right = closest_pair_of_points_sqr(
+        points_sorted_on_y, points_sorted_on_y[mid:], points_counts - mid
+    )
     closest_pair_dis = min(closest_in_left, closest_in_right)
 
     """
@@ -118,8 +118,9 @@ def closest_pair_of_points_sqr(points_sorted_on_x, points_sorted_on_y, points_co
         if abs(point[0] - points_sorted_on_x[mid][0]) < closest_pair_dis:
             cross_strip.append(point)
 
-    closest_in_strip = dis_between_closest_in_strip(cross_strip,
-                     len(cross_strip), closest_pair_dis)
+    closest_in_strip = dis_between_closest_in_strip(
+        cross_strip, len(cross_strip), closest_pair_dis
+    )
     return min(closest_pair_dis, closest_in_strip)
 
 
@@ -128,11 +129,13 @@ def closest_pair_of_points(points, points_counts):
     >>> closest_pair_of_points([(2, 3), (12, 30)], len([(2, 3), (12, 30)]))
     28.792360097775937
     """
-    points_sorted_on_x = column_based_sort(points, column = 0)
-    points_sorted_on_y = column_based_sort(points, column = 1)
-    return (closest_pair_of_points_sqr(points_sorted_on_x,
-                                       points_sorted_on_y,
-                                       points_counts)) ** 0.5
+    points_sorted_on_x = column_based_sort(points, column=0)
+    points_sorted_on_y = column_based_sort(points, column=1)
+    return (
+        closest_pair_of_points_sqr(
+            points_sorted_on_x, points_sorted_on_y, points_counts
+        )
+    ) ** 0.5
 
 
 if __name__ == "__main__":
diff --git a/divide_and_conquer/convex_hull.py b/divide_and_conquer/convex_hull.py
index 534ebda2c780..bd88256ab01c 100644
--- a/divide_and_conquer/convex_hull.py
+++ b/divide_and_conquer/convex_hull.py
@@ -1,4 +1,5 @@
 from numbers import Number
+
 """
 The convex hull problem is problem of finding all the vertices of convex polygon, P of
 a set of points in a plane such that all the points are either on the vertices of P or
@@ -47,8 +48,10 @@ def __init__(self, x, y):
             try:
                 x, y = float(x), float(y)
             except ValueError as e:
-                e.args = ("x and y must be both numeric types "
-                          "but got {}, {} instead".format(type(x), type(y)), )
+                e.args = (
+                    "x and y must be both numeric types "
+                    "but got {}, {} instead".format(type(x), type(y)),
+                )
                 raise
 
         self.x = x
@@ -85,7 +88,7 @@ def __le__(self, other):
         return False
 
     def __repr__(self):
-        return "({}, {})".format(self.x,  self.y)
+        return "({}, {})".format(self.x, self.y)
 
     def __hash__(self):
         return hash(self.x)
@@ -132,8 +135,10 @@ def _construct_points(list_of_tuples):
             try:
                 points.append(Point(p[0], p[1]))
             except (IndexError, TypeError):
-                print("Ignoring deformed point {}. All points"
-                      " must have at least 2 coordinates.".format(p))
+                print(
+                    "Ignoring deformed point {}. All points"
+                    " must have at least 2 coordinates.".format(p)
+                )
     return points
 
 
@@ -189,12 +194,15 @@ def _validate_input(points):
             if isinstance(points[0], (list, tuple)):
                 points = _construct_points(points)
             else:
-                raise ValueError("Expecting an iterable of type Point, list or tuple. "
-                                 "Found objects of type {} instead"
-                                 .format(type(points[0])))
+                raise ValueError(
+                    "Expecting an iterable of type Point, list or tuple. "
+                    "Found objects of type {} instead".format(type(points[0]))
+                )
         elif not hasattr(points, "__iter__"):
-            raise ValueError("Expecting an iterable object "
-                             "but got an non-iterable type {}".format(points))
+            raise ValueError(
+                "Expecting an iterable object "
+                "but got an non-iterable type {}".format(points)
+            )
     except TypeError as e:
         print("Expecting an iterable of type Point, list or tuple.")
         raise
@@ -277,7 +285,7 @@ def convex_hull_bf(points):
     n = len(points)
     convex_set = set()
 
-    for i in range(n-1):
+    for i in range(n - 1):
         for j in range(i + 1, n):
             points_left_of_ij = points_right_of_ij = False
             ij_part_of_convex_hull = True
@@ -353,13 +361,13 @@ def convex_hull_recursive(points):
     # convex hull
 
     left_most_point = points[0]
-    right_most_point = points[n-1]
+    right_most_point = points[n - 1]
 
     convex_set = {left_most_point, right_most_point}
     upperhull = []
     lowerhull = []
 
-    for i in range(1, n-1):
+    for i in range(1, n - 1):
         det = _det(left_most_point, right_most_point, points[i])
 
         if det > 0:
@@ -394,7 +402,7 @@ def _construct_hull(points, left, right, convex_set):
     """
     if points:
         extreme_point = None
-        extreme_point_distance = float('-inf')
+        extreme_point_distance = float("-inf")
         candidate_points = []
 
         for p in points:
@@ -414,8 +422,18 @@ def _construct_hull(points, left, right, convex_set):
 
 
 def main():
-    points = [(0, 3), (2, 2), (1, 1), (2, 1), (3, 0),
-              (0, 0), (3, 3), (2, -1), (2, -4), (1, -3)]
+    points = [
+        (0, 3),
+        (2, 2),
+        (1, 1),
+        (2, 1),
+        (3, 0),
+        (0, 0),
+        (3, 3),
+        (2, -1),
+        (2, -4),
+        (1, -3),
+    ]
     # the convex set of points is
     # [(0, 0), (0, 3), (1, -3), (2, -4), (3, 0), (3, 3)]
     results_recursive = convex_hull_recursive(points)
@@ -425,5 +443,5 @@ def main():
     print(results_bf)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
diff --git a/divide_and_conquer/inversions.py b/divide_and_conquer/inversions.py
index e4d50b7d4729..9bb656229321 100644
--- a/divide_and_conquer/inversions.py
+++ b/divide_and_conquer/inversions.py
@@ -38,7 +38,7 @@ def count_inversions_bf(arr):
     num_inversions = 0
     n = len(arr)
 
-    for i in range(n-1):
+    for i in range(n - 1):
         for j in range(i + 1, n):
             if arr[i] > arr[j]:
                 num_inversions += 1
@@ -73,7 +73,7 @@ def count_inversions_recursive(arr):
     if len(arr) <= 1:
         return arr, 0
     else:
-        mid = len(arr)//2
+        mid = len(arr) // 2
         P = arr[0:mid]
         Q = arr[mid:]
 
@@ -119,7 +119,7 @@ def _count_cross_inversions(P, Q):
             # if P[1] > Q[j], then P[k] > Q[k] for all  i < k <= len(P)
             # These are all inversions. The claim emerges from the
             # property that P is sorted.
-            num_inversion += (len(P) - i)
+            num_inversion += len(P) - i
             R.append(Q[j])
             j += 1
         else:
@@ -127,9 +127,9 @@ def _count_cross_inversions(P, Q):
             i += 1
 
     if i < len(P):
-       R.extend(P[i:])
+        R.extend(P[i:])
     else:
-       R.extend(Q[j:])
+        R.extend(Q[j:])
 
     return R, num_inversion
 
@@ -166,6 +166,4 @@ def main():
 
 
 if __name__ == "__main__":
-   main()
-
-
+    main()
diff --git a/divide_and_conquer/max_subarray_sum.py b/divide_and_conquer/max_subarray_sum.py
index 0428f4e13768..9e81c83649a6 100644
--- a/divide_and_conquer/max_subarray_sum.py
+++ b/divide_and_conquer/max_subarray_sum.py
@@ -40,8 +40,8 @@ def max_cross_array_sum(array, left, mid, right):
 
     """
 
-    max_sum_of_left = max_sum_from_start(array[left:mid+1][::-1])
-    max_sum_of_right = max_sum_from_start(array[mid+1: right+1])
+    max_sum_of_left = max_sum_from_start(array[left : mid + 1][::-1])
+    max_sum_of_right = max_sum_from_start(array[mid + 1 : right + 1])
     return max_sum_of_left + max_sum_of_right
 
 
@@ -60,7 +60,7 @@ def max_subarray_sum(array, left, right):
     # base case: array has only one element
     if left == right:
         return array[right]
-    
+
     # Recursion
     mid = (left + right) // 2
     left_half_sum = max_subarray_sum(array, left, mid)
@@ -71,5 +71,6 @@ def max_subarray_sum(array, left, right):
 
 array = [-2, -5, 6, -2, -3, 1, 5, -6]
 array_length = len(array)
-print("Maximum sum of contiguous subarray:", max_subarray_sum(array, 0, array_length - 1))
-
+print(
+    "Maximum sum of contiguous subarray:", max_subarray_sum(array, 0, array_length - 1)
+)
diff --git a/dynamic_programming/bitmask.py b/dynamic_programming/bitmask.py
index 6685e1c68ee6..5c1ed36cb42a 100644
--- a/dynamic_programming/bitmask.py
+++ b/dynamic_programming/bitmask.py
@@ -13,54 +13,55 @@
 
 
 class AssignmentUsingBitmask:
-    def __init__(self,task_performed,total):
+    def __init__(self, task_performed, total):
 
-        self.total_tasks = total    #total no of tasks (N)
+        self.total_tasks = total  # total no of tasks (N)
 
         # DP table will have a dimension of (2^M)*N
         # initially all values are set to -1
-        self.dp = [[-1 for i in range(total+1)] for j in range(2**len(task_performed))]
+        self.dp = [
+            [-1 for i in range(total + 1)] for j in range(2 ** len(task_performed))
+        ]
 
-        self.task = defaultdict(list)   #stores the list of persons for each task
+        self.task = defaultdict(list)  # stores the list of persons for each task
 
-        #finalmask is used to check if all persons are included by setting all bits to 1
-        self.finalmask = (1<<len(task_performed)) - 1
+        # finalmask is used to check if all persons are included by setting all bits to 1
+        self.finalmask = (1 << len(task_performed)) - 1
 
-
-    def CountWaysUtil(self,mask,taskno):
+    def CountWaysUtil(self, mask, taskno):
 
         # if mask == self.finalmask all persons are distributed tasks, return 1
         if mask == self.finalmask:
             return 1
 
-        #if not everyone gets the task and no more tasks are available, return 0
+        # if not everyone gets the task and no more tasks are available, return 0
         if taskno > self.total_tasks:
             return 0
 
-        #if case already considered
-        if self.dp[mask][taskno]!=-1:
+        # if case already considered
+        if self.dp[mask][taskno] != -1:
             return self.dp[mask][taskno]
 
         # Number of ways when we dont this task in the arrangement
-        total_ways_util = self.CountWaysUtil(mask,taskno+1)
+        total_ways_util = self.CountWaysUtil(mask, taskno + 1)
 
         # now assign the tasks one by one to all possible persons and recursively assign for the remaining tasks.
         if taskno in self.task:
             for p in self.task[taskno]:
 
                 # if p is already given a task
-                if mask & (1<<p):
+                if mask & (1 << p):
                     continue
 
                 # assign this task to p and change the mask value. And recursively assign tasks with the new mask value.
-                total_ways_util+=self.CountWaysUtil(mask|(1<<p),taskno+1)
+                total_ways_util += self.CountWaysUtil(mask | (1 << p), taskno + 1)
 
         # save the value.
         self.dp[mask][taskno] = total_ways_util
 
         return self.dp[mask][taskno]
 
-    def countNoOfWays(self,task_performed):
+    def countNoOfWays(self, task_performed):
 
         # Store the list of persons for each task
         for i in range(len(task_performed)):
@@ -68,22 +69,22 @@ def countNoOfWays(self,task_performed):
                 self.task[j].append(i)
 
         # call the function to fill the DP table, final answer is stored in dp[0][1]
-        return self.CountWaysUtil(0,1)
+        return self.CountWaysUtil(0, 1)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
 
-    total_tasks = 5    #total no of tasks (the value of N)
+    total_tasks = 5  # total no of tasks (the value of N)
 
-    #the list of tasks that can be done by M persons.
-    task_performed = [
-        [ 1 , 3 , 4 ],
-        [ 1 , 2 , 5 ],
-        [ 3 , 4 ]
-         ]
-    print(AssignmentUsingBitmask(task_performed,total_tasks).countNoOfWays(task_performed))
+    # the list of tasks that can be done by M persons.
+    task_performed = [[1, 3, 4], [1, 2, 5], [3, 4]]
+    print(
+        AssignmentUsingBitmask(task_performed, total_tasks).countNoOfWays(
+            task_performed
+        )
+    )
     """
     For the particular example the tasks can be distributed as
     (1,2,3), (1,2,4), (1,5,3), (1,5,4), (3,1,4), (3,2,4), (3,5,4), (4,1,3), (4,2,3), (4,5,3)
     total 10
-    """
\ No newline at end of file
+    """
diff --git a/dynamic_programming/coin_change.py b/dynamic_programming/coin_change.py
index 61deccd124e6..a85d8e08dbb1 100644
--- a/dynamic_programming/coin_change.py
+++ b/dynamic_programming/coin_change.py
@@ -5,6 +5,8 @@
 the given types of coins?
 https://www.hackerrank.com/challenges/coin-change/problem
 """
+
+
 def dp_count(S, m, n):
 
     # table[i] represents the number of ways to get to amount i
@@ -23,6 +25,6 @@ def dp_count(S, m, n):
     return table[n]
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     print(dp_count([1, 2, 3], 3, 4))  # answer 4
     print(dp_count([2, 5, 3, 6], 4, 10))  # answer 5
diff --git a/dynamic_programming/edit_distance.py b/dynamic_programming/edit_distance.py
index 585c762ad017..9df00eae96d7 100644
--- a/dynamic_programming/edit_distance.py
+++ b/dynamic_programming/edit_distance.py
@@ -19,37 +19,41 @@ class EditDistance:
     def __init__(self):
         self.__prepare__()
 
-    def __prepare__(self, N = 0, M = 0):
-        self.dp = [[-1 for y in range(0,M)] for x in range(0,N)]
+    def __prepare__(self, N=0, M=0):
+        self.dp = [[-1 for y in range(0, M)] for x in range(0, N)]
 
     def __solveDP(self, x, y):
-        if (x==-1):
-            return y+1
-        elif (y==-1):
-            return x+1
-        elif (self.dp[x][y]>-1):
+        if x == -1:
+            return y + 1
+        elif y == -1:
+            return x + 1
+        elif self.dp[x][y] > -1:
             return self.dp[x][y]
         else:
-            if (self.A[x]==self.B[y]):
-                self.dp[x][y] = self.__solveDP(x-1,y-1)
+            if self.A[x] == self.B[y]:
+                self.dp[x][y] = self.__solveDP(x - 1, y - 1)
             else:
-                self.dp[x][y] = 1+min(self.__solveDP(x,y-1), self.__solveDP(x-1,y), self.__solveDP(x-1,y-1))
+                self.dp[x][y] = 1 + min(
+                    self.__solveDP(x, y - 1),
+                    self.__solveDP(x - 1, y),
+                    self.__solveDP(x - 1, y - 1),
+                )
 
             return self.dp[x][y]
 
     def solve(self, A, B):
-        if isinstance(A,bytes):
-            A = A.decode('ascii')
+        if isinstance(A, bytes):
+            A = A.decode("ascii")
 
-        if isinstance(B,bytes):
-            B = B.decode('ascii')
+        if isinstance(B, bytes):
+            B = B.decode("ascii")
 
         self.A = str(A)
         self.B = str(B)
 
         self.__prepare__(len(A), len(B))
 
-        return self.__solveDP(len(A)-1, len(B)-1)
+        return self.__solveDP(len(A) - 1, len(B) - 1)
 
 
 def min_distance_bottom_up(word1: str, word2: str) -> int:
@@ -63,38 +67,37 @@ def min_distance_bottom_up(word1: str, word2: str) -> int:
     """
     m = len(word1)
     n = len(word2)
-    dp = [[0 for _ in range(n+1) ] for _ in range(m+1)]
-    for i in range(m+1):
-        for j in range(n+1):
+    dp = [[0 for _ in range(n + 1)] for _ in range(m + 1)]
+    for i in range(m + 1):
+        for j in range(n + 1):
 
-            if i == 0:  #first string is empty
+            if i == 0:  # first string is empty
                 dp[i][j] = j
-            elif j == 0: #second string is empty
+            elif j == 0:  # second string is empty
                 dp[i][j] = i
-            elif word1[i-1] == word2[j-1]: #last character of both substing is equal
-                dp[i][j] = dp[i-1][j-1]
+            elif (
+                word1[i - 1] == word2[j - 1]
+            ):  # last character of both substing is equal
+                dp[i][j] = dp[i - 1][j - 1]
             else:
-                insert = dp[i][j-1]
-                delete = dp[i-1][j]
-                replace = dp[i-1][j-1]
+                insert = dp[i][j - 1]
+                delete = dp[i - 1][j]
+                replace = dp[i - 1][j - 1]
                 dp[i][j] = 1 + min(insert, delete, replace)
     return dp[m][n]
 
-if __name__ == '__main__':
-        solver = EditDistance()
-
-        print("****************** Testing Edit Distance DP Algorithm ******************")
-        print()
-
-        S1 = input("Enter the first string: ").strip()
-        S2 = input("Enter the second string: ").strip()
-
-        print()
-        print("The minimum Edit Distance is: %d" % (solver.solve(S1, S2)))
-        print("The minimum Edit Distance is: %d" % (min_distance_bottom_up(S1, S2)))
-        print()
-        print("*************** End of Testing Edit Distance DP Algorithm ***************")
 
+if __name__ == "__main__":
+    solver = EditDistance()
 
+    print("****************** Testing Edit Distance DP Algorithm ******************")
+    print()
 
+    S1 = input("Enter the first string: ").strip()
+    S2 = input("Enter the second string: ").strip()
 
+    print()
+    print("The minimum Edit Distance is: %d" % (solver.solve(S1, S2)))
+    print("The minimum Edit Distance is: %d" % (min_distance_bottom_up(S1, S2)))
+    print()
+    print("*************** End of Testing Edit Distance DP Algorithm ***************")
diff --git a/dynamic_programming/factorial.py b/dynamic_programming/factorial.py
index 7c6541ee2a74..0269014e7a18 100644
--- a/dynamic_programming/factorial.py
+++ b/dynamic_programming/factorial.py
@@ -1,6 +1,8 @@
-#Factorial of a number using memoization
-result=[-1]*10
-result[0]=result[1]=1
+# Factorial of a number using memoization
+result = [-1] * 10
+result[0] = result[1] = 1
+
+
 def factorial(num):
     """
     >>> factorial(7)
@@ -10,19 +12,20 @@ def factorial(num):
     >>> [factorial(i) for i in range(5)]
     [1, 1, 2, 6, 24]
     """
-    
-    if num<0:
+
+    if num < 0:
         return "Number should not be negative."
-    if result[num]!=-1:
+    if result[num] != -1:
         return result[num]
     else:
-        result[num]=num*factorial(num-1)
-        #uncomment the following to see how recalculations are avoided
-        #print(result)
+        result[num] = num * factorial(num - 1)
+        # uncomment the following to see how recalculations are avoided
+        # print(result)
         return result[num]
 
-#factorial of num
-#uncomment the following to see how recalculations are avoided
+
+# factorial of num
+# uncomment the following to see how recalculations are avoided
 ##result=[-1]*10
 ##result[0]=result[1]=1
 ##print(factorial(5))
@@ -31,4 +34,5 @@ def factorial(num):
 
 if __name__ == "__main__":
     import doctest
+
     doctest.testmod()
diff --git a/dynamic_programming/fibonacci.py b/dynamic_programming/fibonacci.py
index 90fe6386044a..2dd1c2555f3e 100644
--- a/dynamic_programming/fibonacci.py
+++ b/dynamic_programming/fibonacci.py
@@ -4,7 +4,6 @@
 
 
 class Fibonacci:
-
     def __init__(self, N=None):
         self.fib_array = []
         if N:
@@ -19,14 +18,14 @@ def __init__(self, N=None):
     def get(self, sequence_no=None):
         if sequence_no != None:
             if sequence_no < len(self.fib_array):
-                return print(self.fib_array[:sequence_no + 1])
+                return print(self.fib_array[: sequence_no + 1])
             else:
                 print("Out of bound.")
         else:
             print("Please specify a value")
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     print("\n********* Fibonacci Series Using Dynamic Programming ************\n")
     print("\n Enter the upper limit for the fibonacci sequence: ", end="")
     try:
@@ -34,7 +33,8 @@ def get(self, sequence_no=None):
         fib = Fibonacci(N)
         print(
             "\n********* Enter different values to get the corresponding fibonacci "
-            "sequence, enter any negative number to exit. ************\n")
+            "sequence, enter any negative number to exit. ************\n"
+        )
         while True:
             try:
                 i = int(input("Enter value: ").strip())
diff --git a/dynamic_programming/floyd_warshall.py b/dynamic_programming/floyd_warshall.py
index 038499ca03b6..a4b6c6a82568 100644
--- a/dynamic_programming/floyd_warshall.py
+++ b/dynamic_programming/floyd_warshall.py
@@ -1,37 +1,42 @@
 import math
 
+
 class Graph:
-    
-    def __init__(self, N = 0): # a graph with Node 0,1,...,N-1
+    def __init__(self, N=0):  # a graph with Node 0,1,...,N-1
         self.N = N
-        self.W = [[math.inf for j in range(0,N)] for i in range(0,N)] # adjacency matrix for weight
-        self.dp = [[math.inf for j in range(0,N)] for i in range(0,N)] # dp[i][j] stores minimum distance from i to j
+        self.W = [
+            [math.inf for j in range(0, N)] for i in range(0, N)
+        ]  # adjacency matrix for weight
+        self.dp = [
+            [math.inf for j in range(0, N)] for i in range(0, N)
+        ]  # dp[i][j] stores minimum distance from i to j
 
     def addEdge(self, u, v, w):
         self.dp[u][v] = w
 
     def floyd_warshall(self):
-        for k in range(0,self.N):
-            for i in range(0,self.N):
-                for j in range(0,self.N):
+        for k in range(0, self.N):
+            for i in range(0, self.N):
+                for j in range(0, self.N):
                     self.dp[i][j] = min(self.dp[i][j], self.dp[i][k] + self.dp[k][j])
 
     def showMin(self, u, v):
         return self.dp[u][v]
-    
-if __name__ == '__main__':
+
+
+if __name__ == "__main__":
     graph = Graph(5)
-    graph.addEdge(0,2,9)
-    graph.addEdge(0,4,10)
-    graph.addEdge(1,3,5)
-    graph.addEdge(2,3,7)
-    graph.addEdge(3,0,10)
-    graph.addEdge(3,1,2)
-    graph.addEdge(3,2,1)
-    graph.addEdge(3,4,6)
-    graph.addEdge(4,1,3)
-    graph.addEdge(4,2,4)
-    graph.addEdge(4,3,9)
+    graph.addEdge(0, 2, 9)
+    graph.addEdge(0, 4, 10)
+    graph.addEdge(1, 3, 5)
+    graph.addEdge(2, 3, 7)
+    graph.addEdge(3, 0, 10)
+    graph.addEdge(3, 1, 2)
+    graph.addEdge(3, 2, 1)
+    graph.addEdge(3, 4, 6)
+    graph.addEdge(4, 1, 3)
+    graph.addEdge(4, 2, 4)
+    graph.addEdge(4, 3, 9)
     graph.floyd_warshall()
-    graph.showMin(1,4)
-    graph.showMin(0,3)
+    graph.showMin(1, 4)
+    graph.showMin(0, 3)
diff --git a/dynamic_programming/fractional_knapsack.py b/dynamic_programming/fractional_knapsack.py
index 74e85b4b4708..881b6a3969d0 100644
--- a/dynamic_programming/fractional_knapsack.py
+++ b/dynamic_programming/fractional_knapsack.py
@@ -1,12 +1,20 @@
 from itertools import accumulate
 from bisect import bisect
 
+
 def fracKnapsack(vl, wt, W, n):
 
-    r = list(sorted(zip(vl,wt), key=lambda x:x[0]/x[1],reverse=True))
-    vl , wt = [i[0] for i in r],[i[1] for i in r]
-    acc=list(accumulate(wt))
-    k = bisect(acc,W)
-    return 0 if k == 0 else sum(vl[:k])+(W-acc[k-1])*(vl[k])/(wt[k]) if k!=n else sum(vl[:k])
+    r = list(sorted(zip(vl, wt), key=lambda x: x[0] / x[1], reverse=True))
+    vl, wt = [i[0] for i in r], [i[1] for i in r]
+    acc = list(accumulate(wt))
+    k = bisect(acc, W)
+    return (
+        0
+        if k == 0
+        else sum(vl[:k]) + (W - acc[k - 1]) * (vl[k]) / (wt[k])
+        if k != n
+        else sum(vl[:k])
+    )
+
 
-print("%.0f"%fracKnapsack([60, 100, 120],[10, 20, 30],50,3))
+print("%.0f" % fracKnapsack([60, 100, 120], [10, 20, 30], 50, 3))
diff --git a/dynamic_programming/integer_partition.py b/dynamic_programming/integer_partition.py
index f17561fc135b..ec8c5bf62d7d 100644
--- a/dynamic_programming/integer_partition.py
+++ b/dynamic_programming/integer_partition.py
@@ -1,33 +1,36 @@
-'''
+"""
 The number of partitions of a number n into at least k parts equals the number of partitions into exactly k parts
 plus the number of partitions into at least k-1 parts. Subtracting 1 from each part of a partition of n into k parts
 gives a partition of n-k into k parts. These two facts together are used for this algorithm.
-'''
+"""
+
+
 def partition(m):
-	memo = [[0 for _ in range(m)] for _ in range(m+1)]
-	for i in range(m+1):
-		memo[i][0] = 1
+    memo = [[0 for _ in range(m)] for _ in range(m + 1)]
+    for i in range(m + 1):
+        memo[i][0] = 1
+
+    for n in range(m + 1):
+        for k in range(1, m):
+            memo[n][k] += memo[n][k - 1]
+            if n - k > 0:
+                memo[n][k] += memo[n - k - 1][k]
 
-	for n in range(m+1):
-		for k in range(1, m):
-			memo[n][k] += memo[n][k-1]
-			if n-k > 0:
-				memo[n][k] += memo[n-k-1][k]
+    return memo[m][m - 1]
 
-	return memo[m][m-1]
 
-if __name__ == '__main__':
-	import sys
+if __name__ == "__main__":
+    import sys
 
-	if len(sys.argv) == 1:
-		try:
-			n = int(input('Enter a number: ').strip())
-			print(partition(n))
-		except ValueError:
-			print('Please enter a number.')
-	else:
-		try:
-			n = int(sys.argv[1])
-			print(partition(n))
-		except ValueError:
-			print('Please pass a number.')
\ No newline at end of file
+    if len(sys.argv) == 1:
+        try:
+            n = int(input("Enter a number: ").strip())
+            print(partition(n))
+        except ValueError:
+            print("Please enter a number.")
+    else:
+        try:
+            n = int(sys.argv[1])
+            print(partition(n))
+        except ValueError:
+            print("Please pass a number.")
diff --git a/dynamic_programming/k_means_clustering_tensorflow.py b/dynamic_programming/k_means_clustering_tensorflow.py
index b6813c6a22b3..6b1eb628e5c3 100644
--- a/dynamic_programming/k_means_clustering_tensorflow.py
+++ b/dynamic_programming/k_means_clustering_tensorflow.py
@@ -14,24 +14,24 @@ def TFKMeansCluster(vectors, noofclusters):
     noofclusters = int(noofclusters)
     assert noofclusters < len(vectors)
 
-    #Find out the dimensionality
+    # Find out the dimensionality
     dim = len(vectors[0])
 
-    #Will help select random centroids from among the available vectors
+    # Will help select random centroids from among the available vectors
     vector_indices = list(range(len(vectors)))
     shuffle(vector_indices)
 
-    #GRAPH OF COMPUTATION
-    #We initialize a new graph and set it as the default during each run
-    #of this algorithm. This ensures that as this function is called
-    #multiple times, the default graph doesn't keep getting crowded with
-    #unused ops and Variables from previous function calls.
+    # GRAPH OF COMPUTATION
+    # We initialize a new graph and set it as the default during each run
+    # of this algorithm. This ensures that as this function is called
+    # multiple times, the default graph doesn't keep getting crowded with
+    # unused ops and Variables from previous function calls.
 
     graph = tf.Graph()
 
     with graph.as_default():
 
-        #SESSION OF COMPUTATION
+        # SESSION OF COMPUTATION
 
         sess = tf.Session()
 
@@ -39,8 +39,9 @@ def TFKMeansCluster(vectors, noofclusters):
 
         ##First lets ensure we have a Variable vector for each centroid,
         ##initialized to one of the vectors from the available data points
-        centroids = [tf.Variable((vectors[vector_indices[i]]))
-                     for i in range(noofclusters)]
+        centroids = [
+            tf.Variable((vectors[vector_indices[i]])) for i in range(noofclusters)
+        ]
         ##These nodes will assign the centroid Variables the appropriate
         ##values
         centroid_value = tf.placeholder("float64", [dim])
@@ -56,26 +57,24 @@ def TFKMeansCluster(vectors, noofclusters):
         assignment_value = tf.placeholder("int32")
         cluster_assigns = []
         for assignment in assignments:
-            cluster_assigns.append(tf.assign(assignment,
-                                             assignment_value))
+            cluster_assigns.append(tf.assign(assignment, assignment_value))
 
         ##Now lets construct the node that will compute the mean
-        #The placeholder for the input
+        # The placeholder for the input
         mean_input = tf.placeholder("float", [None, dim])
-        #The Node/op takes the input and computes a mean along the 0th
-        #dimension, i.e. the list of input vectors
+        # The Node/op takes the input and computes a mean along the 0th
+        # dimension, i.e. the list of input vectors
         mean_op = tf.reduce_mean(mean_input, 0)
 
         ##Node for computing Euclidean distances
-        #Placeholders for input
+        # Placeholders for input
         v1 = tf.placeholder("float", [dim])
         v2 = tf.placeholder("float", [dim])
-        euclid_dist = tf.sqrt(tf.reduce_sum(tf.pow(tf.sub(
-            v1, v2), 2)))
+        euclid_dist = tf.sqrt(tf.reduce_sum(tf.pow(tf.sub(v1, v2), 2)))
 
         ##This node will figure out which cluster to assign a vector to,
         ##based on Euclidean distances of the vector from the centroids.
-        #Placeholder for input
+        # Placeholder for input
         centroid_distances = tf.placeholder("float", [noofclusters])
         cluster_assignment = tf.argmin(centroid_distances, 0)
 
@@ -87,55 +86,62 @@ def TFKMeansCluster(vectors, noofclusters):
         ##will be included in the initialization.
         init_op = tf.initialize_all_variables()
 
-        #Initialize all variables
+        # Initialize all variables
         sess.run(init_op)
 
         ##CLUSTERING ITERATIONS
 
-        #Now perform the Expectation-Maximization steps of K-Means clustering
-        #iterations. To keep things simple, we will only do a set number of
-        #iterations, instead of using a Stopping Criterion.
+        # Now perform the Expectation-Maximization steps of K-Means clustering
+        # iterations. To keep things simple, we will only do a set number of
+        # iterations, instead of using a Stopping Criterion.
         noofiterations = 100
         for iteration_n in range(noofiterations):
 
             ##EXPECTATION STEP
             ##Based on the centroid locations till last iteration, compute
             ##the _expected_ centroid assignments.
-            #Iterate over each vector
+            # Iterate over each vector
             for vector_n in range(len(vectors)):
                 vect = vectors[vector_n]
-                #Compute Euclidean distance between this vector and each
-                #centroid. Remember that this list cannot be named
+                # Compute Euclidean distance between this vector and each
+                # centroid. Remember that this list cannot be named
                 #'centroid_distances', since that is the input to the
-                #cluster assignment node.
-                distances = [sess.run(euclid_dist, feed_dict={
-                    v1: vect, v2: sess.run(centroid)})
-                             for centroid in centroids]
-                #Now use the cluster assignment node, with the distances
-                #as the input
-                assignment = sess.run(cluster_assignment, feed_dict = {
-                    centroid_distances: distances})
-                #Now assign the value to the appropriate state variable
-                sess.run(cluster_assigns[vector_n], feed_dict={
-                    assignment_value: assignment})
+                # cluster assignment node.
+                distances = [
+                    sess.run(euclid_dist, feed_dict={v1: vect, v2: sess.run(centroid)})
+                    for centroid in centroids
+                ]
+                # Now use the cluster assignment node, with the distances
+                # as the input
+                assignment = sess.run(
+                    cluster_assignment, feed_dict={centroid_distances: distances}
+                )
+                # Now assign the value to the appropriate state variable
+                sess.run(
+                    cluster_assigns[vector_n], feed_dict={assignment_value: assignment}
+                )
 
             ##MAXIMIZATION STEP
-            #Based on the expected state computed from the Expectation Step,
-            #compute the locations of the centroids so as to maximize the
-            #overall objective of minimizing within-cluster Sum-of-Squares
+            # Based on the expected state computed from the Expectation Step,
+            # compute the locations of the centroids so as to maximize the
+            # overall objective of minimizing within-cluster Sum-of-Squares
             for cluster_n in range(noofclusters):
-                #Collect all the vectors assigned to this cluster
-                assigned_vects = [vectors[i] for i in range(len(vectors))
-                                  if sess.run(assignments[i]) == cluster_n]
-                #Compute new centroid location
-                new_location = sess.run(mean_op, feed_dict={
-                    mean_input: array(assigned_vects)})
-                #Assign value to appropriate variable
-                sess.run(cent_assigns[cluster_n], feed_dict={
-                    centroid_value: new_location})
-
-        #Return centroids and assignments
+                # Collect all the vectors assigned to this cluster
+                assigned_vects = [
+                    vectors[i]
+                    for i in range(len(vectors))
+                    if sess.run(assignments[i]) == cluster_n
+                ]
+                # Compute new centroid location
+                new_location = sess.run(
+                    mean_op, feed_dict={mean_input: array(assigned_vects)}
+                )
+                # Assign value to appropriate variable
+                sess.run(
+                    cent_assigns[cluster_n], feed_dict={centroid_value: new_location}
+                )
+
+        # Return centroids and assignments
         centroids = sess.run(centroids)
         assignments = sess.run(assignments)
         return centroids, assignments
-
diff --git a/dynamic_programming/knapsack.py b/dynamic_programming/knapsack.py
index 488059d6244d..e71e3892e8cc 100644
--- a/dynamic_programming/knapsack.py
+++ b/dynamic_programming/knapsack.py
@@ -8,36 +8,38 @@
 
 
 def MF_knapsack(i, wt, val, j):
-    '''
+    """
     This code involves the concept of memory functions. Here we solve the subproblems which are needed
     unlike the below example
     F is a 2D array with -1s filled up
-    '''
+    """
     global F  # a global dp table for knapsack
     if F[i][j] < 0:
-        if j < wt[i-1]:
-            val = MF_knapsack(i-1, wt, val, j)
+        if j < wt[i - 1]:
+            val = MF_knapsack(i - 1, wt, val, j)
         else:
-            val = max(MF_knapsack(i-1, wt, val, j),
-                      MF_knapsack(i-1, wt, val, j - wt[i-1]) + val[i-1])
+            val = max(
+                MF_knapsack(i - 1, wt, val, j),
+                MF_knapsack(i - 1, wt, val, j - wt[i - 1]) + val[i - 1],
+            )
         F[i][j] = val
     return F[i][j]
 
 
 def knapsack(W, wt, val, n):
-    dp = [[0 for i in range(W+1)]for j in range(n+1)]
+    dp = [[0 for i in range(W + 1)] for j in range(n + 1)]
 
-    for i in range(1,n+1):
-        for w in range(1, W+1):
-            if wt[i-1] <= w:
-                dp[i][w] = max(val[i-1] + dp[i-1][w-wt[i-1]], dp[i-1][w])
+    for i in range(1, n + 1):
+        for w in range(1, W + 1):
+            if wt[i - 1] <= w:
+                dp[i][w] = max(val[i - 1] + dp[i - 1][w - wt[i - 1]], dp[i - 1][w])
             else:
-                dp[i][w] = dp[i-1][w]
+                dp[i][w] = dp[i - 1][w]
 
     return dp[n][W], dp
 
 
-def knapsack_with_example_solution(W: int, wt: list, val:list):
+def knapsack_with_example_solution(W: int, wt: list, val: list):
     """
     Solves the integer weights knapsack problem returns one of
     the several possible optimal subsets.
@@ -70,17 +72,23 @@ def knapsack_with_example_solution(W: int, wt: list, val:list):
     But got 4 weights and 3 values
     """
     if not (isinstance(wt, (list, tuple)) and isinstance(val, (list, tuple))):
-        raise ValueError("Both the weights and values vectors must be either lists or tuples")
+        raise ValueError(
+            "Both the weights and values vectors must be either lists or tuples"
+        )
 
     num_items = len(wt)
     if num_items != len(val):
-        raise ValueError("The number of weights must be the "
-                         "same as the number of values.\nBut "
-                         "got {} weights and {} values".format(num_items, len(val)))
+        raise ValueError(
+            "The number of weights must be the "
+            "same as the number of values.\nBut "
+            "got {} weights and {} values".format(num_items, len(val))
+        )
     for i in range(num_items):
         if not isinstance(wt[i], int):
-            raise TypeError("All weights must be integers but "
-                            "got weight of type {} at index {}".format(type(wt[i]), i))
+            raise TypeError(
+                "All weights must be integers but "
+                "got weight of type {} at index {}".format(type(wt[i]), i)
+            )
 
     optimal_val, dp_table = knapsack(W, wt, val, num_items)
     example_optional_set = set()
@@ -89,7 +97,7 @@ def knapsack_with_example_solution(W: int, wt: list, val:list):
     return optimal_val, example_optional_set
 
 
-def _construct_solution(dp:list, wt:list, i:int, j:int, optimal_set:set):
+def _construct_solution(dp: list, wt: list, i: int, j: int, optimal_set: set):
     """
     Recursively reconstructs one of the optimal subsets given
     a filled DP table and the vector of weights
@@ -117,21 +125,21 @@ def _construct_solution(dp:list, wt:list, i:int, j:int, optimal_set:set):
             _construct_solution(dp, wt, i - 1, j, optimal_set)
         else:
             optimal_set.add(i)
-            _construct_solution(dp, wt, i - 1, j - wt[i-1], optimal_set)
+            _construct_solution(dp, wt, i - 1, j - wt[i - 1], optimal_set)
 
 
-if __name__ == '__main__':
-    '''
+if __name__ == "__main__":
+    """
     Adding test case for knapsack
-    '''
+    """
     val = [3, 2, 4, 4]
     wt = [4, 3, 2, 3]
     n = 4
     w = 6
     F = [[0] * (w + 1)] + [[0] + [-1 for i in range(w + 1)] for j in range(n + 1)]
-    optimal_solution, _ = knapsack(w,wt,val, n)
+    optimal_solution, _ = knapsack(w, wt, val, n)
     print(optimal_solution)
-    print(MF_knapsack(n,wt,val,w))  # switched the n and w
+    print(MF_knapsack(n, wt, val, w))  # switched the n and w
 
     # testing the dynamic programming problem with example
     # the optimal subset for the above example are items 3 and 4
@@ -140,4 +148,3 @@ def _construct_solution(dp:list, wt:list, i:int, j:int, optimal_set:set):
     assert optimal_subset == {3, 4}
     print("optimal_value = ", optimal_solution)
     print("An optimal subset corresponding to the optimal value", optimal_subset)
-
diff --git a/dynamic_programming/longest_common_subsequence.py b/dynamic_programming/longest_common_subsequence.py
index d39485408988..12fcae684051 100644
--- a/dynamic_programming/longest_common_subsequence.py
+++ b/dynamic_programming/longest_common_subsequence.py
@@ -41,12 +41,12 @@ def longest_common_subsequence(x: str, y: str):
 
     for i in range(1, m + 1):
         for j in range(1, n + 1):
-            if x[i-1] == y[j-1]:
+            if x[i - 1] == y[j - 1]:
                 match = 1
             else:
                 match = 0
 
-            L[i][j] = max(L[i-1][j], L[i][j-1], L[i-1][j-1] + match)
+            L[i][j] = max(L[i - 1][j], L[i][j - 1], L[i - 1][j - 1] + match)
 
     seq = ""
     i, j = m, n
@@ -69,9 +69,9 @@ def longest_common_subsequence(x: str, y: str):
     return L[m][n], seq
 
 
-if __name__ == '__main__':
-    a = 'AGGTAB'
-    b = 'GXTXAYB'
+if __name__ == "__main__":
+    a = "AGGTAB"
+    b = "GXTXAYB"
     expected_ln = 4
     expected_subseq = "GTAB"
 
diff --git a/dynamic_programming/longest_increasing_subsequence.py b/dynamic_programming/longest_increasing_subsequence.py
index 151a5e0b7c80..3cb57806e06f 100644
--- a/dynamic_programming/longest_increasing_subsequence.py
+++ b/dynamic_programming/longest_increasing_subsequence.py
@@ -1,4 +1,4 @@
-'''
+"""
 Author  : Mehdi ALAOUI
 
 This is a pure Python implementation of Dynamic Programming solution to the longest increasing subsequence of a given sequence.
@@ -6,35 +6,40 @@
 The problem is  :
 Given an ARRAY, to find the longest and increasing sub ARRAY in that given ARRAY and return it.
 Example: [10, 22, 9, 33, 21, 50, 41, 60, 80] as input will return [10, 22, 33, 41, 60, 80] as output
-'''
-def longestSub(ARRAY): 			#This function is recursive
-
-	ARRAY_LENGTH = len(ARRAY)
-	if(ARRAY_LENGTH <= 1):  	#If the array contains only one element, we return it (it's the stop condition of recursion)
-		return ARRAY
-								#Else
-	PIVOT=ARRAY[0]
-	isFound=False
-	i=1
-	LONGEST_SUB=[]
-	while(not isFound and i<ARRAY_LENGTH):
-		if (ARRAY[i] < PIVOT):
-			isFound=True
-			TEMPORARY_ARRAY = [ element for element in ARRAY[i:] if element >= ARRAY[i] ]
-			TEMPORARY_ARRAY = longestSub(TEMPORARY_ARRAY)
-			if ( len(TEMPORARY_ARRAY) > len(LONGEST_SUB) ):
-				LONGEST_SUB = TEMPORARY_ARRAY
-		else:
-			i+=1
-
-	TEMPORARY_ARRAY = [ element for element in ARRAY[1:] if element >= PIVOT ]
-	TEMPORARY_ARRAY = [PIVOT] + longestSub(TEMPORARY_ARRAY)
-	if ( len(TEMPORARY_ARRAY) > len(LONGEST_SUB) ):
-		return TEMPORARY_ARRAY
-	else:
-		return LONGEST_SUB
-
-#Some examples
-
-print(longestSub([4,8,7,5,1,12,2,3,9]))
-print(longestSub([9,8,7,6,5,7]))
\ No newline at end of file
+"""
+
+
+def longestSub(ARRAY):  # This function is recursive
+
+    ARRAY_LENGTH = len(ARRAY)
+    if (
+        ARRAY_LENGTH <= 1
+    ):  # If the array contains only one element, we return it (it's the stop condition of recursion)
+        return ARRAY
+        # Else
+    PIVOT = ARRAY[0]
+    isFound = False
+    i = 1
+    LONGEST_SUB = []
+    while not isFound and i < ARRAY_LENGTH:
+        if ARRAY[i] < PIVOT:
+            isFound = True
+            TEMPORARY_ARRAY = [element for element in ARRAY[i:] if element >= ARRAY[i]]
+            TEMPORARY_ARRAY = longestSub(TEMPORARY_ARRAY)
+            if len(TEMPORARY_ARRAY) > len(LONGEST_SUB):
+                LONGEST_SUB = TEMPORARY_ARRAY
+        else:
+            i += 1
+
+    TEMPORARY_ARRAY = [element for element in ARRAY[1:] if element >= PIVOT]
+    TEMPORARY_ARRAY = [PIVOT] + longestSub(TEMPORARY_ARRAY)
+    if len(TEMPORARY_ARRAY) > len(LONGEST_SUB):
+        return TEMPORARY_ARRAY
+    else:
+        return LONGEST_SUB
+
+
+# Some examples
+
+print(longestSub([4, 8, 7, 5, 1, 12, 2, 3, 9]))
+print(longestSub([9, 8, 7, 6, 5, 7]))
diff --git a/dynamic_programming/longest_increasing_subsequence_o(nlogn).py b/dynamic_programming/longest_increasing_subsequence_o(nlogn).py
index 9b27ed6be303..f7b2c6915bcb 100644
--- a/dynamic_programming/longest_increasing_subsequence_o(nlogn).py
+++ b/dynamic_programming/longest_increasing_subsequence_o(nlogn).py
@@ -4,38 +4,38 @@
 # comments: This programme outputs the Longest Strictly Increasing Subsequence in O(NLogN)
 #           Where N is the Number of elements in the list
 #############################
-def CeilIndex(v,l,r,key):
-	while r-l > 1:
-		m = (l + r)/2
-		if v[m] >= key:
-			r = m
-		else:
-			l = m
+def CeilIndex(v, l, r, key):
+    while r - l > 1:
+        m = (l + r) / 2
+        if v[m] >= key:
+            r = m
+        else:
+            l = m
 
-	return r
+    return r
 
 
 def LongestIncreasingSubsequenceLength(v):
-	if(len(v) == 0):
-		return 0
+    if len(v) == 0:
+        return 0
 
-	tail = [0]*len(v)
-	length = 1
+    tail = [0] * len(v)
+    length = 1
 
-	tail[0] = v[0]
+    tail[0] = v[0]
 
-	for i in range(1,len(v)):
-		if v[i] < tail[0]:
-			tail[0] = v[i]
-		elif v[i] > tail[length-1]:
-			tail[length] = v[i]
-			length += 1
-		else:
-			tail[CeilIndex(tail,-1,length-1,v[i])] = v[i]
+    for i in range(1, len(v)):
+        if v[i] < tail[0]:
+            tail[0] = v[i]
+        elif v[i] > tail[length - 1]:
+            tail[length] = v[i]
+            length += 1
+        else:
+            tail[CeilIndex(tail, -1, length - 1, v[i])] = v[i]
 
-	return length
+    return length
 
 
 if __name__ == "__main__":
-	v = [2, 5, 3, 7, 11, 8, 10, 13, 6]
-	print(LongestIncreasingSubsequenceLength(v))
+    v = [2, 5, 3, 7, 11, 8, 10, 13, 6]
+    print(LongestIncreasingSubsequenceLength(v))
diff --git a/dynamic_programming/longest_sub_array.py b/dynamic_programming/longest_sub_array.py
index 856b31f03982..65ce151c33d6 100644
--- a/dynamic_programming/longest_sub_array.py
+++ b/dynamic_programming/longest_sub_array.py
@@ -1,32 +1,32 @@
-'''
+"""
 Auther  : Yvonne
 
 This is a pure Python implementation of Dynamic Programming solution to the longest_sub_array problem.
 
 The problem is  :
 Given an array, to find the longest and continuous sub array and get the max sum of the sub array in the given array.
-'''
+"""
 
 
 class SubArray:
-
     def __init__(self, arr):
         # we need a list not a string, so do something to change the type
-        self.array = arr.split(',')
+        self.array = arr.split(",")
         print(("the input array is:", self.array))
 
     def solve_sub_array(self):
-        rear = [int(self.array[0])]*len(self.array)
-        sum_value = [int(self.array[0])]*len(self.array)
+        rear = [int(self.array[0])] * len(self.array)
+        sum_value = [int(self.array[0])] * len(self.array)
         for i in range(1, len(self.array)):
-            sum_value[i] = max(int(self.array[i]) + sum_value[i-1], int(self.array[i]))
-            rear[i] = max(sum_value[i], rear[i-1])
-        return rear[len(self.array)-1]
+            sum_value[i] = max(
+                int(self.array[i]) + sum_value[i - 1], int(self.array[i])
+            )
+            rear[i] = max(sum_value[i], rear[i - 1])
+        return rear[len(self.array) - 1]
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     whole_array = input("please input some numbers:")
     array = SubArray(whole_array)
     re = array.solve_sub_array()
     print(("the results is:", re))
-
diff --git a/dynamic_programming/matrix_chain_order.py b/dynamic_programming/matrix_chain_order.py
index cb4aec345437..f88a9be8ac95 100644
--- a/dynamic_programming/matrix_chain_order.py
+++ b/dynamic_programming/matrix_chain_order.py
@@ -1,44 +1,54 @@
 import sys
-'''
+
+"""
 Dynamic Programming
 Implementation of Matrix Chain Multiplication
 Time Complexity: O(n^3)
 Space Complexity: O(n^2)
-'''
+"""
+
+
 def MatrixChainOrder(array):
-    N=len(array)
-    Matrix=[[0 for x in range(N)] for x in range(N)]
-    Sol=[[0 for x in range(N)] for x in range(N)]
+    N = len(array)
+    Matrix = [[0 for x in range(N)] for x in range(N)]
+    Sol = [[0 for x in range(N)] for x in range(N)]
 
-    for ChainLength in range(2,N):
-        for a in range(1,N-ChainLength+1):
-            b = a+ChainLength-1
+    for ChainLength in range(2, N):
+        for a in range(1, N - ChainLength + 1):
+            b = a + ChainLength - 1
 
             Matrix[a][b] = sys.maxsize
-            for c in range(a , b):
-                cost = Matrix[a][c] + Matrix[c+1][b] + array[a-1]*array[c]*array[b]
+            for c in range(a, b):
+                cost = (
+                    Matrix[a][c] + Matrix[c + 1][b] + array[a - 1] * array[c] * array[b]
+                )
                 if cost < Matrix[a][b]:
                     Matrix[a][b] = cost
                     Sol[a][b] = c
-    return Matrix , Sol
-#Print order of matrix with Ai as Matrix
-def PrintOptimalSolution(OptimalSolution,i,j):
-    if i==j:
-        print("A" + str(i),end = " ")
+    return Matrix, Sol
+
+
+# Print order of matrix with Ai as Matrix
+def PrintOptimalSolution(OptimalSolution, i, j):
+    if i == j:
+        print("A" + str(i), end=" ")
     else:
-        print("(",end = " ")
-        PrintOptimalSolution(OptimalSolution,i,OptimalSolution[i][j])
-        PrintOptimalSolution(OptimalSolution,OptimalSolution[i][j]+1,j)
-        print(")",end = " ")
+        print("(", end=" ")
+        PrintOptimalSolution(OptimalSolution, i, OptimalSolution[i][j])
+        PrintOptimalSolution(OptimalSolution, OptimalSolution[i][j] + 1, j)
+        print(")", end=" ")
+
 
 def main():
-    array=[30,35,15,5,10,20,25]
-    n=len(array)
-    #Size of matrix created from above array will be
+    array = [30, 35, 15, 5, 10, 20, 25]
+    n = len(array)
+    # Size of matrix created from above array will be
     # 30*35 35*15 15*5 5*10 10*20 20*25
-    Matrix , OptimalSolution = MatrixChainOrder(array)
+    Matrix, OptimalSolution = MatrixChainOrder(array)
+
+    print("No. of Operation required: " + str((Matrix[1][n - 1])))
+    PrintOptimalSolution(OptimalSolution, 1, n - 1)
+
 
-    print("No. of Operation required: "+str((Matrix[1][n-1])))
-    PrintOptimalSolution(OptimalSolution,1,n-1)
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
diff --git a/dynamic_programming/max_sub_array.py b/dynamic_programming/max_sub_array.py
index d6084ecfd6d9..eb6ab41bf52d 100644
--- a/dynamic_programming/max_sub_array.py
+++ b/dynamic_programming/max_sub_array.py
@@ -5,37 +5,41 @@
 import time
 import matplotlib.pyplot as plt
 from random import randint
-def find_max_sub_array(A,low,high):
-    if low==high:
-        return low,high,A[low]
-    else :
-        mid=(low+high)//2
-        left_low,left_high,left_sum=find_max_sub_array(A,low,mid)
-        right_low,right_high,right_sum=find_max_sub_array(A,mid+1,high)
-        cross_left,cross_right,cross_sum=find_max_cross_sum(A,low,mid,high)
-        if left_sum>=right_sum and left_sum>=cross_sum:
-            return left_low,left_high,left_sum
-        elif right_sum>=left_sum and right_sum>=cross_sum :
-            return right_low,right_high,right_sum
+
+
+def find_max_sub_array(A, low, high):
+    if low == high:
+        return low, high, A[low]
+    else:
+        mid = (low + high) // 2
+        left_low, left_high, left_sum = find_max_sub_array(A, low, mid)
+        right_low, right_high, right_sum = find_max_sub_array(A, mid + 1, high)
+        cross_left, cross_right, cross_sum = find_max_cross_sum(A, low, mid, high)
+        if left_sum >= right_sum and left_sum >= cross_sum:
+            return left_low, left_high, left_sum
+        elif right_sum >= left_sum and right_sum >= cross_sum:
+            return right_low, right_high, right_sum
         else:
-            return cross_left,cross_right,cross_sum
+            return cross_left, cross_right, cross_sum
+
 
-def find_max_cross_sum(A,low,mid,high):
-    left_sum,max_left=-999999999,-1
-    right_sum,max_right=-999999999,-1
-    summ=0
-    for i in range(mid,low-1,-1):
-        summ+=A[i]
+def find_max_cross_sum(A, low, mid, high):
+    left_sum, max_left = -999999999, -1
+    right_sum, max_right = -999999999, -1
+    summ = 0
+    for i in range(mid, low - 1, -1):
+        summ += A[i]
         if summ > left_sum:
-            left_sum=summ
-            max_left=i
-    summ=0
-    for i in range(mid+1,high+1):
-        summ+=A[i]
+            left_sum = summ
+            max_left = i
+    summ = 0
+    for i in range(mid + 1, high + 1):
+        summ += A[i]
         if summ > right_sum:
-            right_sum=summ
-            max_right=i
-    return max_left,max_right,(left_sum+right_sum)
+            right_sum = summ
+            max_right = i
+    return max_left, max_right, (left_sum + right_sum)
+
 
 def max_sub_array(nums: List[int]) -> int:
     """
@@ -58,22 +62,20 @@ def max_sub_array(nums: List[int]) -> int:
         best = max(best, current)
     return best
 
-if __name__=='__main__':
-    inputs=[10,100,1000,10000,50000,100000,200000,300000,400000,500000]
-    tim=[]
+
+if __name__ == "__main__":
+    inputs = [10, 100, 1000, 10000, 50000, 100000, 200000, 300000, 400000, 500000]
+    tim = []
     for i in inputs:
-        li=[randint(1,i) for j in range(i)]
-        strt=time.time()
-        (find_max_sub_array(li,0,len(li)-1))
-        end=time.time()
-        tim.append(end-strt)
+        li = [randint(1, i) for j in range(i)]
+        strt = time.time()
+        (find_max_sub_array(li, 0, len(li) - 1))
+        end = time.time()
+        tim.append(end - strt)
     print("No of Inputs       Time Taken")
     for i in range(len(inputs)):
-        print(inputs[i],'\t\t',tim[i])
-    plt.plot(inputs,tim)
-    plt.xlabel("Number of Inputs");plt.ylabel("Time taken in seconds ")
+        print(inputs[i], "\t\t", tim[i])
+    plt.plot(inputs, tim)
+    plt.xlabel("Number of Inputs")
+    plt.ylabel("Time taken in seconds ")
     plt.show()
-
-
-
-
diff --git a/dynamic_programming/minimum_partition.py b/dynamic_programming/minimum_partition.py
index 18aa1faa2fa6..d5750326fea4 100644
--- a/dynamic_programming/minimum_partition.py
+++ b/dynamic_programming/minimum_partition.py
@@ -1,28 +1,30 @@
 """
 Partition a set into two subsets such that the difference of subset sums is minimum
 """
+
+
 def findMin(arr):
     n = len(arr)
     s = sum(arr)
 
-    dp = [[False for x in range(s+1)]for y in range(n+1)]
+    dp = [[False for x in range(s + 1)] for y in range(n + 1)]
 
-    for i in range(1, n+1):
+    for i in range(1, n + 1):
         dp[i][0] = True
 
-    for i in range(1, s+1):
+    for i in range(1, s + 1):
         dp[0][i] = False
 
-    for i in range(1, n+1):
-        for j in range(1, s+1):
-            dp[i][j]= dp[i][j-1]
+    for i in range(1, n + 1):
+        for j in range(1, s + 1):
+            dp[i][j] = dp[i][j - 1]
 
-            if (arr[i-1] <= j):
-                dp[i][j] = dp[i][j] or dp[i-1][j-arr[i-1]]
+            if arr[i - 1] <= j:
+                dp[i][j] = dp[i][j] or dp[i - 1][j - arr[i - 1]]
 
-    for j in range(int(s/2), -1, -1):
+    for j in range(int(s / 2), -1, -1):
         if dp[n][j] == True:
-            diff = s-2*j
-            break;
+            diff = s - 2 * j
+            break
 
     return diff
diff --git a/dynamic_programming/rod_cutting.py b/dynamic_programming/rod_cutting.py
index 5b52eaca7c89..3a1d55320d7b 100644
--- a/dynamic_programming/rod_cutting.py
+++ b/dynamic_programming/rod_cutting.py
@@ -12,7 +12,7 @@
 
 
 def naive_cut_rod_recursive(n: int, prices: list):
-	"""
+    """
 	Solves the rod-cutting problem via naively without using the benefit of dynamic programming.
 	The results is the same sub-problems are solved several times leading to an exponential runtime
 
@@ -36,18 +36,20 @@ def naive_cut_rod_recursive(n: int, prices: list):
 	30
 	"""
 
-	_enforce_args(n, prices)
-	if n == 0:
-		return 0
-	max_revue = float("-inf")
-	for i in range(1, n + 1):
-		max_revue = max(max_revue, prices[i - 1] + naive_cut_rod_recursive(n - i, prices))
+    _enforce_args(n, prices)
+    if n == 0:
+        return 0
+    max_revue = float("-inf")
+    for i in range(1, n + 1):
+        max_revue = max(
+            max_revue, prices[i - 1] + naive_cut_rod_recursive(n - i, prices)
+        )
 
-	return max_revue
+    return max_revue
 
 
 def top_down_cut_rod(n: int, prices: list):
-	"""
+    """
 	Constructs a top-down dynamic programming solution for the rod-cutting problem
 	via memoization. This function serves as a wrapper for _top_down_cut_rod_recursive
 
@@ -75,13 +77,13 @@ def top_down_cut_rod(n: int, prices: list):
 	>>> top_down_cut_rod(10, [1, 5, 8, 9, 10, 17, 17, 20, 24, 30])
 	30
 	"""
-	_enforce_args(n, prices)
-	max_rev = [float("-inf") for _ in range(n + 1)]
-	return _top_down_cut_rod_recursive(n, prices, max_rev)
+    _enforce_args(n, prices)
+    max_rev = [float("-inf") for _ in range(n + 1)]
+    return _top_down_cut_rod_recursive(n, prices, max_rev)
 
 
 def _top_down_cut_rod_recursive(n: int, prices: list, max_rev: list):
-	"""
+    """
 	Constructs a top-down dynamic programming solution for the rod-cutting problem
 	via memoization.
 
@@ -99,22 +101,25 @@ def _top_down_cut_rod_recursive(n: int, prices: list, max_rev: list):
 	-------
 	The maximum revenue obtainable for a rod of length n given the list of prices for each piece.
 	"""
-	if max_rev[n] >= 0:
-		return max_rev[n]
-	elif n == 0:
-		return 0
-	else:
-		max_revenue = float("-inf")
-		for i in range(1, n + 1):
-			max_revenue = max(max_revenue, prices[i - 1] + _top_down_cut_rod_recursive(n - i, prices, max_rev))
+    if max_rev[n] >= 0:
+        return max_rev[n]
+    elif n == 0:
+        return 0
+    else:
+        max_revenue = float("-inf")
+        for i in range(1, n + 1):
+            max_revenue = max(
+                max_revenue,
+                prices[i - 1] + _top_down_cut_rod_recursive(n - i, prices, max_rev),
+            )
 
-		max_rev[n] = max_revenue
+        max_rev[n] = max_revenue
 
-	return max_rev[n]
+    return max_rev[n]
 
 
 def bottom_up_cut_rod(n: int, prices: list):
-	"""
+    """
 	Constructs a bottom-up dynamic programming solution for the rod-cutting problem
 
 	Runtime: O(n^2)
@@ -137,24 +142,24 @@ def bottom_up_cut_rod(n: int, prices: list):
 	>>> bottom_up_cut_rod(10, [1, 5, 8, 9, 10, 17, 17, 20, 24, 30])
 	30
 	"""
-	_enforce_args(n, prices)
+    _enforce_args(n, prices)
 
-	# length(max_rev) = n + 1, to accommodate for the revenue obtainable from a rod of length 0.
-	max_rev = [float("-inf") for _ in range(n + 1)]
-	max_rev[0] = 0
+    # length(max_rev) = n + 1, to accommodate for the revenue obtainable from a rod of length 0.
+    max_rev = [float("-inf") for _ in range(n + 1)]
+    max_rev[0] = 0
 
-	for i in range(1, n + 1):
-		max_revenue_i = max_rev[i]
-		for j in range(1, i + 1):
-			max_revenue_i = max(max_revenue_i, prices[j - 1] + max_rev[i - j])
+    for i in range(1, n + 1):
+        max_revenue_i = max_rev[i]
+        for j in range(1, i + 1):
+            max_revenue_i = max(max_revenue_i, prices[j - 1] + max_rev[i - j])
 
-		max_rev[i] = max_revenue_i
+        max_rev[i] = max_revenue_i
 
-	return max_rev[n]
+    return max_rev[n]
 
 
 def _enforce_args(n: int, prices: list):
-	"""
+    """
 	Basic checks on the arguments to the rod-cutting algorithms
 
 	n: int, the length of the rod
@@ -164,30 +169,32 @@ def _enforce_args(n: int, prices: list):
 
 	if n is negative or there are fewer items in the price list than the length of the rod
 	"""
-	if n < 0:
-		raise ValueError(f"n must be greater than or equal to 0. Got n = {n}")
+    if n < 0:
+        raise ValueError(f"n must be greater than or equal to 0. Got n = {n}")
 
-	if n > len(prices):
-		raise ValueError(f"Each integral piece of rod must have a corresponding "
-						 f"price. Got n = {n} but length of prices = {len(prices)}")
+    if n > len(prices):
+        raise ValueError(
+            f"Each integral piece of rod must have a corresponding "
+            f"price. Got n = {n} but length of prices = {len(prices)}"
+        )
 
 
 def main():
-	prices = [6, 10, 12, 15, 20, 23]
-	n = len(prices)
+    prices = [6, 10, 12, 15, 20, 23]
+    n = len(prices)
 
-	# the best revenue comes from cutting the rod into 6 pieces, each
-	# of length 1 resulting in a revenue of 6 * 6 = 36.
-	expected_max_revenue = 36
+    # the best revenue comes from cutting the rod into 6 pieces, each
+    # of length 1 resulting in a revenue of 6 * 6 = 36.
+    expected_max_revenue = 36
 
-	max_rev_top_down = top_down_cut_rod(n, prices)
-	max_rev_bottom_up = bottom_up_cut_rod(n, prices)
-	max_rev_naive = naive_cut_rod_recursive(n, prices)
+    max_rev_top_down = top_down_cut_rod(n, prices)
+    max_rev_bottom_up = bottom_up_cut_rod(n, prices)
+    max_rev_naive = naive_cut_rod_recursive(n, prices)
 
-	assert expected_max_revenue == max_rev_top_down
-	assert max_rev_top_down == max_rev_bottom_up
-	assert max_rev_bottom_up == max_rev_naive
+    assert expected_max_revenue == max_rev_top_down
+    assert max_rev_top_down == max_rev_bottom_up
+    assert max_rev_bottom_up == max_rev_naive
 
 
-if __name__ == '__main__':
-	main()
+if __name__ == "__main__":
+    main()
diff --git a/dynamic_programming/subset_generation.py b/dynamic_programming/subset_generation.py
index 4b7a2bf87fd5..2cca97fc3cbc 100644
--- a/dynamic_programming/subset_generation.py
+++ b/dynamic_programming/subset_generation.py
@@ -1,39 +1,43 @@
 # python program to print all subset combination of n element in given set of r element .
-#arr[]  ---> Input Array
-#data[] ---> Temporary array to store current combination
+# arr[]  ---> Input Array
+# data[] ---> Temporary array to store current combination
 # start & end ---> Staring and Ending indexes in arr[]
 # index  ---> Current index in data[]
-#r ---> Size of a combination to be printed 
-def combinationUtil(arr,n,r,index,data,i):
-#Current combination is ready to be printed,
-# print it
- if(index == r):
-  for j in range(r):
-   print(data[j],end =" ")
-  print(" ")
-  return
-#  When no more elements are there to put in data[]
- if(i >= n):
-  return
-#current is included, put next at next
-# location 
- data[index] = arr[i]
- combinationUtil(arr,n,r,index+1,data,i+1)
- # current is excluded, replace it with
- # next (Note that i+1 is passed, but
- # index is not changed)
- combinationUtil(arr,n,r,index,data,i+1)
- # The main function that prints all combinations
- #of size r in arr[] of size n. This function 
- #mainly uses combinationUtil()
-def printcombination(arr,n,r):
-# A temporary array to store all combination
-# one by one
- data = [0]*r
-#Print all combination using temprary
-#array 'data[]'
- combinationUtil(arr,n,r,0,data,0)
+# r ---> Size of a combination to be printed
+def combinationUtil(arr, n, r, index, data, i):
+    # Current combination is ready to be printed,
+    # print it
+    if index == r:
+        for j in range(r):
+            print(data[j], end=" ")
+        print(" ")
+        return
+    #  When no more elements are there to put in data[]
+    if i >= n:
+        return
+    # current is included, put next at next
+    # location
+    data[index] = arr[i]
+    combinationUtil(arr, n, r, index + 1, data, i + 1)
+    # current is excluded, replace it with
+    # next (Note that i+1 is passed, but
+    # index is not changed)
+    combinationUtil(arr, n, r, index, data, i + 1)
+    # The main function that prints all combinations
+    # of size r in arr[] of size n. This function
+    # mainly uses combinationUtil()
+
+
+def printcombination(arr, n, r):
+    # A temporary array to store all combination
+    # one by one
+    data = [0] * r
+    # Print all combination using temprary
+    # array 'data[]'
+    combinationUtil(arr, n, r, 0, data, 0)
+
+
 # Driver function to check for above function
-arr = [10,20,30,40,50]
-printcombination(arr,len(arr),3)
-#This code is contributed by Ambuj sahu
+arr = [10, 20, 30, 40, 50]
+printcombination(arr, len(arr), 3)
+# This code is contributed by Ambuj sahu
diff --git a/dynamic_programming/sum_of_subset.py b/dynamic_programming/sum_of_subset.py
index f6509a259c5d..581039080101 100644
--- a/dynamic_programming/sum_of_subset.py
+++ b/dynamic_programming/sum_of_subset.py
@@ -1,34 +1,35 @@
 def isSumSubset(arr, arrLen, requiredSum):
 
     # a subset value says 1 if that subset sum can be formed else 0
-    #initially no subsets can be formed hence False/0
-    subset = ([[False for i in range(requiredSum + 1)] for i in range(arrLen + 1)])
+    # initially no subsets can be formed hence False/0
+    subset = [[False for i in range(requiredSum + 1)] for i in range(arrLen + 1)]
 
-    #for each arr value, a sum of zero(0) can be formed by not taking any element hence True/1
+    # for each arr value, a sum of zero(0) can be formed by not taking any element hence True/1
     for i in range(arrLen + 1):
         subset[i][0] = True
 
-    #sum is not zero and set is empty then false
+    # sum is not zero and set is empty then false
     for i in range(1, requiredSum + 1):
         subset[0][i] = False
 
     for i in range(1, arrLen + 1):
         for j in range(1, requiredSum + 1):
-            if arr[i-1]>j:
-                subset[i][j] = subset[i-1][j]
-            if arr[i-1]<=j:
-                subset[i][j] = (subset[i-1][j] or subset[i-1][j-arr[i-1]])
+            if arr[i - 1] > j:
+                subset[i][j] = subset[i - 1][j]
+            if arr[i - 1] <= j:
+                subset[i][j] = subset[i - 1][j] or subset[i - 1][j - arr[i - 1]]
 
-    #uncomment to print the subset
+    # uncomment to print the subset
     # for i in range(arrLen+1):
     #     print(subset[i])
 
     return subset[arrLen][requiredSum]
 
+
 arr = [2, 4, 6, 8]
-requiredSum =  5
+requiredSum = 5
 arrLen = len(arr)
 if isSumSubset(arr, arrLen, requiredSum):
     print("Found a subset with required sum")
 else:
-    print("No subset with required sum")
\ No newline at end of file
+    print("No subset with required sum")
diff --git a/file_transfer/recieve_file.py b/file_transfer/recieve_file.py
index f404546d7765..cfba6ed88484 100644
--- a/file_transfer/recieve_file.py
+++ b/file_transfer/recieve_file.py
@@ -1,4 +1,4 @@
-if __name__ == '__main__':
+if __name__ == "__main__":
     import socket  # Import socket module
 
     sock = socket.socket()  # Create a socket object
@@ -6,11 +6,11 @@
     port = 12312
 
     sock.connect((host, port))
-    sock.send(b'Hello server!')
+    sock.send(b"Hello server!")
 
-    with open('Received_file', 'wb') as out_file:
-        print('File opened')
-        print('Receiving data...')
+    with open("Received_file", "wb") as out_file:
+        print("File opened")
+        print("Receiving data...")
         while True:
             data = sock.recv(1024)
             print(f"data={data}")
@@ -18,6 +18,6 @@
                 break
             out_file.write(data)  # Write data to a file
 
-    print('Successfully got the file')
+    print("Successfully got the file")
     sock.close()
-    print('Connection closed')
+    print("Connection closed")
diff --git a/file_transfer/send_file.py b/file_transfer/send_file.py
index 92fab206c1a1..ebc075a30ad4 100644
--- a/file_transfer/send_file.py
+++ b/file_transfer/send_file.py
@@ -1,16 +1,18 @@
-if __name__ == '__main__':
+if __name__ == "__main__":
     import socket  # Import socket module
 
-    ONE_CONNECTION_ONLY = True  # Set this to False if you wish to continuously accept connections
+    ONE_CONNECTION_ONLY = (
+        True
+    )  # Set this to False if you wish to continuously accept connections
 
-    filename='mytext.txt'
+    filename = "mytext.txt"
     port = 12312  # Reserve a port for your service.
     sock = socket.socket()  # Create a socket object
     host = socket.gethostname()  # Get local machine name
     sock.bind((host, port))  # Bind to the port
     sock.listen(5)  # Now wait for client connection.
 
-    print('Server listening....')
+    print("Server listening....")
 
     while True:
         conn, addr = sock.accept()  # Establish connection with client.
@@ -18,16 +20,18 @@
         data = conn.recv(1024)
         print(f"Server received {data}")
 
-        with open(filename,'rb') as in_file:
+        with open(filename, "rb") as in_file:
             data = in_file.read(1024)
-            while (data):
-               conn.send(data)
-               print(f"Sent {data!r}")
-               data = in_file.read(1024)
+            while data:
+                conn.send(data)
+                print(f"Sent {data!r}")
+                data = in_file.read(1024)
 
-        print('Done sending')
+        print("Done sending")
         conn.close()
-        if ONE_CONNECTION_ONLY:  # This is to make sure that the program doesn't hang while testing
+        if (
+            ONE_CONNECTION_ONLY
+        ):  # This is to make sure that the program doesn't hang while testing
             break
 
     sock.shutdown(1)
diff --git a/graphs/a_star.py b/graphs/a_star.py
index 09a7a0e579d8..e1d17fc55434 100644
--- a/graphs/a_star.py
+++ b/graphs/a_star.py
@@ -1,42 +1,45 @@
-grid = [[0, 1, 0, 0, 0, 0],
-        [0, 1, 0, 0, 0, 0],#0 are free path whereas 1's are obstacles
-        [0, 1, 0, 0, 0, 0],
-        [0, 1, 0, 0, 1, 0],
-        [0, 0, 0, 0, 1, 0]]
-
-'''
+grid = [
+    [0, 1, 0, 0, 0, 0],
+    [0, 1, 0, 0, 0, 0],  # 0 are free path whereas 1's are obstacles
+    [0, 1, 0, 0, 0, 0],
+    [0, 1, 0, 0, 1, 0],
+    [0, 0, 0, 0, 1, 0],
+]
+
+"""
 heuristic = [[9, 8, 7, 6, 5, 4],
              [8, 7, 6, 5, 4, 3],
              [7, 6, 5, 4, 3, 2],
              [6, 5, 4, 3, 2, 1],
-             [5, 4, 3, 2, 1, 0]]'''
+             [5, 4, 3, 2, 1, 0]]"""
 
 init = [0, 0]
-goal = [len(grid)-1, len(grid[0])-1] #all coordinates are given in format [y,x]
+goal = [len(grid) - 1, len(grid[0]) - 1]  # all coordinates are given in format [y,x]
 cost = 1
 
-#the cost map which pushes the path closer to the goal
+# the cost map which pushes the path closer to the goal
 heuristic = [[0 for row in range(len(grid[0]))] for col in range(len(grid))]
 for i in range(len(grid)):
     for j in range(len(grid[0])):
         heuristic[i][j] = abs(i - goal[0]) + abs(j - goal[1])
         if grid[i][j] == 1:
-            heuristic[i][j] = 99 #added extra penalty in the heuristic map
+            heuristic[i][j] = 99  # added extra penalty in the heuristic map
 
 
-#the actions we can take
-delta = [[-1, 0 ], # go up
-         [ 0, -1], # go left
-         [ 1, 0 ], # go down
-         [ 0, 1 ]] # go right
+# the actions we can take
+delta = [[-1, 0], [0, -1], [1, 0], [0, 1]]  # go up  # go left  # go down  # go right
 
 
-#function to search the path
-def search(grid,init,goal,cost,heuristic):
+# function to search the path
+def search(grid, init, goal, cost, heuristic):
 
-    closed = [[0 for col in range(len(grid[0]))] for row in range(len(grid))]# the referrence grid
+    closed = [
+        [0 for col in range(len(grid[0]))] for row in range(len(grid))
+    ]  # the referrence grid
     closed[init[0]][init[1]] = 1
-    action = [[0 for col in range(len(grid[0]))] for row in range(len(grid))]#the action grid
+    action = [
+        [0 for col in range(len(grid[0]))] for row in range(len(grid))
+    ]  # the action grid
 
     x = init[0]
     y = init[1]
@@ -45,14 +48,14 @@ def search(grid,init,goal,cost,heuristic):
     cell = [[f, g, x, y]]
 
     found = False  # flag that is set when search is complete
-    resign = False # flag set if we can't find expand
+    resign = False  # flag set if we can't find expand
 
     while not found and not resign:
         if len(cell) == 0:
             resign = True
             return "FAIL"
         else:
-            cell.sort()#to choose the least costliest action so as to move closer to the goal
+            cell.sort()  # to choose the least costliest action so as to move closer to the goal
             cell.reverse()
             next = cell.pop()
             x = next[2]
@@ -60,14 +63,13 @@ def search(grid,init,goal,cost,heuristic):
             g = next[1]
             f = next[0]
 
-
             if x == goal[0] and y == goal[1]:
                 found = True
             else:
-                for i in range(len(delta)):#to try out different valid actions
+                for i in range(len(delta)):  # to try out different valid actions
                     x2 = x + delta[i][0]
                     y2 = y + delta[i][1]
-                    if x2 >= 0 and x2 < len(grid) and y2 >=0 and y2 < len(grid[0]):
+                    if x2 >= 0 and x2 < len(grid) and y2 >= 0 and y2 < len(grid[0]):
                         if closed[x2][y2] == 0 and grid[x2][y2] == 0:
                             g2 = g + cost
                             f2 = g2 + heuristic[x2][y2]
@@ -77,7 +79,7 @@ def search(grid,init,goal,cost,heuristic):
     invpath = []
     x = goal[0]
     y = goal[1]
-    invpath.append([x, y])#we get the reverse path from here
+    invpath.append([x, y])  # we get the reverse path from here
     while x != init[0] or y != init[1]:
         x2 = x - delta[action[x][y]][0]
         y2 = y - delta[action[x][y]][1]
@@ -87,14 +89,14 @@ def search(grid,init,goal,cost,heuristic):
 
     path = []
     for i in range(len(invpath)):
-    	path.append(invpath[len(invpath) - 1 - i])
+        path.append(invpath[len(invpath) - 1 - i])
     print("ACTION MAP")
     for i in range(len(action)):
         print(action[i])
 
     return path
 
-a = search(grid,init,goal,cost,heuristic)
-for i in range(len(a)):
-	print(a[i])
 
+a = search(grid, init, goal, cost, heuristic)
+for i in range(len(a)):
+    print(a[i])
diff --git a/graphs/articulation_points.py b/graphs/articulation_points.py
index 1173c4ea373c..3ecc829946e8 100644
--- a/graphs/articulation_points.py
+++ b/graphs/articulation_points.py
@@ -33,12 +33,23 @@ def dfs(root, at, parent, outEdgeCount):
         if not visited[i]:
             outEdgeCount = 0
             outEdgeCount = dfs(i, i, -1, outEdgeCount)
-            isArt[i] = (outEdgeCount > 1)
+            isArt[i] = outEdgeCount > 1
 
     for x in range(len(isArt)):
         if isArt[x] == True:
             print(x)
 
+
 # Adjacency list of graph
-l = {0:[1,2], 1:[0,2], 2:[0,1,3,5], 3:[2,4], 4:[3], 5:[2,6,8], 6:[5,7], 7:[6,8], 8:[5,7]}
+l = {
+    0: [1, 2],
+    1: [0, 2],
+    2: [0, 1, 3, 5],
+    3: [2, 4],
+    4: [3],
+    5: [2, 6, 8],
+    6: [5, 7],
+    7: [6, 8],
+    8: [5, 7],
+}
 computeAP(l)
diff --git a/graphs/basic_graphs.py b/graphs/basic_graphs.py
index 308abc0839fa..161bc0c09d3b 100644
--- a/graphs/basic_graphs.py
+++ b/graphs/basic_graphs.py
@@ -237,7 +237,7 @@ def edglist():
     n, m = map(int, input().split(" "))
     l = []
     for i in range(m):
-        l.append(map(int, input().split(' ')))
+        l.append(map(int, input().split(" ")))
     return l, n
 
 
diff --git a/graphs/bellman_ford.py b/graphs/bellman_ford.py
index bebe8f354b26..b782a899fda9 100644
--- a/graphs/bellman_ford.py
+++ b/graphs/bellman_ford.py
@@ -1,35 +1,35 @@
 def printDist(dist, V):
-	print("\nVertex Distance")
-	for i in range(V):
-		if dist[i] != float('inf') :
-			print(i,"\t",int(dist[i]),end = "\t")
-		else:
-			print(i,"\t","INF",end="\t")
-		print()
+    print("\nVertex Distance")
+    for i in range(V):
+        if dist[i] != float("inf"):
+            print(i, "\t", int(dist[i]), end="\t")
+        else:
+            print(i, "\t", "INF", end="\t")
+        print()
 
-def BellmanFord(graph, V, E, src):
-	mdist=[float('inf') for i in range(V)]
-	mdist[src] = 0.0
 
-	for i in range(V-1):
-		for j in range(V):
-			u = graph[j]["src"]
-			v = graph[j]["dst"]
-			w = graph[j]["weight"]
+def BellmanFord(graph, V, E, src):
+    mdist = [float("inf") for i in range(V)]
+    mdist[src] = 0.0
 
-			if mdist[u] != float('inf') and mdist[u] + w < mdist[v]:
-				mdist[v] = mdist[u] + w
-	for j in range(V):
-			u = graph[j]["src"]
-			v = graph[j]["dst"]
-			w = graph[j]["weight"]
+    for i in range(V - 1):
+        for j in range(V):
+            u = graph[j]["src"]
+            v = graph[j]["dst"]
+            w = graph[j]["weight"]
 
-			if mdist[u] != float('inf') and mdist[u] + w < mdist[v]:
-				print("Negative cycle found. Solution not possible.")
-				return
+            if mdist[u] != float("inf") and mdist[u] + w < mdist[v]:
+                mdist[v] = mdist[u] + w
+    for j in range(V):
+        u = graph[j]["src"]
+        v = graph[j]["dst"]
+        w = graph[j]["weight"]
 
-	printDist(mdist, V)
+        if mdist[u] != float("inf") and mdist[u] + w < mdist[v]:
+            print("Negative cycle found. Solution not possible.")
+            return
 
+    printDist(mdist, V)
 
 
 if __name__ == "__main__":
@@ -39,14 +39,14 @@ def BellmanFord(graph, V, E, src):
     graph = [dict() for j in range(E)]
 
     for i in range(V):
-	    graph[i][i] = 0.0
+        graph[i][i] = 0.0
 
     for i in range(E):
-	    print("\nEdge ",i+1)
-	    src = int(input("Enter source:").strip())
-	    dst = int(input("Enter destination:").strip())
-	    weight = float(input("Enter weight:").strip())
-	    graph[i] = {"src": src,"dst": dst, "weight": weight}
+        print("\nEdge ", i + 1)
+        src = int(input("Enter source:").strip())
+        dst = int(input("Enter destination:").strip())
+        weight = float(input("Enter weight:").strip())
+        graph[i] = {"src": src, "dst": dst, "weight": weight}
 
     gsrc = int(input("\nEnter shortest path source:").strip())
     BellmanFord(graph, V, E, gsrc)
diff --git a/graphs/bfs.py b/graphs/bfs.py
index ebbde0c82ce6..9d9b1ac037d9 100644
--- a/graphs/bfs.py
+++ b/graphs/bfs.py
@@ -16,12 +16,14 @@
 
 """
 
-G = {'A': ['B', 'C'],
-     'B': ['A', 'D', 'E'],
-     'C': ['A', 'F'],
-     'D': ['B'],
-     'E': ['B', 'F'],
-     'F': ['C', 'E']}
+G = {
+    "A": ["B", "C"],
+    "B": ["A", "D", "E"],
+    "C": ["A", "F"],
+    "D": ["B"],
+    "E": ["B", "F"],
+    "F": ["C", "E"],
+}
 
 
 def bfs(graph, start):
@@ -40,5 +42,5 @@ def bfs(graph, start):
     return explored
 
 
-if __name__ == '__main__':
-    print(bfs(G, 'A'))
+if __name__ == "__main__":
+    print(bfs(G, "A"))
diff --git a/graphs/bfs_shortest_path.py b/graphs/bfs_shortest_path.py
index 5853351a53a3..ec82c13997e2 100644
--- a/graphs/bfs_shortest_path.py
+++ b/graphs/bfs_shortest_path.py
@@ -1,21 +1,24 @@
-graph = {'A': ['B', 'C', 'E'],
-         'B': ['A','D', 'E'],
-         'C': ['A', 'F', 'G'],
-         'D': ['B'],
-         'E': ['A', 'B','D'],
-         'F': ['C'],
-         'G': ['C']}
+graph = {
+    "A": ["B", "C", "E"],
+    "B": ["A", "D", "E"],
+    "C": ["A", "F", "G"],
+    "D": ["B"],
+    "E": ["A", "B", "D"],
+    "F": ["C"],
+    "G": ["C"],
+}
+
 
 def bfs_shortest_path(graph, start, goal):
     # keep track of explored nodes
     explored = []
     # keep track of all the paths to be checked
     queue = [[start]]
- 
+
     # return path if start is goal
     if start == goal:
         return "That was easy! Start = goal"
- 
+
     # keeps looping until all possible paths have been checked
     while queue:
         # pop the first path from the queue
@@ -33,11 +36,12 @@ def bfs_shortest_path(graph, start, goal):
                 # return path if neighbour is goal
                 if neighbour == goal:
                     return new_path
- 
+
             # mark node as explored
             explored.append(node)
- 
+
     # in case there's no path between the 2 nodes
     return "So sorry, but a connecting path doesn't exist :("
- 
-bfs_shortest_path(graph, 'G', 'D')  # returns ['G', 'C', 'A', 'B', 'D']
+
+
+bfs_shortest_path(graph, "G", "D")  # returns ['G', 'C', 'A', 'B', 'D']
diff --git a/graphs/breadth_first_search.py b/graphs/breadth_first_search.py
index 205f49a6172b..8516e60a59c4 100644
--- a/graphs/breadth_first_search.py
+++ b/graphs/breadth_first_search.py
@@ -4,14 +4,14 @@
 """ Author: OMKAR PATHAK """
 
 
-class Graph():
+class Graph:
     def __init__(self):
         self.vertex = {}
 
     # for printing the Graph vertexes
     def printGraph(self):
         for i in self.vertex.keys():
-            print(i,' -> ', ' -> '.join([str(j) for j in self.vertex[i]]))
+            print(i, " -> ", " -> ".join([str(j) for j in self.vertex[i]]))
 
     # for adding the edge beween two vertexes
     def addEdge(self, fromVertex, toVertex):
@@ -35,7 +35,7 @@ def BFS(self, startVertex):
 
         while queue:
             startVertex = queue.pop(0)
-            print(startVertex, end = ' ')
+            print(startVertex, end=" ")
 
             # mark all adjacent nodes as visited and print them
             for i in self.vertex[startVertex]:
@@ -43,7 +43,8 @@ def BFS(self, startVertex):
                     queue.append(i)
                     visited[i] = True
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
     g = Graph()
     g.addEdge(0, 1)
     g.addEdge(0, 2)
@@ -53,7 +54,7 @@ def BFS(self, startVertex):
     g.addEdge(3, 3)
 
     g.printGraph()
-    print('BFS:')
+    print("BFS:")
     g.BFS(2)
 
     # OUTPUT:
diff --git a/graphs/check_bipartite_graph_bfs.py b/graphs/check_bipartite_graph_bfs.py
index 1b9c32c6ccc4..1ec3e3d1d45f 100644
--- a/graphs/check_bipartite_graph_bfs.py
+++ b/graphs/check_bipartite_graph_bfs.py
@@ -11,7 +11,7 @@ def checkBipartite(l):
     color = [-1] * len(l)
 
     def bfs():
-        while(queue):
+        while queue:
             u = queue.pop(0)
             visited[u] = True
 
@@ -38,6 +38,7 @@ def bfs():
 
     return True
 
+
 # Adjacency List of graph
-l = {0:[1,3], 1:[0,2], 2:[1,3], 3:[0,2]}
+l = {0: [1, 3], 1: [0, 2], 2: [1, 3], 3: [0, 2]}
 print(checkBipartite(l))
diff --git a/graphs/check_bipartite_graph_dfs.py b/graphs/check_bipartite_graph_dfs.py
index eeb3a84b7a15..6fe54a6723c5 100644
--- a/graphs/check_bipartite_graph_dfs.py
+++ b/graphs/check_bipartite_graph_dfs.py
@@ -26,8 +26,8 @@ def dfs(v, c):
                 return False
 
     return True
-        
+
 
 # Adjacency list of graph
-l = {0:[1,3], 1:[0,2], 2:[1,3], 3:[0,2], 4: []}
+l = {0: [1, 3], 1: [0, 2], 2: [1, 3], 3: [0, 2], 4: []}
 print(check_bipartite_dfs(l))
diff --git a/graphs/depth_first_search.py b/graphs/depth_first_search.py
index 2b03683c0047..5347c2fbcfa3 100644
--- a/graphs/depth_first_search.py
+++ b/graphs/depth_first_search.py
@@ -4,7 +4,7 @@
 """ Author: OMKAR PATHAK """
 
 
-class Graph():
+class Graph:
     def __init__(self):
         self.vertex = {}
 
@@ -12,7 +12,7 @@ def __init__(self):
     def printGraph(self):
         print(self.vertex)
         for i in self.vertex.keys():
-            print(i,' -> ', ' -> '.join([str(j) for j in self.vertex[i]]))
+            print(i, " -> ", " -> ".join([str(j) for j in self.vertex[i]]))
 
     # for adding the edge beween two vertexes
     def addEdge(self, fromVertex, toVertex):
@@ -36,14 +36,15 @@ def DFSRec(self, startVertex, visited):
         # mark start vertex as visited
         visited[startVertex] = True
 
-        print(startVertex, end = ' ')
+        print(startVertex, end=" ")
 
         # Recur for all the vertexes that are adjacent to this node
         for i in self.vertex.keys():
             if visited[i] == False:
                 self.DFSRec(i, visited)
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
     g = Graph()
     g.addEdge(0, 1)
     g.addEdge(0, 2)
@@ -53,7 +54,7 @@ def DFSRec(self, startVertex, visited):
     g.addEdge(3, 3)
 
     g.printGraph()
-    print('DFS:')
+    print("DFS:")
     g.DFS()
 
     # OUTPUT:
@@ -62,4 +63,4 @@ def DFSRec(self, startVertex, visited):
     # 2  ->  0 -> 3
     # 3  ->  3
     # DFS:
-    # 0 1 2 3
+    #  0 1 2 3
diff --git a/graphs/dfs.py b/graphs/dfs.py
index 68bf60e3c298..f183eae73fef 100644
--- a/graphs/dfs.py
+++ b/graphs/dfs.py
@@ -17,8 +17,10 @@ def dfs(graph, start):
        it off the stack."""
     explored, stack = set(), [start]
     while stack:
-        v = stack.pop()  # one difference from BFS is to pop last element here instead of first one
-        
+        v = (
+            stack.pop()
+        )  # one difference from BFS is to pop last element here instead of first one
+
         if v in explored:
             continue
 
@@ -30,11 +32,13 @@ def dfs(graph, start):
     return explored
 
 
-G = {'A': ['B', 'C'],
-     'B': ['A', 'D', 'E'],
-     'C': ['A', 'F'],
-     'D': ['B'],
-     'E': ['B', 'F'],
-     'F': ['C', 'E']}
+G = {
+    "A": ["B", "C"],
+    "B": ["A", "D", "E"],
+    "C": ["A", "F"],
+    "D": ["B"],
+    "E": ["B", "F"],
+    "F": ["C", "E"],
+}
 
-print(dfs(G, 'A'))
+print(dfs(G, "A"))
diff --git a/graphs/dijkstra.py b/graphs/dijkstra.py
index 5f09a45cf2c4..195f4e02d409 100644
--- a/graphs/dijkstra.py
+++ b/graphs/dijkstra.py
@@ -115,4 +115,5 @@ def dijkstra(graph, start, end):
 
 if __name__ == "__main__":
     import doctest
+
     doctest.testmod()
diff --git a/graphs/dijkstra_2.py b/graphs/dijkstra_2.py
index f6118830c9c0..762884136e4a 100644
--- a/graphs/dijkstra_2.py
+++ b/graphs/dijkstra_2.py
@@ -1,55 +1,58 @@
 def printDist(dist, V):
-	print("\nVertex Distance")
-	for i in range(V):
-		if dist[i] != float('inf') :
-			print(i,"\t",int(dist[i]),end = "\t")
-		else:
-			print(i,"\t","INF",end="\t")
-		print()
-
-def minDist(mdist, vset, V):
-	minVal = float('inf')
-	minInd = -1
-	for i in range(V):
-		if (not vset[i]) and mdist[i] < minVal :
-			minInd = i
-			minVal = mdist[i]
-	return minInd
+    print("\nVertex Distance")
+    for i in range(V):
+        if dist[i] != float("inf"):
+            print(i, "\t", int(dist[i]), end="\t")
+        else:
+            print(i, "\t", "INF", end="\t")
+        print()
 
-def Dijkstra(graph, V, src):
-	mdist=[float('inf') for i in range(V)]
-	vset = [False for i in range(V)]
-	mdist[src] = 0.0
 
-	for i in range(V-1):
-		u = minDist(mdist, vset, V)
-		vset[u] = True
+def minDist(mdist, vset, V):
+    minVal = float("inf")
+    minInd = -1
+    for i in range(V):
+        if (not vset[i]) and mdist[i] < minVal:
+            minInd = i
+            minVal = mdist[i]
+    return minInd
 
-		for v in range(V):
-			if (not vset[v]) and graph[u][v]!=float('inf') and mdist[u] + graph[u][v] < mdist[v]:
-				mdist[v] = mdist[u] + graph[u][v]
 
+def Dijkstra(graph, V, src):
+    mdist = [float("inf") for i in range(V)]
+    vset = [False for i in range(V)]
+    mdist[src] = 0.0
 
+    for i in range(V - 1):
+        u = minDist(mdist, vset, V)
+        vset[u] = True
 
-	printDist(mdist, V)
+        for v in range(V):
+            if (
+                (not vset[v])
+                and graph[u][v] != float("inf")
+                and mdist[u] + graph[u][v] < mdist[v]
+            ):
+                mdist[v] = mdist[u] + graph[u][v]
 
+    printDist(mdist, V)
 
 
 if __name__ == "__main__":
     V = int(input("Enter number of vertices: ").strip())
     E = int(input("Enter number of edges: ").strip())
 
-    graph = [[float('inf') for i in range(V)] for j in range(V)]
+    graph = [[float("inf") for i in range(V)] for j in range(V)]
 
     for i in range(V):
-	    graph[i][i] = 0.0
+        graph[i][i] = 0.0
 
     for i in range(E):
-	    print("\nEdge ",i+1)
-	    src = int(input("Enter source:").strip())
-	    dst = int(input("Enter destination:").strip())
-	    weight = float(input("Enter weight:").strip())
-	    graph[src][dst] = weight
+        print("\nEdge ", i + 1)
+        src = int(input("Enter source:").strip())
+        dst = int(input("Enter destination:").strip())
+        weight = float(input("Enter weight:").strip())
+        graph[src][dst] = weight
 
     gsrc = int(input("\nEnter shortest path source:").strip())
     Dijkstra(graph, V, gsrc)
diff --git a/graphs/dijkstra_algorithm.py b/graphs/dijkstra_algorithm.py
index c43ff37f5336..9304a83148f3 100644
--- a/graphs/dijkstra_algorithm.py
+++ b/graphs/dijkstra_algorithm.py
@@ -4,6 +4,7 @@
 
 import math
 import sys
+
 # For storing the vertex set to retreive node with the lowest distance
 
 
@@ -12,7 +13,7 @@ class PriorityQueue:
     def __init__(self):
         self.cur_size = 0
         self.array = []
-        self.pos = {}   # To store the pos of node in array
+        self.pos = {}  # To store the pos of node in array
 
     def isEmpty(self):
         return self.cur_size == 0
@@ -78,8 +79,8 @@ def decrease_key(self, tup, new_d):
 
 class Graph:
     def __init__(self, num):
-        self.adjList = {}   # To store graph: u -> (v,w)
-        self.num_nodes = num    # Number of nodes in graph
+        self.adjList = {}  # To store graph: u -> (v,w)
+        self.num_nodes = num  # Number of nodes in graph
         # To store the distance from source vertex
         self.dist = [0] * self.num_nodes
         self.par = [-1] * self.num_nodes  # To store the path
@@ -102,8 +103,11 @@ def add_edge(self, u, v, w):
     def show_graph(self):
         # u -> v(w)
         for u in self.adjList:
-            print(u, '->', ' -> '.join(str("{}({})".format(v, w))
-                                       for v, w in self.adjList[u]))
+            print(
+                u,
+                "->",
+                " -> ".join(str("{}({})".format(v, w)) for v, w in self.adjList[u]),
+            )
 
     def dijkstra(self, src):
         # Flush old junk values in par[]
@@ -137,7 +141,7 @@ def dijkstra(self, src):
     def show_distances(self, src):
         print("Distance from node: {}".format(src))
         for u in range(self.num_nodes):
-            print('Node {} has distance: {}'.format(u, self.dist[u]))
+            print("Node {} has distance: {}".format(u, self.dist[u]))
 
     def show_path(self, src, dest):
         # To show the shortest path from src to dest
@@ -157,16 +161,16 @@ def show_path(self, src, dest):
         path.append(src)
         path.reverse()
 
-        print('----Path to reach {} from {}----'.format(dest, src))
+        print("----Path to reach {} from {}----".format(dest, src))
         for u in path:
-            print('{}'.format(u), end=' ')
+            print("{}".format(u), end=" ")
             if u != dest:
-                print('-> ', end='')
+                print("-> ", end="")
 
-        print('\nTotal cost of path: ', cost)
+        print("\nTotal cost of path: ", cost)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     graph = Graph(9)
     graph.add_edge(0, 1, 4)
     graph.add_edge(0, 7, 8)
diff --git a/graphs/directed_and_undirected_(weighted)_graph.py b/graphs/directed_and_undirected_(weighted)_graph.py
index a31a4a96d6d0..883a8a00c6b1 100644
--- a/graphs/directed_and_undirected_(weighted)_graph.py
+++ b/graphs/directed_and_undirected_(weighted)_graph.py
@@ -5,468 +5,493 @@
 
 # the dfault weight is 1 if not assigend but all the implementation is weighted
 
+
 class DirectedGraph:
-	def __init__(self):
-		self.graph = {}
-
-	# adding vertices and edges
-	# adding the weight is optional
-	# handels repetition
-	def add_pair(self, u, v, w = 1):
-		if self.graph.get(u):
-			if self.graph[u].count([w,v]) == 0:
-				self.graph[u].append([w, v])
-		else:
-			self.graph[u] = [[w, v]]
-		if not self.graph.get(v):
-			self.graph[v] = []
-
-	def all_nodes(self):
-		return list(self.graph)
-
-	# handels if the input does not exist
-	def remove_pair(self, u, v):
-		if self.graph.get(u):
-			for _ in self.graph[u]:
-				if _[1] == v:
-					self.graph[u].remove(_)
-
-	# if no destination is meant the defaut value is -1
-	def dfs(self, s = -2, d = -1):
-		if s == d:
-			return []
-		stack = []
-		visited = []
-		if s == -2:
-			s = list(self.graph.keys())[0]
-		stack.append(s)
-		visited.append(s)
-		ss = s
-
-		while True:
-			# check if there is any non isolated nodes
-			if len(self.graph[s]) != 0:
-				ss = s
-				for __ in self.graph[s]:
-					if visited.count(__[1]) < 1:
-						if __[1] == d:
-							visited.append(d)
-							return visited
-						else:
-							stack.append(__[1])
-							visited.append(__[1])
-							ss =__[1]
-							break
-
-			# check if all the children are visited
-			if s == ss :
-				stack.pop()
-				if len(stack) != 0:
-					s = stack[len(stack) - 1]
-			else:
-				s = ss
-
-			# check if se have reached the starting point
-			if len(stack) == 0:
-				return visited	
-
-	# c is the count of nodes you want and if you leave it or pass -1 to the funtion the count
-	# will be random from 10 to 10000
-	def fill_graph_randomly(self, c = -1):
-		if c == -1:
-			c = (math.floor(rand.random() * 10000)) + 10
-		for _ in range(c):
-			# every vertex has max 100 edges
-			e = math.floor(rand.random() * 102) + 1
-			for __ in range(e):
-				n = math.floor(rand.random() * (c)) + 1
-				if n == _:
-					continue
-				self.add_pair(_, n, 1)
-
-	def bfs(self, s = -2):
-		d = deque()
-		visited = []
-		if s == -2:
-			s = list(self.graph.keys())[0]
-		d.append(s)
-		visited.append(s)
-		while d:
-			s = d.popleft()
-			if len(self.graph[s]) != 0:
-				for __ in self.graph[s]:
-					if visited.count(__[1]) < 1:
-						d.append(__[1])
-						visited.append(__[1])
-		return visited
-	def in_degree(self, u):
-		count = 0
-		for _ in self.graph:
-			for __ in self.graph[_]:
-				if __[1] == u:
-					count += 1
-		return count
-
-	def out_degree(self, u):
-		return len(self.graph[u])
-
-	def topological_sort(self, s = -2):
-		stack = []
-		visited = []
-		if s == -2:
-			s = list(self.graph.keys())[0]
-		stack.append(s)
-		visited.append(s)
-		ss = s
-		sorted_nodes = []
-
-		while True:
-			# check if there is any non isolated nodes
-			if len(self.graph[s]) != 0:
-				ss = s
-				for __ in self.graph[s]:
-					if visited.count(__[1]) < 1:
-						stack.append(__[1])
-						visited.append(__[1])
-						ss =__[1]
-						break
-
-			# check if all the children are visited
-			if s == ss :
-				sorted_nodes.append(stack.pop())
-				if len(stack) != 0:
-					s = stack[len(stack) - 1]
-			else:
-				s = ss
-
-			# check if se have reached the starting point
-			if len(stack) == 0:
-				return sorted_nodes
-
-	def cycle_nodes(self):
-		stack = []
-		visited = []
-		s = list(self.graph.keys())[0]
-		stack.append(s)
-		visited.append(s)
-		parent = -2
-		indirect_parents = []
-		ss = s
-		on_the_way_back = False
-		anticipating_nodes = set()
-
-		while True:
-			# check if there is any non isolated nodes
-			if len(self.graph[s]) != 0:
-				ss = s
-				for __ in self.graph[s]:
-					if visited.count(__[1]) > 0 and __[1] != parent and indirect_parents.count(__[1]) > 0 and not on_the_way_back:
-						l = len(stack) - 1
-						while True and l >= 0:
-							if stack[l] == __[1]:
-								anticipating_nodes.add(__[1])
-								break
-							else:
-								anticipating_nodes.add(stack[l])
-								l -= 1
-					if visited.count(__[1]) < 1:
-						stack.append(__[1])
-						visited.append(__[1])
-						ss =__[1]
-						break
-
-			# check if all the children are visited
-			if s == ss :
-				stack.pop()
-				on_the_way_back = True
-				if len(stack) != 0:
-					s = stack[len(stack) - 1]
-			else:
-				on_the_way_back = False
-				indirect_parents.append(parent)
-				parent = s
-				s = ss
-
-			# check if se have reached the starting point
-			if len(stack) == 0:
-				return list(anticipating_nodes)
-
-	def has_cycle(self):
-		stack = []
-		visited = []
-		s = list(self.graph.keys())[0]
-		stack.append(s)
-		visited.append(s)
-		parent = -2
-		indirect_parents = []
-		ss = s
-		on_the_way_back = False
-		anticipating_nodes = set()
-
-		while True:
-			# check if there is any non isolated nodes
-			if len(self.graph[s]) != 0:
-				ss = s
-				for __ in self.graph[s]:
-					if visited.count(__[1]) > 0 and __[1] != parent and indirect_parents.count(__[1]) > 0 and not on_the_way_back:
-						l = len(stack) - 1
-						while True and l >= 0:
-							if stack[l] == __[1]:
-								anticipating_nodes.add(__[1])
-								break
-							else:
-								return True
-								anticipating_nodes.add(stack[l])
-								l -= 1
-					if visited.count(__[1]) < 1:
-						stack.append(__[1])
-						visited.append(__[1])
-						ss =__[1]
-						break
-
-			# check if all the children are visited
-			if s == ss :
-				stack.pop()
-				on_the_way_back = True
-				if len(stack) != 0:
-					s = stack[len(stack) - 1]
-			else:
-				on_the_way_back = False
-				indirect_parents.append(parent)
-				parent = s
-				s = ss
-
-			# check if se have reached the starting point
-			if len(stack) == 0:
-				return False
-
-	def dfs_time(self, s = -2, e = -1):
-		begin = time.time()
-		self.dfs(s,e)
-		end = time.time()
-		return end - begin
-
-	def bfs_time(self, s  = -2):
-		begin = time.time()
-		self.bfs(s)
-		end = time.time()
-		return end - begin
+    def __init__(self):
+        self.graph = {}
+
+    # adding vertices and edges
+    # adding the weight is optional
+    # handels repetition
+    def add_pair(self, u, v, w=1):
+        if self.graph.get(u):
+            if self.graph[u].count([w, v]) == 0:
+                self.graph[u].append([w, v])
+        else:
+            self.graph[u] = [[w, v]]
+        if not self.graph.get(v):
+            self.graph[v] = []
+
+    def all_nodes(self):
+        return list(self.graph)
+
+    # handels if the input does not exist
+    def remove_pair(self, u, v):
+        if self.graph.get(u):
+            for _ in self.graph[u]:
+                if _[1] == v:
+                    self.graph[u].remove(_)
+
+    # if no destination is meant the defaut value is -1
+    def dfs(self, s=-2, d=-1):
+        if s == d:
+            return []
+        stack = []
+        visited = []
+        if s == -2:
+            s = list(self.graph.keys())[0]
+        stack.append(s)
+        visited.append(s)
+        ss = s
+
+        while True:
+            # check if there is any non isolated nodes
+            if len(self.graph[s]) != 0:
+                ss = s
+                for __ in self.graph[s]:
+                    if visited.count(__[1]) < 1:
+                        if __[1] == d:
+                            visited.append(d)
+                            return visited
+                        else:
+                            stack.append(__[1])
+                            visited.append(__[1])
+                            ss = __[1]
+                            break
+
+            # check if all the children are visited
+            if s == ss:
+                stack.pop()
+                if len(stack) != 0:
+                    s = stack[len(stack) - 1]
+            else:
+                s = ss
+
+            # check if se have reached the starting point
+            if len(stack) == 0:
+                return visited
+
+    # c is the count of nodes you want and if you leave it or pass -1 to the funtion the count
+    # will be random from 10 to 10000
+    def fill_graph_randomly(self, c=-1):
+        if c == -1:
+            c = (math.floor(rand.random() * 10000)) + 10
+        for _ in range(c):
+            # every vertex has max 100 edges
+            e = math.floor(rand.random() * 102) + 1
+            for __ in range(e):
+                n = math.floor(rand.random() * (c)) + 1
+                if n == _:
+                    continue
+                self.add_pair(_, n, 1)
+
+    def bfs(self, s=-2):
+        d = deque()
+        visited = []
+        if s == -2:
+            s = list(self.graph.keys())[0]
+        d.append(s)
+        visited.append(s)
+        while d:
+            s = d.popleft()
+            if len(self.graph[s]) != 0:
+                for __ in self.graph[s]:
+                    if visited.count(__[1]) < 1:
+                        d.append(__[1])
+                        visited.append(__[1])
+        return visited
+
+    def in_degree(self, u):
+        count = 0
+        for _ in self.graph:
+            for __ in self.graph[_]:
+                if __[1] == u:
+                    count += 1
+        return count
+
+    def out_degree(self, u):
+        return len(self.graph[u])
+
+    def topological_sort(self, s=-2):
+        stack = []
+        visited = []
+        if s == -2:
+            s = list(self.graph.keys())[0]
+        stack.append(s)
+        visited.append(s)
+        ss = s
+        sorted_nodes = []
+
+        while True:
+            # check if there is any non isolated nodes
+            if len(self.graph[s]) != 0:
+                ss = s
+                for __ in self.graph[s]:
+                    if visited.count(__[1]) < 1:
+                        stack.append(__[1])
+                        visited.append(__[1])
+                        ss = __[1]
+                        break
+
+            # check if all the children are visited
+            if s == ss:
+                sorted_nodes.append(stack.pop())
+                if len(stack) != 0:
+                    s = stack[len(stack) - 1]
+            else:
+                s = ss
+
+            # check if se have reached the starting point
+            if len(stack) == 0:
+                return sorted_nodes
+
+    def cycle_nodes(self):
+        stack = []
+        visited = []
+        s = list(self.graph.keys())[0]
+        stack.append(s)
+        visited.append(s)
+        parent = -2
+        indirect_parents = []
+        ss = s
+        on_the_way_back = False
+        anticipating_nodes = set()
+
+        while True:
+            # check if there is any non isolated nodes
+            if len(self.graph[s]) != 0:
+                ss = s
+                for __ in self.graph[s]:
+                    if (
+                        visited.count(__[1]) > 0
+                        and __[1] != parent
+                        and indirect_parents.count(__[1]) > 0
+                        and not on_the_way_back
+                    ):
+                        l = len(stack) - 1
+                        while True and l >= 0:
+                            if stack[l] == __[1]:
+                                anticipating_nodes.add(__[1])
+                                break
+                            else:
+                                anticipating_nodes.add(stack[l])
+                                l -= 1
+                    if visited.count(__[1]) < 1:
+                        stack.append(__[1])
+                        visited.append(__[1])
+                        ss = __[1]
+                        break
+
+            # check if all the children are visited
+            if s == ss:
+                stack.pop()
+                on_the_way_back = True
+                if len(stack) != 0:
+                    s = stack[len(stack) - 1]
+            else:
+                on_the_way_back = False
+                indirect_parents.append(parent)
+                parent = s
+                s = ss
+
+            # check if se have reached the starting point
+            if len(stack) == 0:
+                return list(anticipating_nodes)
+
+    def has_cycle(self):
+        stack = []
+        visited = []
+        s = list(self.graph.keys())[0]
+        stack.append(s)
+        visited.append(s)
+        parent = -2
+        indirect_parents = []
+        ss = s
+        on_the_way_back = False
+        anticipating_nodes = set()
+
+        while True:
+            # check if there is any non isolated nodes
+            if len(self.graph[s]) != 0:
+                ss = s
+                for __ in self.graph[s]:
+                    if (
+                        visited.count(__[1]) > 0
+                        and __[1] != parent
+                        and indirect_parents.count(__[1]) > 0
+                        and not on_the_way_back
+                    ):
+                        l = len(stack) - 1
+                        while True and l >= 0:
+                            if stack[l] == __[1]:
+                                anticipating_nodes.add(__[1])
+                                break
+                            else:
+                                return True
+                                anticipating_nodes.add(stack[l])
+                                l -= 1
+                    if visited.count(__[1]) < 1:
+                        stack.append(__[1])
+                        visited.append(__[1])
+                        ss = __[1]
+                        break
+
+            # check if all the children are visited
+            if s == ss:
+                stack.pop()
+                on_the_way_back = True
+                if len(stack) != 0:
+                    s = stack[len(stack) - 1]
+            else:
+                on_the_way_back = False
+                indirect_parents.append(parent)
+                parent = s
+                s = ss
+
+            # check if se have reached the starting point
+            if len(stack) == 0:
+                return False
+
+    def dfs_time(self, s=-2, e=-1):
+        begin = time.time()
+        self.dfs(s, e)
+        end = time.time()
+        return end - begin
+
+    def bfs_time(self, s=-2):
+        begin = time.time()
+        self.bfs(s)
+        end = time.time()
+        return end - begin
+
 
 class Graph:
-	def __init__(self):
-		self.graph = {}
-
-	# adding vertices and edges
-	# adding the weight is optional
-	# handels repetition
-	def add_pair(self, u, v, w = 1):
-		# check if the u exists
-		if self.graph.get(u):
-			# if there already is a edge
-			if self.graph[u].count([w,v]) == 0:
-				self.graph[u].append([w, v])
-		else:
-			# if u does not exist
-			self.graph[u] = [[w, v]]
-		# add the other way
-		if self.graph.get(v):
-			# if there already is a edge
-			if self.graph[v].count([w,u]) == 0:
-				self.graph[v].append([w, u])
-		else:
-			# if u does not exist
-			self.graph[v] = [[w, u]]
-			
-	# handels if the input does not exist
-	def remove_pair(self, u, v):
-		if self.graph.get(u):
-			for _ in self.graph[u]:
-				if _[1] == v:
-					self.graph[u].remove(_)
-		# the other way round
-		if self.graph.get(v):
-			for _ in self.graph[v]:
-				if _[1] == u:
-					self.graph[v].remove(_)
-
-	# if no destination is meant the defaut value is -1
-	def dfs(self, s = -2, d = -1):
-		if s == d:
-			return []
-		stack = []
-		visited = []
-		if s == -2:
-			s = list(self.graph.keys())[0]
-		stack.append(s)
-		visited.append(s)
-		ss = s
-
-		while True:
-			# check if there is any non isolated nodes
-			if len(self.graph[s]) != 0:
-				ss = s
-				for __ in self.graph[s]:
-					if visited.count(__[1]) < 1:
-						if __[1] == d:
-							visited.append(d)
-							return visited
-						else:
-							stack.append(__[1])
-							visited.append(__[1])
-							ss =__[1]
-							break
-
-			# check if all the children are visited
-			if s == ss :
-				stack.pop()
-				if len(stack) != 0:
-					s = stack[len(stack) - 1]
-			else:
-				s = ss
-
-			# check if se have reached the starting point
-			if len(stack) == 0:
-				return visited	
-
-	# c is the count of nodes you want and if you leave it or pass -1 to the funtion the count
-	# will be random from 10 to 10000
-	def fill_graph_randomly(self, c = -1):
-		if c == -1:
-			c = (math.floor(rand.random() * 10000)) + 10
-		for _ in range(c):
-			# every vertex has max 100 edges
-			e = math.floor(rand.random() * 102) + 1
-			for __ in range(e):
-				n = math.floor(rand.random() * (c)) + 1
-				if n == _:
-					continue
-				self.add_pair(_, n, 1)
-
-	def bfs(self, s = -2):
-		d = deque()
-		visited = []
-		if s == -2:
-			s = list(self.graph.keys())[0]
-		d.append(s)
-		visited.append(s)
-		while d:
-			s = d.popleft()
-			if len(self.graph[s]) != 0:
-				for __ in self.graph[s]:
-					if visited.count(__[1]) < 1:
-						d.append(__[1])
-						visited.append(__[1])
-		return visited
-	def degree(self, u):
-		return len(self.graph[u])
-
-	def cycle_nodes(self):
-		stack = []
-		visited = []
-		s = list(self.graph.keys())[0]
-		stack.append(s)
-		visited.append(s)
-		parent = -2
-		indirect_parents = []
-		ss = s
-		on_the_way_back = False
-		anticipating_nodes = set()
-
-		while True:
-			# check if there is any non isolated nodes
-			if len(self.graph[s]) != 0:
-				ss = s
-				for __ in self.graph[s]:
-					if visited.count(__[1]) > 0 and __[1] != parent and indirect_parents.count(__[1]) > 0 and not on_the_way_back:
-						l = len(stack) - 1
-						while True and l >= 0:
-							if stack[l] == __[1]:
-								anticipating_nodes.add(__[1])
-								break
-							else:
-								anticipating_nodes.add(stack[l])
-								l -= 1
-					if visited.count(__[1]) < 1:
-						stack.append(__[1])
-						visited.append(__[1])
-						ss =__[1]
-						break
-
-			# check if all the children are visited
-			if s == ss :
-				stack.pop()
-				on_the_way_back = True
-				if len(stack) != 0:
-					s = stack[len(stack) - 1]
-			else:
-				on_the_way_back = False
-				indirect_parents.append(parent)
-				parent = s
-				s = ss
-
-			# check if se have reached the starting point
-			if len(stack) == 0:
-				return list(anticipating_nodes)
-
-	def has_cycle(self):
-		stack = []
-		visited = []
-		s = list(self.graph.keys())[0]
-		stack.append(s)
-		visited.append(s)
-		parent = -2
-		indirect_parents = []
-		ss = s
-		on_the_way_back = False
-		anticipating_nodes = set()
-
-		while True:
-			# check if there is any non isolated nodes
-			if len(self.graph[s]) != 0:
-				ss = s
-				for __ in self.graph[s]:
-					if visited.count(__[1]) > 0 and __[1] != parent and indirect_parents.count(__[1]) > 0 and not on_the_way_back:
-						l = len(stack) - 1
-						while True and l >= 0:
-							if stack[l] == __[1]:
-								anticipating_nodes.add(__[1])
-								break
-							else:
-								return True
-								anticipating_nodes.add(stack[l])
-								l -= 1
-					if visited.count(__[1]) < 1:
-						stack.append(__[1])
-						visited.append(__[1])
-						ss =__[1]
-						break
-
-			# check if all the children are visited
-			if s == ss :
-				stack.pop()
-				on_the_way_back = True
-				if len(stack) != 0:
-					s = stack[len(stack) - 1]
-			else:
-				on_the_way_back = False
-				indirect_parents.append(parent)
-				parent = s
-				s = ss
-
-			# check if se have reached the starting point
-			if len(stack) == 0:
-				return False
-	def all_nodes(self):
-		return list(self.graph)
-
-	def dfs_time(self, s = -2, e = -1):
-		begin = time.time()
-		self.dfs(s,e)
-		end = time.time()
-		return end - begin
-
-	def bfs_time(self, s = -2):
-		begin = time.time()
-		self.bfs(s)
-		end = time.time()
-		return end - begin
+    def __init__(self):
+        self.graph = {}
+
+    # adding vertices and edges
+    # adding the weight is optional
+    # handels repetition
+    def add_pair(self, u, v, w=1):
+        # check if the u exists
+        if self.graph.get(u):
+            # if there already is a edge
+            if self.graph[u].count([w, v]) == 0:
+                self.graph[u].append([w, v])
+        else:
+            # if u does not exist
+            self.graph[u] = [[w, v]]
+        # add the other way
+        if self.graph.get(v):
+            # if there already is a edge
+            if self.graph[v].count([w, u]) == 0:
+                self.graph[v].append([w, u])
+        else:
+            # if u does not exist
+            self.graph[v] = [[w, u]]
+
+    # handels if the input does not exist
+    def remove_pair(self, u, v):
+        if self.graph.get(u):
+            for _ in self.graph[u]:
+                if _[1] == v:
+                    self.graph[u].remove(_)
+        # the other way round
+        if self.graph.get(v):
+            for _ in self.graph[v]:
+                if _[1] == u:
+                    self.graph[v].remove(_)
+
+    # if no destination is meant the defaut value is -1
+    def dfs(self, s=-2, d=-1):
+        if s == d:
+            return []
+        stack = []
+        visited = []
+        if s == -2:
+            s = list(self.graph.keys())[0]
+        stack.append(s)
+        visited.append(s)
+        ss = s
+
+        while True:
+            # check if there is any non isolated nodes
+            if len(self.graph[s]) != 0:
+                ss = s
+                for __ in self.graph[s]:
+                    if visited.count(__[1]) < 1:
+                        if __[1] == d:
+                            visited.append(d)
+                            return visited
+                        else:
+                            stack.append(__[1])
+                            visited.append(__[1])
+                            ss = __[1]
+                            break
+
+            # check if all the children are visited
+            if s == ss:
+                stack.pop()
+                if len(stack) != 0:
+                    s = stack[len(stack) - 1]
+            else:
+                s = ss
+
+            # check if se have reached the starting point
+            if len(stack) == 0:
+                return visited
+
+    # c is the count of nodes you want and if you leave it or pass -1 to the funtion the count
+    # will be random from 10 to 10000
+    def fill_graph_randomly(self, c=-1):
+        if c == -1:
+            c = (math.floor(rand.random() * 10000)) + 10
+        for _ in range(c):
+            # every vertex has max 100 edges
+            e = math.floor(rand.random() * 102) + 1
+            for __ in range(e):
+                n = math.floor(rand.random() * (c)) + 1
+                if n == _:
+                    continue
+                self.add_pair(_, n, 1)
+
+    def bfs(self, s=-2):
+        d = deque()
+        visited = []
+        if s == -2:
+            s = list(self.graph.keys())[0]
+        d.append(s)
+        visited.append(s)
+        while d:
+            s = d.popleft()
+            if len(self.graph[s]) != 0:
+                for __ in self.graph[s]:
+                    if visited.count(__[1]) < 1:
+                        d.append(__[1])
+                        visited.append(__[1])
+        return visited
+
+    def degree(self, u):
+        return len(self.graph[u])
+
+    def cycle_nodes(self):
+        stack = []
+        visited = []
+        s = list(self.graph.keys())[0]
+        stack.append(s)
+        visited.append(s)
+        parent = -2
+        indirect_parents = []
+        ss = s
+        on_the_way_back = False
+        anticipating_nodes = set()
+
+        while True:
+            # check if there is any non isolated nodes
+            if len(self.graph[s]) != 0:
+                ss = s
+                for __ in self.graph[s]:
+                    if (
+                        visited.count(__[1]) > 0
+                        and __[1] != parent
+                        and indirect_parents.count(__[1]) > 0
+                        and not on_the_way_back
+                    ):
+                        l = len(stack) - 1
+                        while True and l >= 0:
+                            if stack[l] == __[1]:
+                                anticipating_nodes.add(__[1])
+                                break
+                            else:
+                                anticipating_nodes.add(stack[l])
+                                l -= 1
+                    if visited.count(__[1]) < 1:
+                        stack.append(__[1])
+                        visited.append(__[1])
+                        ss = __[1]
+                        break
+
+            # check if all the children are visited
+            if s == ss:
+                stack.pop()
+                on_the_way_back = True
+                if len(stack) != 0:
+                    s = stack[len(stack) - 1]
+            else:
+                on_the_way_back = False
+                indirect_parents.append(parent)
+                parent = s
+                s = ss
+
+            # check if se have reached the starting point
+            if len(stack) == 0:
+                return list(anticipating_nodes)
+
+    def has_cycle(self):
+        stack = []
+        visited = []
+        s = list(self.graph.keys())[0]
+        stack.append(s)
+        visited.append(s)
+        parent = -2
+        indirect_parents = []
+        ss = s
+        on_the_way_back = False
+        anticipating_nodes = set()
+
+        while True:
+            # check if there is any non isolated nodes
+            if len(self.graph[s]) != 0:
+                ss = s
+                for __ in self.graph[s]:
+                    if (
+                        visited.count(__[1]) > 0
+                        and __[1] != parent
+                        and indirect_parents.count(__[1]) > 0
+                        and not on_the_way_back
+                    ):
+                        l = len(stack) - 1
+                        while True and l >= 0:
+                            if stack[l] == __[1]:
+                                anticipating_nodes.add(__[1])
+                                break
+                            else:
+                                return True
+                                anticipating_nodes.add(stack[l])
+                                l -= 1
+                    if visited.count(__[1]) < 1:
+                        stack.append(__[1])
+                        visited.append(__[1])
+                        ss = __[1]
+                        break
+
+            # check if all the children are visited
+            if s == ss:
+                stack.pop()
+                on_the_way_back = True
+                if len(stack) != 0:
+                    s = stack[len(stack) - 1]
+            else:
+                on_the_way_back = False
+                indirect_parents.append(parent)
+                parent = s
+                s = ss
+
+            # check if se have reached the starting point
+            if len(stack) == 0:
+                return False
+
+    def all_nodes(self):
+        return list(self.graph)
+
+    def dfs_time(self, s=-2, e=-1):
+        begin = time.time()
+        self.dfs(s, e)
+        end = time.time()
+        return end - begin
+
+    def bfs_time(self, s=-2):
+        begin = time.time()
+        self.bfs(s)
+        end = time.time()
+        return end - begin
diff --git a/graphs/edmonds_karp_multiple_source_and_sink.py b/graphs/edmonds_karp_multiple_source_and_sink.py
index d231ac2c4cc3..6334f05c50bd 100644
--- a/graphs/edmonds_karp_multiple_source_and_sink.py
+++ b/graphs/edmonds_karp_multiple_source_and_sink.py
@@ -28,14 +28,13 @@ def _normalizeGraph(self, sources, sinks):
             for i in sources:
                 maxInputFlow += sum(self.graph[i])
 
-
             size = len(self.graph) + 1
             for room in self.graph:
                 room.insert(0, 0)
             self.graph.insert(0, [0] * size)
             for i in sources:
                 self.graph[0][i + 1] = maxInputFlow
-            self.sourceIndex  = 0
+            self.sourceIndex = 0
 
             size = len(self.graph) + 1
             for room in self.graph:
@@ -45,7 +44,6 @@ def _normalizeGraph(self, sources, sinks):
                 self.graph[i + 1][size - 1] = maxInputFlow
             self.sinkIndex = size - 1
 
-
     def findMaximumFlow(self):
         if self.maximumFlowAlgorithm is None:
             raise Exception("You need to set maximum flow algorithm before.")
@@ -80,7 +78,6 @@ def _algorithm(self):
         pass
 
 
-
 class MaximumFlowAlgorithmExecutor(FlowNetworkAlgorithmExecutor):
     def __init__(self, flowNetwork):
         super(MaximumFlowAlgorithmExecutor, self).__init__(flowNetwork)
@@ -93,6 +90,7 @@ def getMaximumFlow(self):
 
         return self.maximumFlow
 
+
 class PushRelabelExecutor(MaximumFlowAlgorithmExecutor):
     def __init__(self, flowNetwork):
         super(PushRelabelExecutor, self).__init__(flowNetwork)
@@ -112,8 +110,11 @@ def _algorithm(self):
             self.excesses[nextVertexIndex] += bandwidth
 
         # Relabel-to-front selection rule
-        verticesList = [i for i in range(self.verticesCount)
-                        if i != self.sourceIndex and i != self.sinkIndex]
+        verticesList = [
+            i
+            for i in range(self.verticesCount)
+            if i != self.sourceIndex and i != self.sinkIndex
+        ]
 
         # move through list
         i = 0
@@ -135,15 +136,21 @@ def processVertex(self, vertexIndex):
         while self.excesses[vertexIndex] > 0:
             for neighbourIndex in range(self.verticesCount):
                 # if it's neighbour and current vertex is higher
-                if self.graph[vertexIndex][neighbourIndex] - self.preflow[vertexIndex][neighbourIndex] > 0\
-                        and self.heights[vertexIndex] > self.heights[neighbourIndex]:
+                if (
+                    self.graph[vertexIndex][neighbourIndex]
+                    - self.preflow[vertexIndex][neighbourIndex]
+                    > 0
+                    and self.heights[vertexIndex] > self.heights[neighbourIndex]
+                ):
                     self.push(vertexIndex, neighbourIndex)
 
             self.relabel(vertexIndex)
 
     def push(self, fromIndex, toIndex):
-        preflowDelta = min(self.excesses[fromIndex],
-                           self.graph[fromIndex][toIndex] - self.preflow[fromIndex][toIndex])
+        preflowDelta = min(
+            self.excesses[fromIndex],
+            self.graph[fromIndex][toIndex] - self.preflow[fromIndex][toIndex],
+        )
         self.preflow[fromIndex][toIndex] += preflowDelta
         self.preflow[toIndex][fromIndex] -= preflowDelta
         self.excesses[fromIndex] -= preflowDelta
@@ -152,14 +159,18 @@ def push(self, fromIndex, toIndex):
     def relabel(self, vertexIndex):
         minHeight = None
         for toIndex in range(self.verticesCount):
-            if self.graph[vertexIndex][toIndex] - self.preflow[vertexIndex][toIndex] > 0:
+            if (
+                self.graph[vertexIndex][toIndex] - self.preflow[vertexIndex][toIndex]
+                > 0
+            ):
                 if minHeight is None or self.heights[toIndex] < minHeight:
                     minHeight = self.heights[toIndex]
 
         if minHeight is not None:
             self.heights[vertexIndex] = minHeight + 1
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
     entrances = [0]
     exits = [3]
     # graph = [
diff --git a/graphs/eulerian_path_and_circuit_for_undirected_graph.py b/graphs/eulerian_path_and_circuit_for_undirected_graph.py
index c6c6a1a25f03..a2e5cf4da26a 100644
--- a/graphs/eulerian_path_and_circuit_for_undirected_graph.py
+++ b/graphs/eulerian_path_and_circuit_for_undirected_graph.py
@@ -50,32 +50,10 @@ def check_euler(graph, max_node):
 
 
 def main():
-    G1 = {
-        1: [2, 3, 4],
-        2: [1, 3],
-        3: [1, 2],
-        4: [1, 5],
-        5: [4]
-    }
-    G2 = {
-        1: [2, 3, 4, 5],
-        2: [1, 3],
-        3: [1, 2],
-        4: [1, 5],
-        5: [1, 4]
-    }
-    G3 = {
-        1: [2, 3, 4],
-        2: [1, 3, 4],
-        3: [1, 2],
-        4: [1, 2, 5],
-        5: [4]
-    }
-    G4 = {
-        1: [2, 3],
-        2: [1, 3],
-        3: [1, 2],
-    }
+    G1 = {1: [2, 3, 4], 2: [1, 3], 3: [1, 2], 4: [1, 5], 5: [4]}
+    G2 = {1: [2, 3, 4, 5], 2: [1, 3], 3: [1, 2], 4: [1, 5], 5: [1, 4]}
+    G3 = {1: [2, 3, 4], 2: [1, 3, 4], 3: [1, 2], 4: [1, 2, 5], 5: [4]}
+    G4 = {1: [2, 3], 2: [1, 3], 3: [1, 2]}
     G5 = {
         1: [],
         2: []
diff --git a/graphs/even_tree.py b/graphs/even_tree.py
index 45d55eecff8a..c9aef6e7861f 100644
--- a/graphs/even_tree.py
+++ b/graphs/even_tree.py
@@ -45,23 +45,13 @@ def even_tree():
     dfs(1)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     n, m = 10, 9
     tree = defaultdict(list)
     visited = {}
     cuts = []
     count = 0
-    edges = [
-        (2, 1),
-        (3, 1),
-        (4, 3),
-        (5, 2),
-        (6, 1),
-        (7, 2),
-        (8, 6),
-        (9, 8),
-        (10, 8),
-    ]
+    edges = [(2, 1), (3, 1), (4, 3), (5, 2), (6, 1), (7, 2), (8, 6), (9, 8), (10, 8)]
     for u, v in edges:
         tree[u].append(v)
         tree[v].append(u)
diff --git a/graphs/finding_bridges.py b/graphs/finding_bridges.py
index 56533dd48bde..e18a3bafa9c0 100644
--- a/graphs/finding_bridges.py
+++ b/graphs/finding_bridges.py
@@ -1,7 +1,7 @@
 # Finding Bridges in Undirected Graph
 def computeBridges(l):
     id = 0
-    n = len(l) # No of vertices in graph
+    n = len(l)  # No of vertices in graph
     low = [0] * n
     visited = [False] * n
 
@@ -23,9 +23,20 @@ def dfs(at, parent, bridges, id):
 
     bridges = []
     for i in range(n):
-        if (not visited[i]):
+        if not visited[i]:
             dfs(i, -1, bridges, id)
     print(bridges)
-            
-l = {0:[1,2], 1:[0,2], 2:[0,1,3,5], 3:[2,4], 4:[3], 5:[2,6,8], 6:[5,7], 7:[6,8], 8:[5,7]}
+
+
+l = {
+    0: [1, 2],
+    1: [0, 2],
+    2: [0, 1, 3, 5],
+    3: [2, 4],
+    4: [3],
+    5: [2, 6, 8],
+    6: [5, 7],
+    7: [6, 8],
+    8: [5, 7],
+}
 computeBridges(l)
diff --git a/graphs/graph_list.py b/graphs/graph_list.py
index 2ca363b1d746..4f0cbf15c033 100644
--- a/graphs/graph_list.py
+++ b/graphs/graph_list.py
@@ -5,6 +5,7 @@
 
 # We can use Python's dictionary for constructing the graph.
 
+
 class AdjacencyList(object):
     def __init__(self):
         self.List = {}
@@ -17,10 +18,11 @@ def addEdge(self, fromVertex, toVertex):
             self.List[fromVertex] = [toVertex]
 
     def printList(self):
-        for i  in self.List:
-            print((i,'->',' -> '.join([str(j) for j in self.List[i]])))
+        for i in self.List:
+            print((i, "->", " -> ".join([str(j) for j in self.List[i]])))
+
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     al = AdjacencyList()
     al.addEdge(0, 1)
     al.addEdge(0, 4)
diff --git a/graphs/graph_matrix.py b/graphs/graph_matrix.py
index 1998fec8d6fe..987168426ba5 100644
--- a/graphs/graph_matrix.py
+++ b/graphs/graph_matrix.py
@@ -1,8 +1,7 @@
 class Graph:
-
     def __init__(self, vertex):
         self.vertex = vertex
-        self.graph = [[0] * vertex for i in range(vertex) ]
+        self.graph = [[0] * vertex for i in range(vertex)]
 
     def add_edge(self, u, v):
         self.graph[u - 1][v - 1] = 1
@@ -12,18 +11,15 @@ def show(self):
 
         for i in self.graph:
             for j in i:
-                print(j, end=' ')
-            print(' ')
-
-
+                print(j, end=" ")
+            print(" ")
 
 
 g = Graph(100)
 
-g.add_edge(1,4)
-g.add_edge(4,2)
-g.add_edge(4,5)
-g.add_edge(2,5)
-g.add_edge(5,3)
+g.add_edge(1, 4)
+g.add_edge(4, 2)
+g.add_edge(4, 5)
+g.add_edge(2, 5)
+g.add_edge(5, 3)
 g.show()
-
diff --git a/graphs/graphs_floyd_warshall.py b/graphs/graphs_floyd_warshall.py
index 5f159683733f..5727a2f21d89 100644
--- a/graphs/graphs_floyd_warshall.py
+++ b/graphs/graphs_floyd_warshall.py
@@ -6,19 +6,18 @@
 
 
 def _print_dist(dist, v):
-	print("\nThe shortest path matrix using Floyd Warshall algorithm\n")
-	for i in range(v):
-		for j in range(v):
-			if dist[i][j] != float('inf') :
-				print(int(dist[i][j]),end = "\t")
-			else:
-				print("INF",end="\t")
-		print()
-
+    print("\nThe shortest path matrix using Floyd Warshall algorithm\n")
+    for i in range(v):
+        for j in range(v):
+            if dist[i][j] != float("inf"):
+                print(int(dist[i][j]), end="\t")
+            else:
+                print("INF", end="\t")
+        print()
 
 
 def floyd_warshall(graph, v):
-	"""
+    """
     :param graph: 2D array calculated from weight[edge[i, j]]
     :type graph: List[List[float]]
     :param v: number of vertices
@@ -33,68 +32,70 @@ def floyd_warshall(graph, v):
     5. Whenever distance[i][j] is given a new minimum value, next vertex[i][j] is updated to the next vertex[i][k].
     """
 
-	dist=[[float('inf') for _ in range(v)] for _ in range(v)]
-
-	for i in range(v):
-		for j in range(v):
-			dist[i][j] = graph[i][j]
-
-    # check vertex k against all other vertices (i, j)
-	for k in range(v):
-		# looping through rows of graph array
-		for i in range(v):
-			# looping through columns of graph array
-			for j in range(v):
-				if dist[i][k]!=float('inf') and dist[k][j]!=float('inf') and dist[i][k]+dist[k][j] < dist[i][j]:
-					dist[i][j] = dist[i][k] + dist[k][j]
-
-	_print_dist(dist, v)
-	return dist, v
-
-
-
-if __name__== '__main__':
-	v = int(input("Enter number of vertices: "))
-	e = int(input("Enter number of edges: "))
-
-	graph = [[float('inf') for i in range(v)] for j in range(v)]
-
-	for i in range(v):
-		graph[i][i] = 0.0
-
-    # src and dst are indices that must be within the array size graph[e][v]
-    # failure to follow this will result in an error
-	for i in range(e):
-		print("\nEdge ",i+1)
-		src = int(input("Enter source:"))
-		dst = int(input("Enter destination:"))
-		weight = float(input("Enter weight:"))
-		graph[src][dst] = weight
-
-	floyd_warshall(graph, v)
-
-
-	# Example Input
-	# Enter number of vertices: 3
-	# Enter number of edges: 2
-
-	# # generated graph from vertex and edge inputs
-	# [[inf, inf, inf], [inf, inf, inf], [inf, inf, inf]]
-	# [[0.0, inf, inf], [inf, 0.0, inf], [inf, inf, 0.0]]
-
-	# specify source, destination and weight for edge #1
-	# Edge  1
-	# Enter source:1
-	# Enter destination:2
-	# Enter weight:2
-
-	# specify source, destination and weight for edge #2
-	# Edge  2
-	# Enter source:2
-	# Enter destination:1
-	# Enter weight:1
-
-	# # Expected Output from the vertice, edge and src, dst, weight inputs!!
-	# 0		INF	INF
-	# INF	0	2
-	# INF	1	0
+    dist = [[float("inf") for _ in range(v)] for _ in range(v)]
+
+    for i in range(v):
+        for j in range(v):
+            dist[i][j] = graph[i][j]
+
+            # check vertex k against all other vertices (i, j)
+    for k in range(v):
+        # looping through rows of graph array
+        for i in range(v):
+            # looping through columns of graph array
+            for j in range(v):
+                if (
+                    dist[i][k] != float("inf")
+                    and dist[k][j] != float("inf")
+                    and dist[i][k] + dist[k][j] < dist[i][j]
+                ):
+                    dist[i][j] = dist[i][k] + dist[k][j]
+
+    _print_dist(dist, v)
+    return dist, v
+
+
+if __name__ == "__main__":
+    v = int(input("Enter number of vertices: "))
+    e = int(input("Enter number of edges: "))
+
+    graph = [[float("inf") for i in range(v)] for j in range(v)]
+
+    for i in range(v):
+        graph[i][i] = 0.0
+
+        # src and dst are indices that must be within the array size graph[e][v]
+        # failure to follow this will result in an error
+    for i in range(e):
+        print("\nEdge ", i + 1)
+        src = int(input("Enter source:"))
+        dst = int(input("Enter destination:"))
+        weight = float(input("Enter weight:"))
+        graph[src][dst] = weight
+
+    floyd_warshall(graph, v)
+
+    # Example Input
+    # Enter number of vertices: 3
+    # Enter number of edges: 2
+
+    # # generated graph from vertex and edge inputs
+    # [[inf, inf, inf], [inf, inf, inf], [inf, inf, inf]]
+    # [[0.0, inf, inf], [inf, 0.0, inf], [inf, inf, 0.0]]
+
+    # specify source, destination and weight for edge #1
+    # Edge  1
+    # Enter source:1
+    # Enter destination:2
+    # Enter weight:2
+
+    # specify source, destination and weight for edge #2
+    # Edge  2
+    # Enter source:2
+    # Enter destination:1
+    # Enter weight:1
+
+    # # Expected Output from the vertice, edge and src, dst, weight inputs!!
+    # 0		INF	INF
+    # INF	0	2
+    # INF	1	0
diff --git a/graphs/kahns_algorithm_long.py b/graphs/kahns_algorithm_long.py
index 453b5706f6da..0651040365d0 100644
--- a/graphs/kahns_algorithm_long.py
+++ b/graphs/kahns_algorithm_long.py
@@ -12,19 +12,20 @@ def longestDistance(l):
         if indegree[i] == 0:
             queue.append(i)
 
-    while(queue):
+    while queue:
         vertex = queue.pop(0)
         for x in l[vertex]:
             indegree[x] -= 1
 
             if longDist[vertex] + 1 > longDist[x]:
-                longDist[x] =  longDist[vertex] + 1
+                longDist[x] = longDist[vertex] + 1
 
             if indegree[x] == 0:
                 queue.append(x)
 
     print(max(longDist))
 
+
 # Adjacency list of Graph
-l = {0:[2,3,4], 1:[2,7], 2:[5], 3:[5,7], 4:[7], 5:[6], 6:[7], 7:[]}
+l = {0: [2, 3, 4], 1: [2, 7], 2: [5], 3: [5, 7], 4: [7], 5: [6], 6: [7], 7: []}
 longestDistance(l)
diff --git a/graphs/kahns_algorithm_topo.py b/graphs/kahns_algorithm_topo.py
index 8c182c4e902c..d50bc9a43d19 100644
--- a/graphs/kahns_algorithm_topo.py
+++ b/graphs/kahns_algorithm_topo.py
@@ -13,7 +13,7 @@ def topologicalSort(l):
         if indegree[i] == 0:
             queue.append(i)
 
-    while(queue):
+    while queue:
         vertex = queue.pop(0)
         cnt += 1
         topo.append(vertex)
@@ -27,6 +27,7 @@ def topologicalSort(l):
     else:
         print(topo)
 
+
 # Adjacency List of Graph
-l = {0:[1,2], 1:[3], 2:[3], 3:[4,5], 4:[], 5:[]}
+l = {0: [1, 2], 1: [3], 2: [3], 3: [4, 5], 4: [], 5: []}
 topologicalSort(l)
diff --git a/graphs/minimum_spanning_tree_kruskal.py b/graphs/minimum_spanning_tree_kruskal.py
index a2211582ec40..91b44f6508e7 100644
--- a/graphs/minimum_spanning_tree_kruskal.py
+++ b/graphs/minimum_spanning_tree_kruskal.py
@@ -4,29 +4,29 @@
     edges = []
 
     for i in range(num_edges):
-	    node1, node2, cost = list(map(int, input().strip().split()))
-	    edges.append((i,node1,node2,cost))
+        node1, node2, cost = list(map(int, input().strip().split()))
+        edges.append((i, node1, node2, cost))
 
     edges = sorted(edges, key=lambda edge: edge[3])
 
     parent = list(range(num_nodes))
 
     def find_parent(i):
-	    if i != parent[i]:
-		    parent[i] = find_parent(parent[i])
-	    return parent[i]
+        if i != parent[i]:
+            parent[i] = find_parent(parent[i])
+        return parent[i]
 
     minimum_spanning_tree_cost = 0
     minimum_spanning_tree = []
 
     for edge in edges:
-	    parent_a = find_parent(edge[1])
-	    parent_b = find_parent(edge[2])
-	    if parent_a != parent_b:
-		    minimum_spanning_tree_cost += edge[3]
-		    minimum_spanning_tree.append(edge)
-		    parent[parent_a] = parent_b
+        parent_a = find_parent(edge[1])
+        parent_b = find_parent(edge[2])
+        if parent_a != parent_b:
+            minimum_spanning_tree_cost += edge[3]
+            minimum_spanning_tree.append(edge)
+            parent[parent_a] = parent_b
 
     print(minimum_spanning_tree_cost)
     for edge in minimum_spanning_tree:
-	    print(edge)
+        print(edge)
diff --git a/graphs/minimum_spanning_tree_prims.py b/graphs/minimum_spanning_tree_prims.py
index 0f21b8f494e4..216d6a3f56de 100644
--- a/graphs/minimum_spanning_tree_prims.py
+++ b/graphs/minimum_spanning_tree_prims.py
@@ -1,9 +1,11 @@
 import sys
 from collections import defaultdict
 
+
 def PrimsAlgorithm(l):
 
     nodePosition = []
+
     def getPosition(vertex):
         return nodePosition[vertex]
 
@@ -36,11 +38,11 @@ def topToBottom(heap, start, size, positions):
     def bottomToTop(val, index, heap, position):
         temp = position[index]
 
-        while(index != 0):
+        while index != 0:
             if index % 2 == 0:
-                parent = int( (index-2) / 2 )
+                parent = int((index - 2) / 2)
             else:
-                parent = int( (index-1) / 2 )
+                parent = int((index - 1) / 2)
 
             if val < heap[parent]:
                 heap[index] = heap[parent]
@@ -69,9 +71,9 @@ def deleteMinimum(heap, positions):
         return temp
 
     visited = [0 for i in range(len(l))]
-    Nbr_TV  = [-1 for i in range(len(l))] # Neighboring Tree Vertex of selected vertex
+    Nbr_TV = [-1 for i in range(len(l))]  # Neighboring Tree Vertex of selected vertex
     # Minimum Distance of explored vertex with neighboring vertex of partial tree formed in graph
-    Distance_TV = [] # Heap of Distance of vertices from their neighboring vertex
+    Distance_TV = []  # Heap of Distance of vertices from their neighboring vertex
     Positions = []
 
     for x in range(len(l)):
@@ -84,8 +86,8 @@ def deleteMinimum(heap, positions):
     visited[0] = 1
     Distance_TV[0] = sys.maxsize
     for x in l[0]:
-        Nbr_TV[ x[0] ] = 0
-        Distance_TV[ x[0] ] = x[1]
+        Nbr_TV[x[0]] = 0
+        Distance_TV[x[0]] = x[1]
     heapify(Distance_TV, Positions)
 
     for i in range(1, len(l)):
@@ -94,12 +96,13 @@ def deleteMinimum(heap, positions):
             TreeEdges.append((Nbr_TV[vertex], vertex))
             visited[vertex] = 1
             for v in l[vertex]:
-                if visited[v[0]] == 0 and v[1] < Distance_TV[ getPosition(v[0]) ]:
-                    Distance_TV[ getPosition(v[0]) ] = v[1]
+                if visited[v[0]] == 0 and v[1] < Distance_TV[getPosition(v[0])]:
+                    Distance_TV[getPosition(v[0])] = v[1]
                     bottomToTop(v[1], getPosition(v[0]), Distance_TV, Positions)
-                    Nbr_TV[ v[0] ] = vertex
+                    Nbr_TV[v[0]] = vertex
     return TreeEdges
 
+
 if __name__ == "__main__":
     # < --------- Prims Algorithm --------- >
     n = int(input("Enter number of vertices: ").strip())
@@ -107,6 +110,6 @@ def deleteMinimum(heap, positions):
     adjlist = defaultdict(list)
     for x in range(e):
         l = [int(x) for x in input().strip().split()]
-        adjlist[l[0]].append([ l[1], l[2] ])
-        adjlist[l[1]].append([ l[0], l[2] ])
+        adjlist[l[0]].append([l[1], l[2]])
+        adjlist[l[1]].append([l[0], l[2]])
     print(PrimsAlgorithm(adjlist))
diff --git a/graphs/multi_hueristic_astar.py b/graphs/multi_hueristic_astar.py
index 3021c4162b8e..56cfc727d338 100644
--- a/graphs/multi_hueristic_astar.py
+++ b/graphs/multi_hueristic_astar.py
@@ -3,260 +3,319 @@
 
 
 class PriorityQueue:
-	def __init__(self):
-		self.elements = []
-		self.set = set()
-
-	def minkey(self):
-		if not self.empty():
-			return self.elements[0][0]
-		else:
-			return float('inf')
-
-	def empty(self):
-		return len(self.elements) == 0
-
-	def put(self, item, priority):
-		if item not in self.set:
-			heapq.heappush(self.elements, (priority, item))
-			self.set.add(item)
-		else:
-			# update
-			# print("update", item)
-			temp = []
-			(pri, x) = heapq.heappop(self.elements)
-			while x != item:
-				temp.append((pri, x))
-				(pri, x) = heapq.heappop(self.elements)
-			temp.append((priority, item))
-			for (pro, xxx) in temp:
-				heapq.heappush(self.elements, (pro, xxx))
-
-	def remove_element(self, item):
-		if item in self.set:
-			self.set.remove(item)
-			temp = []
-			(pro, x) = heapq.heappop(self.elements)
-			while x != item:
-				temp.append((pro, x))
-				(pro, x) = heapq.heappop(self.elements)
-			for (prito, yyy) in temp:
-				heapq.heappush(self.elements, (prito, yyy))
-
-	def top_show(self):
-		return self.elements[0][1]
-
-	def get(self):
-		(priority, item) = heapq.heappop(self.elements)
-		self.set.remove(item)
-		return (priority, item)
+    def __init__(self):
+        self.elements = []
+        self.set = set()
+
+    def minkey(self):
+        if not self.empty():
+            return self.elements[0][0]
+        else:
+            return float("inf")
+
+    def empty(self):
+        return len(self.elements) == 0
+
+    def put(self, item, priority):
+        if item not in self.set:
+            heapq.heappush(self.elements, (priority, item))
+            self.set.add(item)
+        else:
+            # update
+            # print("update", item)
+            temp = []
+            (pri, x) = heapq.heappop(self.elements)
+            while x != item:
+                temp.append((pri, x))
+                (pri, x) = heapq.heappop(self.elements)
+            temp.append((priority, item))
+            for (pro, xxx) in temp:
+                heapq.heappush(self.elements, (pro, xxx))
+
+    def remove_element(self, item):
+        if item in self.set:
+            self.set.remove(item)
+            temp = []
+            (pro, x) = heapq.heappop(self.elements)
+            while x != item:
+                temp.append((pro, x))
+                (pro, x) = heapq.heappop(self.elements)
+            for (prito, yyy) in temp:
+                heapq.heappush(self.elements, (prito, yyy))
+
+    def top_show(self):
+        return self.elements[0][1]
+
+    def get(self):
+        (priority, item) = heapq.heappop(self.elements)
+        self.set.remove(item)
+        return (priority, item)
+
 
 def consistent_hueristic(P, goal):
-	# euclidean distance
-	a = np.array(P)
-	b = np.array(goal)
-	return np.linalg.norm(a - b)
+    # euclidean distance
+    a = np.array(P)
+    b = np.array(goal)
+    return np.linalg.norm(a - b)
+
 
 def hueristic_2(P, goal):
-	# integer division by time variable
-	return consistent_hueristic(P, goal) // t
+    # integer division by time variable
+    return consistent_hueristic(P, goal) // t
+
 
 def hueristic_1(P, goal):
-	# manhattan distance
-	return abs(P[0] - goal[0]) + abs(P[1] - goal[1])
+    # manhattan distance
+    return abs(P[0] - goal[0]) + abs(P[1] - goal[1])
+
 
 def key(start, i, goal, g_function):
-	ans = g_function[start] + W1 * hueristics[i](start, goal)
-	return ans
+    ans = g_function[start] + W1 * hueristics[i](start, goal)
+    return ans
+
 
 def do_something(back_pointer, goal, start):
-	grid = np.chararray((n, n))
-	for i in range(n):
-		for j in range(n):
-			grid[i][j] = '*'
-
-	for i in range(n):
-		for j in range(n):
-			if (j, (n-1)-i) in blocks:
-				grid[i][j] = "#"
-
-	grid[0][(n-1)] = "-"
-	x = back_pointer[goal]
-	while x != start:
-		(x_c, y_c) = x
-		# print(x)
-		grid[(n-1)-y_c][x_c] = "-"
-		x = back_pointer[x]
-	grid[(n-1)][0] = "-"
-
-
-	for i in range(n):
-		for j in range(n):
-			if (i, j) == (0, n-1):
-				print(grid[i][j], end=' ')
-				print("<-- End position", end=' ')
-			else:
-				print(grid[i][j], end=' ')
-		print()
-	print("^")
-	print("Start position")
-	print()
-	print("# is an obstacle")
-	print("- is the path taken by algorithm")
-	print("PATH TAKEN BY THE ALGORITHM IS:-")
-	x = back_pointer[goal]
-	while x != start:
-		print(x, end=' ')
-		x = back_pointer[x]
-	print(x)
-	quit()
+    grid = np.chararray((n, n))
+    for i in range(n):
+        for j in range(n):
+            grid[i][j] = "*"
+
+    for i in range(n):
+        for j in range(n):
+            if (j, (n - 1) - i) in blocks:
+                grid[i][j] = "#"
+
+    grid[0][(n - 1)] = "-"
+    x = back_pointer[goal]
+    while x != start:
+        (x_c, y_c) = x
+        # print(x)
+        grid[(n - 1) - y_c][x_c] = "-"
+        x = back_pointer[x]
+    grid[(n - 1)][0] = "-"
+
+    for i in range(n):
+        for j in range(n):
+            if (i, j) == (0, n - 1):
+                print(grid[i][j], end=" ")
+                print("<-- End position", end=" ")
+            else:
+                print(grid[i][j], end=" ")
+        print()
+    print("^")
+    print("Start position")
+    print()
+    print("# is an obstacle")
+    print("- is the path taken by algorithm")
+    print("PATH TAKEN BY THE ALGORITHM IS:-")
+    x = back_pointer[goal]
+    while x != start:
+        print(x, end=" ")
+        x = back_pointer[x]
+    print(x)
+    quit()
+
 
 def valid(p):
-	if p[0] < 0 or p[0] > n-1:
-		return False
-	if p[1] < 0 or p[1] > n-1:
-		return False
-	return True
-
-def expand_state(s, j, visited, g_function, close_list_anchor, close_list_inad,  open_list, back_pointer):
-	for itera in range(n_hueristic):
-		open_list[itera].remove_element(s)
-	# print("s", s)
-	# print("j", j)
-	(x, y) = s
-	left = (x-1, y)
-	right = (x+1, y)
-	up = (x, y+1)
-	down = (x, y-1)
-
-	for neighbours in [left, right, up, down]:
-		if neighbours not in blocks:
-			if valid(neighbours) and neighbours not in visited:
-				# print("neighbour", neighbours)
-				visited.add(neighbours)
-				back_pointer[neighbours] = -1
-				g_function[neighbours] = float('inf')
-
-			if valid(neighbours) and g_function[neighbours] > g_function[s] + 1:
-				g_function[neighbours] = g_function[s] + 1
-				back_pointer[neighbours] = s
-				if neighbours not in close_list_anchor:
-					open_list[0].put(neighbours, key(neighbours, 0, goal, g_function))
-					if neighbours not in close_list_inad:
-						for var in range(1,n_hueristic):
-							if key(neighbours, var, goal, g_function) <= W2 * key(neighbours, 0, goal, g_function):
-								# print("why not plssssssssss")
-								open_list[j].put(neighbours, key(neighbours, var, goal, g_function))
-
-
-	# print
+    if p[0] < 0 or p[0] > n - 1:
+        return False
+    if p[1] < 0 or p[1] > n - 1:
+        return False
+    return True
+
+
+def expand_state(
+    s,
+    j,
+    visited,
+    g_function,
+    close_list_anchor,
+    close_list_inad,
+    open_list,
+    back_pointer,
+):
+    for itera in range(n_hueristic):
+        open_list[itera].remove_element(s)
+    # print("s", s)
+    # print("j", j)
+    (x, y) = s
+    left = (x - 1, y)
+    right = (x + 1, y)
+    up = (x, y + 1)
+    down = (x, y - 1)
+
+    for neighbours in [left, right, up, down]:
+        if neighbours not in blocks:
+            if valid(neighbours) and neighbours not in visited:
+                # print("neighbour", neighbours)
+                visited.add(neighbours)
+                back_pointer[neighbours] = -1
+                g_function[neighbours] = float("inf")
+
+            if valid(neighbours) and g_function[neighbours] > g_function[s] + 1:
+                g_function[neighbours] = g_function[s] + 1
+                back_pointer[neighbours] = s
+                if neighbours not in close_list_anchor:
+                    open_list[0].put(neighbours, key(neighbours, 0, goal, g_function))
+                    if neighbours not in close_list_inad:
+                        for var in range(1, n_hueristic):
+                            if key(neighbours, var, goal, g_function) <= W2 * key(
+                                neighbours, 0, goal, g_function
+                            ):
+                                # print("why not plssssssssss")
+                                open_list[j].put(
+                                    neighbours, key(neighbours, var, goal, g_function)
+                                )
+
+    # print
+
 
 def make_common_ground():
-	some_list = []
-	# block 1
-	for x in range(1, 5):
-		for y in range(1, 6):
-			some_list.append((x, y))
-
-	# line
-	for x in range(15, 20):
-		some_list.append((x, 17))
-
-	# block 2 big
-	for x in range(10, 19):
-		for y in range(1, 15):
-			some_list.append((x, y))
-
-	# L block
-	for x in range(1, 4):
-		for y in range(12, 19):
-			some_list.append((x, y))
-	for x in range(3, 13):
-		for y in range(16, 19):
-			some_list.append((x, y))
-	return some_list
+    some_list = []
+    # block 1
+    for x in range(1, 5):
+        for y in range(1, 6):
+            some_list.append((x, y))
+
+    # line
+    for x in range(15, 20):
+        some_list.append((x, 17))
+
+    # block 2 big
+    for x in range(10, 19):
+        for y in range(1, 15):
+            some_list.append((x, y))
+
+    # L block
+    for x in range(1, 4):
+        for y in range(12, 19):
+            some_list.append((x, y))
+    for x in range(3, 13):
+        for y in range(16, 19):
+            some_list.append((x, y))
+    return some_list
+
 
 hueristics = {0: consistent_hueristic, 1: hueristic_1, 2: hueristic_2}
 
-blocks_blk = [(0, 1),(1, 1),(2, 1),(3, 1),(4, 1),(5, 1),(6, 1),(7, 1),(8, 1),(9, 1),(10, 1),(11, 1),(12, 1),(13, 1),(14, 1),(15, 1),(16, 1),(17, 1),(18, 1), (19, 1)]
+blocks_blk = [
+    (0, 1),
+    (1, 1),
+    (2, 1),
+    (3, 1),
+    (4, 1),
+    (5, 1),
+    (6, 1),
+    (7, 1),
+    (8, 1),
+    (9, 1),
+    (10, 1),
+    (11, 1),
+    (12, 1),
+    (13, 1),
+    (14, 1),
+    (15, 1),
+    (16, 1),
+    (17, 1),
+    (18, 1),
+    (19, 1),
+]
 blocks_no = []
 blocks_all = make_common_ground()
 
 
-
-
 blocks = blocks_blk
 # hyper parameters
 W1 = 1
 W2 = 1
 n = 20
-n_hueristic = 3 # one consistent and two other inconsistent
+n_hueristic = 3  # one consistent and two other inconsistent
 
 # start and end destination
 start = (0, 0)
-goal = (n-1, n-1)
+goal = (n - 1, n - 1)
 
 t = 1
+
+
 def multi_a_star(start, goal, n_hueristic):
-	g_function = {start: 0, goal: float('inf')}
-	back_pointer = {start:-1, goal:-1}
-	open_list = []
-	visited = set()
-
-	for i in range(n_hueristic):
-		open_list.append(PriorityQueue())
-		open_list[i].put(start, key(start, i, goal, g_function))
-
-	close_list_anchor = []
-	close_list_inad = []
-	while open_list[0].minkey() < float('inf'):
-		for i in range(1, n_hueristic):
-			# print("i", i)
-			# print(open_list[0].minkey(), open_list[i].minkey())
-			if open_list[i].minkey() <= W2 * open_list[0].minkey():
-				global t
-				t += 1
-				# print("less prio")
-				if g_function[goal] <= open_list[i].minkey():
-					if g_function[goal] < float('inf'):
-						do_something(back_pointer, goal, start)
-				else:
-					_, get_s = open_list[i].top_show()
-					visited.add(get_s)
-					expand_state(get_s, i, visited, g_function, close_list_anchor, close_list_inad, open_list, back_pointer)
-					close_list_inad.append(get_s)
-			else:
-				# print("more prio")
-				if g_function[goal] <= open_list[0].minkey():
-					if g_function[goal] < float('inf'):
-						do_something(back_pointer, goal, start)
-				else:
-					# print("hoolla")
-					get_s = open_list[0].top_show()
-					visited.add(get_s)
-					expand_state(get_s, 0, visited, g_function, close_list_anchor, close_list_inad, open_list, back_pointer)
-					close_list_anchor.append(get_s)
-	print("No path found to goal")
-	print()
-	for i in range(n-1,-1, -1):
-		for j in range(n):
-			if (j, i) in blocks:
-				print('#', end=' ')
-			elif (j, i) in back_pointer:
-				if (j, i) == (n-1, n-1):
-					print('*', end=' ')
-				else:
-					print('-', end=' ')
-			else:
-				print('*', end=' ')
-			if (j, i) == (n-1, n-1):
-				print('<-- End position', end=' ')
-		print()
-	print("^")
-	print("Start position")
-	print()
-	print("# is an obstacle")
-	print("- is the path taken by algorithm")
+    g_function = {start: 0, goal: float("inf")}
+    back_pointer = {start: -1, goal: -1}
+    open_list = []
+    visited = set()
+
+    for i in range(n_hueristic):
+        open_list.append(PriorityQueue())
+        open_list[i].put(start, key(start, i, goal, g_function))
+
+    close_list_anchor = []
+    close_list_inad = []
+    while open_list[0].minkey() < float("inf"):
+        for i in range(1, n_hueristic):
+            # print("i", i)
+            # print(open_list[0].minkey(), open_list[i].minkey())
+            if open_list[i].minkey() <= W2 * open_list[0].minkey():
+                global t
+                t += 1
+                # print("less prio")
+                if g_function[goal] <= open_list[i].minkey():
+                    if g_function[goal] < float("inf"):
+                        do_something(back_pointer, goal, start)
+                else:
+                    _, get_s = open_list[i].top_show()
+                    visited.add(get_s)
+                    expand_state(
+                        get_s,
+                        i,
+                        visited,
+                        g_function,
+                        close_list_anchor,
+                        close_list_inad,
+                        open_list,
+                        back_pointer,
+                    )
+                    close_list_inad.append(get_s)
+            else:
+                # print("more prio")
+                if g_function[goal] <= open_list[0].minkey():
+                    if g_function[goal] < float("inf"):
+                        do_something(back_pointer, goal, start)
+                else:
+                    # print("hoolla")
+                    get_s = open_list[0].top_show()
+                    visited.add(get_s)
+                    expand_state(
+                        get_s,
+                        0,
+                        visited,
+                        g_function,
+                        close_list_anchor,
+                        close_list_inad,
+                        open_list,
+                        back_pointer,
+                    )
+                    close_list_anchor.append(get_s)
+    print("No path found to goal")
+    print()
+    for i in range(n - 1, -1, -1):
+        for j in range(n):
+            if (j, i) in blocks:
+                print("#", end=" ")
+            elif (j, i) in back_pointer:
+                if (j, i) == (n - 1, n - 1):
+                    print("*", end=" ")
+                else:
+                    print("-", end=" ")
+            else:
+                print("*", end=" ")
+            if (j, i) == (n - 1, n - 1):
+                print("<-- End position", end=" ")
+        print()
+    print("^")
+    print("Start position")
+    print()
+    print("# is an obstacle")
+    print("- is the path taken by algorithm")
 
 
 if __name__ == "__main__":
diff --git a/graphs/page_rank.py b/graphs/page_rank.py
index 59f15a99e6b2..1e2c7d9aeb48 100644
--- a/graphs/page_rank.py
+++ b/graphs/page_rank.py
@@ -1,7 +1,7 @@
-'''
+"""
 Author: https://github.com/bhushan-borole
-'''
-'''
+"""
+"""
 The input graph for the algorithm is:
 
   A B C
@@ -9,11 +9,9 @@
 B 0 0 1
 C 1 0 0
 
-'''
+"""
 
-graph = [[0, 1, 1],
-    	[0, 0, 1],
-    	[1, 0, 0]]
+graph = [[0, 1, 1], [0, 0, 1], [1, 0, 0]]
 
 
 class Node:
@@ -21,17 +19,17 @@ def __init__(self, name):
         self.name = name
         self.inbound = []
         self.outbound = []
-    
+
     def add_inbound(self, node):
         self.inbound.append(node)
-    
+
     def add_outbound(self, node):
         self.outbound.append(node)
-    
+
     def __repr__(self):
-        return 'Node {}: Inbound: {} ; Outbound: {}'.format(self.name,
-                                                      	self.inbound,
-                                                      	self.outbound)
+        return "Node {}: Inbound: {} ; Outbound: {}".format(
+            self.name, self.inbound, self.outbound
+        )
 
 
 def page_rank(nodes, limit=3, d=0.85):
@@ -44,17 +42,19 @@ def page_rank(nodes, limit=3, d=0.85):
         outbounds[node.name] = len(node.outbound)
 
     for i in range(limit):
-        print("======= Iteration {} =======".format(i+1))
+        print("======= Iteration {} =======".format(i + 1))
         for j, node in enumerate(nodes):
-            ranks[node.name] = (1 - d) + d * sum([ ranks[ib]/outbounds[ib] for ib in node.inbound ])
+            ranks[node.name] = (1 - d) + d * sum(
+                [ranks[ib] / outbounds[ib] for ib in node.inbound]
+            )
         print(ranks)
 
 
 def main():
-    names = list(input('Enter Names of the Nodes: ').split())
+    names = list(input("Enter Names of the Nodes: ").split())
 
     nodes = [Node(name) for name in names]
-    
+
     for ri, row in enumerate(graph):
         for ci, col in enumerate(row):
             if col == 1:
@@ -68,5 +68,5 @@ def main():
     page_rank(nodes)
 
 
-if __name__ == '__main__':
-    main()
\ No newline at end of file
+if __name__ == "__main__":
+    main()
diff --git a/graphs/prim.py b/graphs/prim.py
index f7e08278966d..336424d2c3c1 100644
--- a/graphs/prim.py
+++ b/graphs/prim.py
@@ -21,7 +21,7 @@
 import math
 
 
-class vertex():
+class vertex:
     """Class Vertex."""
 
     def __init__(self, id):
@@ -40,7 +40,7 @@ def __init__(self, id):
 
     def __lt__(self, other):
         """Comparison rule to < operator."""
-        return (self.key < other.key)
+        return self.key < other.key
 
     def __repr__(self):
         """Return the vertex id."""
@@ -76,4 +76,4 @@ def prim(graph, root):
                 v.key = u.edges[v.id]
     for i in range(1, len(graph)):
         A.append([graph[i].id, graph[i].pi.id])
-    return(A)
+    return A
diff --git a/graphs/scc_kosaraju.py b/graphs/scc_kosaraju.py
index 99564a7cfa35..573c1bf5e363 100644
--- a/graphs/scc_kosaraju.py
+++ b/graphs/scc_kosaraju.py
@@ -1,26 +1,31 @@
 def dfs(u):
     global g, r, scc, component, visit, stack
-    if visit[u]: return
+    if visit[u]:
+        return
     visit[u] = True
     for v in g[u]:
         dfs(v)
     stack.append(u)
 
+
 def dfs2(u):
     global g, r, scc, component, visit, stack
-    if visit[u]: return
+    if visit[u]:
+        return
     visit[u] = True
     component.append(u)
     for v in r[u]:
         dfs2(v)
 
+
 def kosaraju():
     global g, r, scc, component, visit, stack
     for i in range(n):
         dfs(i)
-    visit = [False]*n
+    visit = [False] * n
     for i in stack[::-1]:
-        if visit[i]: continue
+        if visit[i]:
+            continue
         component = []
         dfs2(i)
         scc.append(component)
@@ -29,18 +34,18 @@ def kosaraju():
 
 if __name__ == "__main__":
     # n - no of nodes, m - no of edges
-    n, m = list(map(int,input().strip().split()))
+    n, m = list(map(int, input().strip().split()))
 
-    g = [[] for i in range(n)] #graph
-    r = [[] for i in range(n)] #reversed graph
+    g = [[] for i in range(n)]  # graph
+    r = [[] for i in range(n)]  # reversed graph
     # input graph data (edges)
     for i in range(m):
-        u, v = list(map(int,input().strip().split()))
+        u, v = list(map(int, input().strip().split()))
         g[u].append(v)
         r[v].append(u)
 
     stack = []
-    visit = [False]*n
+    visit = [False] * n
     scc = []
     component = []
     print(kosaraju())
diff --git a/graphs/tarjans_scc.py b/graphs/tarjans_scc.py
index 89754e593508..4b0a689ea3c0 100644
--- a/graphs/tarjans_scc.py
+++ b/graphs/tarjans_scc.py
@@ -36,9 +36,13 @@ def strong_connect(v, index, components):
         for w in g[v]:
             if index_of[w] == -1:
                 index = strong_connect(w, index, components)
-                lowlink_of[v] = lowlink_of[w] if lowlink_of[w] < lowlink_of[v] else lowlink_of[v]
+                lowlink_of[v] = (
+                    lowlink_of[w] if lowlink_of[w] < lowlink_of[v] else lowlink_of[v]
+                )
             elif on_stack[w]:
-                lowlink_of[v] = lowlink_of[w] if lowlink_of[w] < lowlink_of[v] else lowlink_of[v]
+                lowlink_of[v] = (
+                    lowlink_of[w] if lowlink_of[w] < lowlink_of[v] else lowlink_of[v]
+                )
 
         if lowlink_of[v] == index_of[v]:
             component = []
@@ -67,7 +71,7 @@ def create_graph(n, edges):
     return g
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     # Test
     n_vertices = 7
     source = [0, 0, 1, 2, 3, 3, 4, 4, 6]
diff --git a/hashes/chaos_machine.py b/hashes/chaos_machine.py
index 3a7c3950bb29..8d3bbd4c0251 100644
--- a/hashes/chaos_machine.py
+++ b/hashes/chaos_machine.py
@@ -1,7 +1,9 @@
 """example of simple chaos machine"""
 
 # Chaos Machine (K, t, m)
-K = [0.33, 0.44, 0.55, 0.44, 0.33]; t = 3; m = 5
+K = [0.33, 0.44, 0.55, 0.44, 0.33]
+t = 3
+m = 5
 
 # Buffer Space (with Parameters Space)
 buffer_space, params_space = [], []
@@ -9,75 +11,73 @@
 # Machine Time
 machine_time = 0
 
+
 def push(seed):
-  global buffer_space, params_space, machine_time, \
-    K, m, t
+    global buffer_space, params_space, machine_time, K, m, t
+
+    # Choosing Dynamical Systems (All)
+    for key, value in enumerate(buffer_space):
+        # Evolution Parameter
+        e = float(seed / value)
 
-  # Choosing Dynamical Systems (All)
-  for key, value in enumerate(buffer_space):
-    # Evolution Parameter
-    e = float(seed / value)
+        # Control Theory: Orbit Change
+        value = (buffer_space[(key + 1) % m] + e) % 1
 
-    # Control Theory: Orbit Change
-    value = (buffer_space[(key + 1) % m] + e) % 1
+        # Control Theory: Trajectory Change
+        r = (params_space[key] + e) % 1 + 3
 
-    # Control Theory: Trajectory Change
-    r = (params_space[key] + e) % 1 + 3
+        # Modification (Transition Function) - Jumps
+        buffer_space[key] = round(float(r * value * (1 - value)), 10)
+        params_space[key] = r  # Saving to Parameters Space
 
-    # Modification (Transition Function) - Jumps
-    buffer_space[key] = \
-      round(float(r * value * (1 - value)), 10)
-    params_space[key] = \
-      r # Saving to Parameters Space
+    # Logistic Map
+    assert max(buffer_space) < 1
+    assert max(params_space) < 4
 
-  # Logistic Map
-  assert max(buffer_space) < 1
-  assert max(params_space) < 4
+    # Machine Time
+    machine_time += 1
 
-  # Machine Time
-  machine_time += 1
 
 def pull():
-  global buffer_space, params_space, machine_time, \
-    K, m, t
+    global buffer_space, params_space, machine_time, K, m, t
+
+    # PRNG (Xorshift by George Marsaglia)
+    def xorshift(X, Y):
+        X ^= Y >> 13
+        Y ^= X << 17
+        X ^= Y >> 5
+        return X
 
-  # PRNG (Xorshift by George Marsaglia)
-  def xorshift(X, Y):
-    X ^= Y >> 13
-    Y ^= X << 17
-    X ^= Y >> 5
-    return X
+    # Choosing Dynamical Systems (Increment)
+    key = machine_time % m
 
-  # Choosing Dynamical Systems (Increment)
-  key = machine_time % m
+    # Evolution (Time Length)
+    for i in range(0, t):
+        # Variables (Position + Parameters)
+        r = params_space[key]
+        value = buffer_space[key]
 
-  # Evolution (Time Length)
-  for i in range(0, t):
-    # Variables (Position + Parameters)
-    r     = params_space[key]
-    value = buffer_space[key]
+        # Modification (Transition Function) - Flow
+        buffer_space[key] = round(float(r * value * (1 - value)), 10)
+        params_space[key] = (machine_time * 0.01 + r * 1.01) % 1 + 3
 
-    # Modification (Transition Function) - Flow
-    buffer_space[key] = \
-      round(float(r * value * (1 - value)), 10)
-    params_space[key] = \
-      (machine_time * 0.01 + r * 1.01) % 1 + 3
+    # Choosing Chaotic Data
+    X = int(buffer_space[(key + 2) % m] * (10 ** 10))
+    Y = int(buffer_space[(key - 2) % m] * (10 ** 10))
 
-  # Choosing Chaotic Data
-  X = int(buffer_space[(key + 2) % m] * (10 ** 10))
-  Y = int(buffer_space[(key - 2) % m] * (10 ** 10))
+    # Machine Time
+    machine_time += 1
 
-  # Machine Time
-  machine_time += 1
+    return xorshift(X, Y) % 0xFFFFFFFF
 
-  return xorshift(X, Y) % 0xFFFFFFFF
 
 def reset():
-  global buffer_space, params_space, machine_time, \
-    K, m, t
+    global buffer_space, params_space, machine_time, K, m, t
+
+    buffer_space = K
+    params_space = [0] * m
+    machine_time = 0
 
-  buffer_space = K; params_space = [0] * m
-  machine_time = 0
 
 #######################################
 
@@ -86,15 +86,17 @@ def reset():
 
 # Pushing Data (Input)
 import random
+
 message = random.sample(range(0xFFFFFFFF), 100)
 for chunk in message:
-  push(chunk)
+    push(chunk)
 
 # for controlling
 inp = ""
 
 # Pulling Data (Output)
 while inp in ("e", "E"):
-  print("%s" % format(pull(), '#04x'))
-  print(buffer_space); print(params_space)
-  inp = input("(e)exit? ").strip()
+    print("%s" % format(pull(), "#04x"))
+    print(buffer_space)
+    print(params_space)
+    inp = input("(e)exit? ").strip()
diff --git a/hashes/enigma_machine.py b/hashes/enigma_machine.py
index 06215785765f..5420bacc1409 100644
--- a/hashes/enigma_machine.py
+++ b/hashes/enigma_machine.py
@@ -40,7 +40,7 @@ def engine(input_character):
     rotator()
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     decode = input("Type your message:\n")
     decode = list(decode)
     while True:
@@ -56,4 +56,5 @@ def engine(input_character):
     print("\n" + "".join(code))
     print(
         f"\nYour Token is {token} please write it down.\nIf you want to decode "
-        f"this message again you should input same digits as token!")
+        f"this message again you should input same digits as token!"
+    )
diff --git a/hashes/md5.py b/hashes/md5.py
index 1ad43013363f..85565533d175 100644
--- a/hashes/md5.py
+++ b/hashes/md5.py
@@ -20,8 +20,8 @@ def rearrange(bitString32):
     if len(bitString32) != 32:
         raise ValueError("Need length 32")
     newString = ""
-    for i in [3, 2,1,0]:
-        newString += bitString32[8*i:8*i+8]
+    for i in [3, 2, 1, 0]:
+        newString += bitString32[8 * i : 8 * i + 8]
     return newString
 
 
@@ -35,10 +35,10 @@ def reformatHex(i):
     '9a020000'
     """
 
-    hexrep = format(i, '08x')
+    hexrep = format(i, "08x")
     thing = ""
-    for i in [3, 2,1,0]:
-        thing += hexrep[2*i:2*i+2]
+    for i in [3, 2, 1, 0]:
+        thing += hexrep[2 * i : 2 * i + 2]
     return thing
 
 
@@ -53,10 +53,10 @@ def pad(bitString):
             [string] -- [binary string]
     """
     startLength = len(bitString)
-    bitString += '1'
+    bitString += "1"
     while len(bitString) % 512 != 448:
-        bitString += '0'
-    lastPart = format(startLength, '064b')
+        bitString += "0"
+    lastPart = format(startLength, "064b")
     bitString += rearrange(lastPart[32:]) + rearrange(lastPart[:32])
     return bitString
 
@@ -73,33 +73,35 @@ def getBlock(bitString):
 
     currPos = 0
     while currPos < len(bitString):
-        currPart = bitString[currPos:currPos+512]
+        currPart = bitString[currPos : currPos + 512]
         mySplits = []
         for i in range(16):
-            mySplits.append(int(rearrange(currPart[32*i:32*i+32]), 2))
+            mySplits.append(int(rearrange(currPart[32 * i : 32 * i + 32]), 2))
         yield mySplits
         currPos += 512
 
 
 def not32(i):
-    '''
+    """
     >>> not32(34)
     4294967261
-    '''
-    i_str = format(i, '032b')
-    new_str = ''
+    """
+    i_str = format(i, "032b")
+    new_str = ""
     for c in i_str:
-        new_str += '1' if c == '0' else '0'
+        new_str += "1" if c == "0" else "0"
     return int(new_str, 2)
 
+
 def sum32(a, b):
-    '''
+    """
+
+    """
+    return (a + b) % 2 ** 32
 
-    '''
-    return (a + b) % 2**32
 
 def leftrot32(i, s):
-    return (i << s) ^ (i >> (32-s))
+    return (i << s) ^ (i >> (32 - s))
 
 
 def md5me(testString):
@@ -110,22 +112,84 @@ def md5me(testString):
             testString {[string]} -- [message]
     """
 
-    bs = ''
+    bs = ""
     for i in testString:
-        bs += format(ord(i), '08b')
+        bs += format(ord(i), "08b")
     bs = pad(bs)
 
-    tvals = [int(2**32 * abs(math.sin(i+1))) for i in range(64)]
+    tvals = [int(2 ** 32 * abs(math.sin(i + 1))) for i in range(64)]
 
     a0 = 0x67452301
-    b0 = 0xefcdab89
-    c0 = 0x98badcfe
+    b0 = 0xEFCDAB89
+    c0 = 0x98BADCFE
     d0 = 0x10325476
 
-    s = [7, 12, 17, 22,  7, 12, 17, 22,  7, 12, 17, 22,  7, 12, 17, 22,
-         5,  9, 14, 20,  5,  9, 14, 20,  5,  9, 14, 20,  5,  9, 14, 20, \
-         4, 11, 16, 23,  4, 11, 16, 23,  4, 11, 16, 23,  4, 11, 16, 23, \
-         6, 10, 15, 21,  6, 10, 15, 21,  6, 10, 15, 21,  6, 10, 15, 21 ]
+    s = [
+        7,
+        12,
+        17,
+        22,
+        7,
+        12,
+        17,
+        22,
+        7,
+        12,
+        17,
+        22,
+        7,
+        12,
+        17,
+        22,
+        5,
+        9,
+        14,
+        20,
+        5,
+        9,
+        14,
+        20,
+        5,
+        9,
+        14,
+        20,
+        5,
+        9,
+        14,
+        20,
+        4,
+        11,
+        16,
+        23,
+        4,
+        11,
+        16,
+        23,
+        4,
+        11,
+        16,
+        23,
+        4,
+        11,
+        16,
+        23,
+        6,
+        10,
+        15,
+        21,
+        6,
+        10,
+        15,
+        21,
+        6,
+        10,
+        15,
+        21,
+        6,
+        10,
+        15,
+        21,
+    ]
 
     for m in getBlock(bs):
         A = a0
@@ -134,42 +198,44 @@ def md5me(testString):
         D = d0
         for i in range(64):
             if i <= 15:
-                #f = (B & C) | (not32(B) & D)
+                # f = (B & C) | (not32(B) & D)
                 f = D ^ (B & (C ^ D))
                 g = i
             elif i <= 31:
-                #f = (D & B) | (not32(D) & C)
+                # f = (D & B) | (not32(D) & C)
                 f = C ^ (D & (B ^ C))
-                g = (5*i+1) % 16
+                g = (5 * i + 1) % 16
             elif i <= 47:
                 f = B ^ C ^ D
-                g = (3*i+5) % 16
+                g = (3 * i + 5) % 16
             else:
                 f = C ^ (B | not32(D))
-                g = (7*i) % 16
+                g = (7 * i) % 16
             dtemp = D
             D = C
             C = B
-            B = sum32(B, leftrot32((A + f + tvals[i] + m[g]) % 2**32, s[i]))
+            B = sum32(B, leftrot32((A + f + tvals[i] + m[g]) % 2 ** 32, s[i]))
             A = dtemp
         a0 = sum32(a0, A)
         b0 = sum32(b0, B)
         c0 = sum32(c0, C)
         d0 = sum32(d0, D)
 
-    digest = reformatHex(a0) + reformatHex(b0) + \
-                         reformatHex(c0) + reformatHex(d0)
+    digest = reformatHex(a0) + reformatHex(b0) + reformatHex(c0) + reformatHex(d0)
     return digest
 
 
 def test():
     assert md5me("") == "d41d8cd98f00b204e9800998ecf8427e"
-    assert md5me(
-        "The quick brown fox jumps over the lazy dog") == "9e107d9d372bb6826bd81d3542a419d6"
+    assert (
+        md5me("The quick brown fox jumps over the lazy dog")
+        == "9e107d9d372bb6826bd81d3542a419d6"
+    )
     print("Success.")
 
 
 if __name__ == "__main__":
     test()
     import doctest
+
     doctest.testmod()
diff --git a/hashes/sha1.py b/hashes/sha1.py
index 511ea6363733..3bf27af27582 100644
--- a/hashes/sha1.py
+++ b/hashes/sha1.py
@@ -25,7 +25,7 @@
 
 import argparse
 import struct
-import hashlib #hashlib is only used inside the Test class
+import hashlib  # hashlib is only used inside the Test class
 import unittest
 
 
@@ -35,6 +35,7 @@ class SHA1Hash:
     >>> SHA1Hash(bytes('Allan', 'utf-8')).final_hash()
     '872af2d8ac3d8695387e7c804bf0e02c18df9e6e'
     """
+
     def __init__(self, data):
         """
         Inititates the variables data and h. h is a list of 5 8-digit Hexadecimal
@@ -52,21 +53,23 @@ def rotate(n, b):
         >>> SHA1Hash('').rotate(12,2)
         48
         """
-        return ((n << b) | (n >> (32 - b))) & 0xffffffff
+        return ((n << b) | (n >> (32 - b))) & 0xFFFFFFFF
 
     def padding(self):
         """
         Pads the input message with zeros so that padded_data has 64 bytes or 512 bits
         """
-        padding = b'\x80' + b'\x00'*(63 - (len(self.data) + 8) % 64)
-        padded_data = self.data + padding + struct.pack('>Q', 8 * len(self.data))
+        padding = b"\x80" + b"\x00" * (63 - (len(self.data) + 8) % 64)
+        padded_data = self.data + padding + struct.pack(">Q", 8 * len(self.data))
         return padded_data
 
     def split_blocks(self):
         """
         Returns a list of bytestrings each of length 64
         """
-        return [self.padded_data[i:i+64] for i in range(0, len(self.padded_data), 64)]
+        return [
+            self.padded_data[i : i + 64] for i in range(0, len(self.padded_data), 64)
+        ]
 
     # @staticmethod
     def expand_block(self, block):
@@ -74,9 +77,9 @@ def expand_block(self, block):
         Takes a bytestring-block of length 64, unpacks it to a list of integers and returns a
         list of 80 integers after some bit operations
         """
-        w = list(struct.unpack('>16L', block)) + [0] * 64
+        w = list(struct.unpack(">16L", block)) + [0] * 64
         for i in range(16, 80):
-            w[i] = self.rotate((w[i-3] ^ w[i-8] ^ w[i-14] ^ w[i-16]), 1)
+            w[i] = self.rotate((w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16]), 1)
         return w
 
     def final_hash(self):
@@ -106,22 +109,30 @@ def final_hash(self):
                 elif 60 <= i < 80:
                     f = b ^ c ^ d
                     k = 0xCA62C1D6
-                a, b, c, d, e = self.rotate(a, 5) + f + e + k + expanded_block[i] & 0xffffffff,\
-                                a, self.rotate(b, 30), c, d
-        self.h = self.h[0] + a & 0xffffffff,\
-                 self.h[1] + b & 0xffffffff,\
-                 self.h[2] + c & 0xffffffff,\
-                 self.h[3] + d & 0xffffffff,\
-                 self.h[4] + e & 0xffffffff
-        return '%08x%08x%08x%08x%08x' %tuple(self.h)
+                a, b, c, d, e = (
+                    self.rotate(a, 5) + f + e + k + expanded_block[i] & 0xFFFFFFFF,
+                    a,
+                    self.rotate(b, 30),
+                    c,
+                    d,
+                )
+        self.h = (
+            self.h[0] + a & 0xFFFFFFFF,
+            self.h[1] + b & 0xFFFFFFFF,
+            self.h[2] + c & 0xFFFFFFFF,
+            self.h[3] + d & 0xFFFFFFFF,
+            self.h[4] + e & 0xFFFFFFFF,
+        )
+        return "%08x%08x%08x%08x%08x" % tuple(self.h)
 
 
 class SHA1HashTest(unittest.TestCase):
     """
     Test class for the SHA1Hash class. Inherits the TestCase class from unittest
     """
+
     def testMatchHashes(self):
-        msg = bytes('Test String', 'utf-8')
+        msg = bytes("Test String", "utf-8")
         self.assertEqual(SHA1Hash(msg).final_hash(), hashlib.sha1(msg).hexdigest())
 
 
@@ -132,23 +143,27 @@ def main():
     the test each time.
     """
     # unittest.main()
-    parser = argparse.ArgumentParser(description='Process some strings or files')
-    parser.add_argument('--string', dest='input_string',
-                        default='Hello World!! Welcome to Cryptography',
-                        help='Hash the string')
-    parser.add_argument('--file', dest='input_file', help='Hash contents of a file')
+    parser = argparse.ArgumentParser(description="Process some strings or files")
+    parser.add_argument(
+        "--string",
+        dest="input_string",
+        default="Hello World!! Welcome to Cryptography",
+        help="Hash the string",
+    )
+    parser.add_argument("--file", dest="input_file", help="Hash contents of a file")
     args = parser.parse_args()
     input_string = args.input_string
-    #In any case hash input should be a bytestring
+    # In any case hash input should be a bytestring
     if args.input_file:
-        with open(args.input_file, 'rb') as f:
+        with open(args.input_file, "rb") as f:
             hash_input = f.read()
     else:
-        hash_input = bytes(input_string, 'utf-8')
+        hash_input = bytes(input_string, "utf-8")
     print(SHA1Hash(hash_input).final_hash())
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
     import doctest
-    doctest.testmod()
\ No newline at end of file
+
+    doctest.testmod()
diff --git a/linear_algebra/src/lib.py b/linear_algebra/src/lib.py
index 281991a93b2d..5ce0f696ad71 100644
--- a/linear_algebra/src/lib.py
+++ b/linear_algebra/src/lib.py
@@ -45,13 +45,15 @@ class Vector(object):
         changeComponent(pos,value) : changes the specified component.
         TODO: compare-operator
     """
-    def __init__(self,components=[]):
+
+    def __init__(self, components=[]):
         """
             input: components or nothing
             simple constructor for init the vector
         """
         self.__components = list(components)
-    def set(self,components):
+
+    def set(self, components):
         """
             input: new components
             changes the components of the vector.
@@ -61,34 +63,39 @@ def set(self,components):
             self.__components = list(components)
         else:
             raise Exception("please give any vector")
+
     def __str__(self):
         """
             returns a string representation of the vector
         """
         return "(" + ",".join(map(str, self.__components)) + ")"
-    def component(self,i):
+
+    def component(self, i):
         """
             input: index (start at 0)
             output: the i-th component of the vector.
         """
-        if type(i) is int and -len(self.__components) <= i < len(self.__components) :
+        if type(i) is int and -len(self.__components) <= i < len(self.__components):
             return self.__components[i]
         else:
             raise Exception("index out of range")
+
     def __len__(self):
         """
             returns the size of the vector
         """
         return len(self.__components)
+
     def eulidLength(self):
         """
             returns the eulidean length of the vector
         """
         summe = 0
         for c in self.__components:
-            summe += c**2
+            summe += c ** 2
         return math.sqrt(summe)
-    def __add__(self,other):
+
+    def __add__(self, other):
         """
             input: other vector
             assumes: other vector has the same size
@@ -100,7 +107,8 @@ def __add__(self,other):
             return Vector(result)
         else:
             raise Exception("must have the same size")
-    def __sub__(self,other):
+
+    def __sub__(self, other):
         """
             input: other vector
             assumes: other vector has the same size
@@ -110,73 +118,80 @@ def __sub__(self,other):
         if size == len(other):
             result = [self.__components[i] - other.component(i) for i in range(size)]
             return result
-        else: # error case
+        else:  # error case
             raise Exception("must have the same size")
-    def __mul__(self,other):
+
+    def __mul__(self, other):
         """
             mul implements the scalar multiplication 
             and the dot-product
         """
-        if isinstance(other,float) or isinstance(other,int):
-            ans = [c*other for c in self.__components]
+        if isinstance(other, float) or isinstance(other, int):
+            ans = [c * other for c in self.__components]
             return ans
-        elif (isinstance(other,Vector) and (len(self) == len(other))):
+        elif isinstance(other, Vector) and (len(self) == len(other)):
             size = len(self)
             summe = 0
             for i in range(size):
                 summe += self.__components[i] * other.component(i)
             return summe
-        else: # error case
+        else:  # error case
             raise Exception("invalide operand!")
+
     def copy(self):
         """
             copies this vector and returns it.
         """
         return Vector(self.__components)
-    def changeComponent(self,pos,value):
+
+    def changeComponent(self, pos, value):
         """
             input: an index (pos) and a value
             changes the specified component (pos) with the
             'value'
         """
-        #precondition
-        assert (-len(self.__components) <= pos < len(self.__components))
+        # precondition
+        assert -len(self.__components) <= pos < len(self.__components)
         self.__components[pos] = value
-    
+
+
 def zeroVector(dimension):
     """
         returns a zero-vector of size 'dimension'
-    """        
-    #precondition
-    assert(isinstance(dimension,int))
-    return Vector([0]*dimension)
+    """
+    # precondition
+    assert isinstance(dimension, int)
+    return Vector([0] * dimension)
 
 
-def unitBasisVector(dimension,pos):
+def unitBasisVector(dimension, pos):
     """
         returns a unit basis vector with a One 
         at index 'pos' (indexing at 0)
     """
-    #precondition
-    assert(isinstance(dimension,int) and (isinstance(pos,int)))
-    ans = [0]*dimension
+    # precondition
+    assert isinstance(dimension, int) and (isinstance(pos, int))
+    ans = [0] * dimension
     ans[pos] = 1
     return Vector(ans)
-        
 
-def axpy(scalar,x,y):
+
+def axpy(scalar, x, y):
     """
         input: a 'scalar' and two vectors 'x' and 'y'
         output: a vector
         computes the axpy operation
     """
     # precondition
-    assert(isinstance(x,Vector) and (isinstance(y,Vector)) \
-    and (isinstance(scalar,int) or isinstance(scalar,float)))
-    return (x*scalar + y)
-    
+    assert (
+        isinstance(x, Vector)
+        and (isinstance(y, Vector))
+        and (isinstance(scalar, int) or isinstance(scalar, float))
+    )
+    return x * scalar + y
+
 
-def randomVector(N,a,b):
+def randomVector(N, a, b):
     """
         input: size (N) of the vector.
                random range (a,b)
@@ -184,7 +199,7 @@ def randomVector(N,a,b):
                 random integer components between 'a' and 'b'.
     """
     random.seed(None)
-    ans = [random.randint(a,b) for i in range(N)]
+    ans = [random.randint(a, b) for i in range(N)]
     return Vector(ans)
 
 
@@ -205,7 +220,8 @@ class Matrix(object):
            operator + : implements the matrix-addition.
            operator - _ implements the matrix-subtraction
     """
-    def __init__(self,matrix,w,h):
+
+    def __init__(self, matrix, w, h):
         """
             simple constructor for initialzes 
             the matrix with components.
@@ -213,6 +229,7 @@ def __init__(self,matrix,w,h):
         self.__matrix = matrix
         self.__width = w
         self.__height = h
+
     def __str__(self):
         """
             returns a string representation of this
@@ -222,102 +239,113 @@ def __str__(self):
         for i in range(self.__height):
             ans += "|"
             for j in range(self.__width):
-                if j < self.__width -1:
+                if j < self.__width - 1:
                     ans += str(self.__matrix[i][j]) + ","
                 else:
                     ans += str(self.__matrix[i][j]) + "|\n"
         return ans
-    def changeComponent(self,x,y, value):
+
+    def changeComponent(self, x, y, value):
         """
             changes the x-y component of this matrix
         """
         if x >= 0 and x < self.__height and y >= 0 and y < self.__width:
             self.__matrix[x][y] = value
         else:
-            raise Exception ("changeComponent: indices out of bounds")
-    def component(self,x,y):
+            raise Exception("changeComponent: indices out of bounds")
+
+    def component(self, x, y):
         """
             returns the specified (x,y) component
         """
         if x >= 0 and x < self.__height and y >= 0 and y < self.__width:
             return self.__matrix[x][y]
         else:
-            raise Exception ("changeComponent: indices out of bounds")
+            raise Exception("changeComponent: indices out of bounds")
+
     def width(self):
         """
             getter for the width
         """
         return self.__width
+
     def height(self):
         """
             getter for the height
         """
         return self.__height
-    def __mul__(self,other):
+
+    def __mul__(self, other):
         """
             implements the matrix-vector multiplication.
             implements the matrix-scalar multiplication
         """
-        if isinstance(other, Vector): # vector-matrix 
-            if (len(other) == self.__width):
+        if isinstance(other, Vector):  # vector-matrix
+            if len(other) == self.__width:
                 ans = zeroVector(self.__height)
                 for i in range(self.__height):
                     summe = 0
                     for j in range(self.__width):
                         summe += other.component(j) * self.__matrix[i][j]
-                    ans.changeComponent(i,summe)
+                    ans.changeComponent(i, summe)
                     summe = 0
                 return ans
             else:
-                raise Exception("vector must have the same size as the " + "number of columns of the matrix!")
-        elif isinstance(other,int) or isinstance(other,float): # matrix-scalar
-            matrix = [[self.__matrix[i][j] * other for j in range(self.__width)] for i in range(self.__height)]
-            return Matrix(matrix,self.__width,self.__height)
-    def __add__(self,other):
+                raise Exception(
+                    "vector must have the same size as the "
+                    + "number of columns of the matrix!"
+                )
+        elif isinstance(other, int) or isinstance(other, float):  # matrix-scalar
+            matrix = [
+                [self.__matrix[i][j] * other for j in range(self.__width)]
+                for i in range(self.__height)
+            ]
+            return Matrix(matrix, self.__width, self.__height)
+
+    def __add__(self, other):
         """
             implements the matrix-addition.
         """
-        if (self.__width == other.width() and self.__height == other.height()):
+        if self.__width == other.width() and self.__height == other.height():
             matrix = []
             for i in range(self.__height):
                 row = []
                 for j in range(self.__width):
-                    row.append(self.__matrix[i][j] + other.component(i,j))
+                    row.append(self.__matrix[i][j] + other.component(i, j))
                 matrix.append(row)
-            return Matrix(matrix,self.__width,self.__height)
+            return Matrix(matrix, self.__width, self.__height)
         else:
             raise Exception("matrix must have the same dimension!")
-    def __sub__(self,other):
+
+    def __sub__(self, other):
         """
             implements the matrix-subtraction.
         """
-        if (self.__width == other.width() and self.__height == other.height()):
+        if self.__width == other.width() and self.__height == other.height():
             matrix = []
             for i in range(self.__height):
                 row = []
                 for j in range(self.__width):
-                    row.append(self.__matrix[i][j] - other.component(i,j))
+                    row.append(self.__matrix[i][j] - other.component(i, j))
                 matrix.append(row)
-            return Matrix(matrix,self.__width,self.__height)
+            return Matrix(matrix, self.__width, self.__height)
         else:
             raise Exception("matrix must have the same dimension!")
-    
+
 
 def squareZeroMatrix(N):
     """
         returns a square zero-matrix of dimension NxN
     """
-    ans = [[0]*N for i in range(N)]
-    return Matrix(ans,N,N)
-    
-    
-def randomMatrix(W,H,a,b):
+    ans = [[0] * N for i in range(N)]
+    return Matrix(ans, N, N)
+
+
+def randomMatrix(W, H, a, b):
     """
         returns a random matrix WxH with integer components
         between 'a' and 'b'
     """
     random.seed(None)
-    matrix = [[random.randint(a,b) for j in range(W)] for i in range(H)]
-    return Matrix(matrix,W,H)
-            
-        
+    matrix = [[random.randint(a, b) for j in range(W)] for i in range(H)]
+    return Matrix(matrix, W, H)
diff --git a/linear_algebra/src/tests.py b/linear_algebra/src/tests.py
index afca4ce87117..b63f2ae8c2db 100644
--- a/linear_algebra/src/tests.py
+++ b/linear_algebra/src/tests.py
@@ -11,123 +11,144 @@
 import unittest
 from lib import Matrix, Vector, axpy, squareZeroMatrix, unitBasisVector, zeroVector
 
+
 class Test(unittest.TestCase):
     def test_component(self):
         """
             test for method component
         """
-        x = Vector([1,2,3])
-        self.assertEqual(x.component(0),1)
-        self.assertEqual(x.component(2),3)
+        x = Vector([1, 2, 3])
+        self.assertEqual(x.component(0), 1)
+        self.assertEqual(x.component(2), 3)
         try:
             y = Vector()
             self.assertTrue(False)
         except:
             self.assertTrue(True)
+
     def test_str(self):
         """
             test for toString() method
         """
-        x = Vector([0,0,0,0,0,1])
-        self.assertEqual(str(x),"(0,0,0,0,0,1)")
+        x = Vector([0, 0, 0, 0, 0, 1])
+        self.assertEqual(str(x), "(0,0,0,0,0,1)")
+
     def test_size(self):
         """
             test for size()-method
         """
-        x = Vector([1,2,3,4])
-        self.assertEqual(len(x),4)
+        x = Vector([1, 2, 3, 4])
+        self.assertEqual(len(x), 4)
+
     def test_euclidLength(self):
         """
             test for the eulidean length
         """
-        x = Vector([1,2])
-        self.assertAlmostEqual(x.eulidLength(),2.236,3)
+        x = Vector([1, 2])
+        self.assertAlmostEqual(x.eulidLength(), 2.236, 3)
+
     def test_add(self):
         """
             test for + operator
         """
-        x = Vector([1,2,3])
-        y = Vector([1,1,1])
-        self.assertEqual((x+y).component(0),2)
-        self.assertEqual((x+y).component(1),3)
-        self.assertEqual((x+y).component(2),4)
+        x = Vector([1, 2, 3])
+        y = Vector([1, 1, 1])
+        self.assertEqual((x + y).component(0), 2)
+        self.assertEqual((x + y).component(1), 3)
+        self.assertEqual((x + y).component(2), 4)
+
     def test_sub(self):
         """
             test for - operator
         """
-        x = Vector([1,2,3])
-        y = Vector([1,1,1])
-        self.assertEqual((x-y).component(0),0)
-        self.assertEqual((x-y).component(1),1)
-        self.assertEqual((x-y).component(2),2)
+        x = Vector([1, 2, 3])
+        y = Vector([1, 1, 1])
+        self.assertEqual((x - y).component(0), 0)
+        self.assertEqual((x - y).component(1), 1)
+        self.assertEqual((x - y).component(2), 2)
+
     def test_mul(self):
         """
             test for * operator
         """
-        x = Vector([1,2,3])
-        a = Vector([2,-1,4]) # for test of dot-product
-        b = Vector([1,-2,-1])
-        self.assertEqual(str(x*3.0),"(3.0,6.0,9.0)")
-        self.assertEqual((a*b),0)
+        x = Vector([1, 2, 3])
+        a = Vector([2, -1, 4])  # for test of dot-product
+        b = Vector([1, -2, -1])
+        self.assertEqual(str(x * 3.0), "(3.0,6.0,9.0)")
+        self.assertEqual((a * b), 0)
+
     def test_zeroVector(self):
         """
             test for the global function zeroVector(...)
         """
         self.assertTrue(str(zeroVector(10)).count("0") == 10)
+
     def test_unitBasisVector(self):
         """
             test for the global function unitBasisVector(...)
         """
-        self.assertEqual(str(unitBasisVector(3,1)),"(0,1,0)")
+        self.assertEqual(str(unitBasisVector(3, 1)), "(0,1,0)")
+
     def test_axpy(self):
         """
             test for the global function axpy(...) (operation)
         """
-        x = Vector([1,2,3])
-        y = Vector([1,0,1])
-        self.assertEqual(str(axpy(2,x,y)),"(3,4,7)")
+        x = Vector([1, 2, 3])
+        y = Vector([1, 0, 1])
+        self.assertEqual(str(axpy(2, x, y)), "(3,4,7)")
+
     def test_copy(self):
         """
             test for the copy()-method
         """
-        x = Vector([1,0,0,0,0,0])
+        x = Vector([1, 0, 0, 0, 0, 0])
         y = x.copy()
-        self.assertEqual(str(x),str(y))
+        self.assertEqual(str(x), str(y))
+
     def test_changeComponent(self):
         """
             test for the changeComponent(...)-method
         """
-        x = Vector([1,0,0])
-        x.changeComponent(0,0)
-        x.changeComponent(1,1)
-        self.assertEqual(str(x),"(0,1,0)")
+        x = Vector([1, 0, 0])
+        x.changeComponent(0, 0)
+        x.changeComponent(1, 1)
+        self.assertEqual(str(x), "(0,1,0)")
+
     def test_str_matrix(self):
-        A = Matrix([[1,2,3],[2,4,5],[6,7,8]],3,3)
-        self.assertEqual("|1,2,3|\n|2,4,5|\n|6,7,8|\n",str(A))
+        A = Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]], 3, 3)
+        self.assertEqual("|1,2,3|\n|2,4,5|\n|6,7,8|\n", str(A))
+
     def test__mul__matrix(self):
-        A = Matrix([[1,2,3],[4,5,6],[7,8,9]],3,3)
-        x = Vector([1,2,3])
-        self.assertEqual("(14,32,50)",str(A*x))
-        self.assertEqual("|2,4,6|\n|8,10,12|\n|14,16,18|\n",str(A*2))
+        A = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]], 3, 3)
+        x = Vector([1, 2, 3])
+        self.assertEqual("(14,32,50)", str(A * x))
+        self.assertEqual("|2,4,6|\n|8,10,12|\n|14,16,18|\n", str(A * 2))
+
     def test_changeComponent_matrix(self):
-        A = Matrix([[1,2,3],[2,4,5],[6,7,8]],3,3)
-        A.changeComponent(0,2,5)
-        self.assertEqual("|1,2,5|\n|2,4,5|\n|6,7,8|\n",str(A))
+        A = Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]], 3, 3)
+        A.changeComponent(0, 2, 5)
+        self.assertEqual("|1,2,5|\n|2,4,5|\n|6,7,8|\n", str(A))
+
     def test_component_matrix(self):
-        A = Matrix([[1,2,3],[2,4,5],[6,7,8]],3,3)
-        self.assertEqual(7,A.component(2,1),0.01)
+        A = Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]], 3, 3)
+        self.assertEqual(7, A.component(2, 1), 0.01)
+
     def test__add__matrix(self):
-        A = Matrix([[1,2,3],[2,4,5],[6,7,8]],3,3)
-        B = Matrix([[1,2,7],[2,4,5],[6,7,10]],3,3)
-        self.assertEqual("|2,4,10|\n|4,8,10|\n|12,14,18|\n",str(A+B))
+        A = Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]], 3, 3)
+        B = Matrix([[1, 2, 7], [2, 4, 5], [6, 7, 10]], 3, 3)
+        self.assertEqual("|2,4,10|\n|4,8,10|\n|12,14,18|\n", str(A + B))
+
     def test__sub__matrix(self):
-        A = Matrix([[1,2,3],[2,4,5],[6,7,8]],3,3)
-        B = Matrix([[1,2,7],[2,4,5],[6,7,10]],3,3)
-        self.assertEqual("|0,0,-4|\n|0,0,0|\n|0,0,-2|\n",str(A-B))
+        A = Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]], 3, 3)
+        B = Matrix([[1, 2, 7], [2, 4, 5], [6, 7, 10]], 3, 3)
+        self.assertEqual("|0,0,-4|\n|0,0,0|\n|0,0,-2|\n", str(A - B))
+
     def test_squareZeroMatrix(self):
-        self.assertEqual('|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|' 
-        +'\n|0,0,0,0,0|\n',str(squareZeroMatrix(5)))
-        
+        self.assertEqual(
+            "|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|" + "\n|0,0,0,0,0|\n",
+            str(squareZeroMatrix(5)),
+        )
+
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/machine_learning/decision_tree.py b/machine_learning/decision_tree.py
index acdf646875ac..4f7a4d12966e 100644
--- a/machine_learning/decision_tree.py
+++ b/machine_learning/decision_tree.py
@@ -5,8 +5,9 @@
 """
 import numpy as np
 
+
 class Decision_Tree:
-    def __init__(self, depth = 5, min_leaf_size = 5):
+    def __init__(self, depth=5, min_leaf_size=5):
         self.depth = depth
         self.decision_boundary = 0
         self.left = None
@@ -58,8 +59,7 @@ def train(self, X, y):
             return
 
         best_split = 0
-        min_error = self.mean_squared_error(X,np.mean(y)) * 2
-
+        min_error = self.mean_squared_error(X, np.mean(y)) * 2
 
         """
         loop over all possible splits for the decision tree. find the best split.
@@ -86,8 +86,12 @@ def train(self, X, y):
             right_y = y[best_split:]
 
             self.decision_boundary = X[best_split]
-            self.left = Decision_Tree(depth = self.depth - 1, min_leaf_size = self.min_leaf_size)
-            self.right = Decision_Tree(depth = self.depth - 1, min_leaf_size = self.min_leaf_size)
+            self.left = Decision_Tree(
+                depth=self.depth - 1, min_leaf_size=self.min_leaf_size
+            )
+            self.right = Decision_Tree(
+                depth=self.depth - 1, min_leaf_size=self.min_leaf_size
+            )
             self.left.train(left_X, left_y)
             self.right.train(right_X, right_y)
         else:
@@ -113,17 +117,18 @@ def predict(self, x):
             print("Error: Decision tree not yet trained")
             return None
 
+
 def main():
     """
     In this demonstration we're generating a sample data set from the sin function in numpy.
     We then train a decision tree on the data set and use the decision tree to predict the
     label of 10 different test values. Then the mean squared error over this test is displayed.
     """
-    X = np.arange(-1., 1., 0.005)
+    X = np.arange(-1.0, 1.0, 0.005)
     y = np.sin(X)
 
-    tree = Decision_Tree(depth = 10, min_leaf_size = 10)
-    tree.train(X,y)
+    tree = Decision_Tree(depth=10, min_leaf_size=10)
+    tree.train(X, y)
 
     test_cases = (np.random.rand(10) * 2) - 1
     predictions = np.array([tree.predict(x) for x in test_cases])
@@ -134,5 +139,5 @@ def main():
     print("Average error: " + str(avg_error))
 
 
-if __name__ == '__main__':
-    main()
\ No newline at end of file
+if __name__ == "__main__":
+    main()
diff --git a/machine_learning/gradient_descent.py b/machine_learning/gradient_descent.py
index 9a17113b7ddb..811cc68467f9 100644
--- a/machine_learning/gradient_descent.py
+++ b/machine_learning/gradient_descent.py
@@ -4,21 +4,28 @@
 import numpy
 
 # List of input, output pairs
-train_data = (((5, 2, 3), 15), ((6, 5, 9), 25),
-              ((11, 12, 13), 41), ((1, 1, 1), 8), ((11, 12, 13), 41))
+train_data = (
+    ((5, 2, 3), 15),
+    ((6, 5, 9), 25),
+    ((11, 12, 13), 41),
+    ((1, 1, 1), 8),
+    ((11, 12, 13), 41),
+)
 test_data = (((515, 22, 13), 555), ((61, 35, 49), 150))
 parameter_vector = [2, 4, 1, 5]
 m = len(train_data)
 LEARNING_RATE = 0.009
 
 
-def _error(example_no, data_set='train'):
+def _error(example_no, data_set="train"):
     """
     :param data_set: train data or test data
     :param example_no: example number whose error has to be checked
     :return: error in example pointed by example number.
     """
-    return calculate_hypothesis_value(example_no, data_set) - output(example_no, data_set)
+    return calculate_hypothesis_value(example_no, data_set) - output(
+        example_no, data_set
+    )
 
 
 def _hypothesis_value(data_input_tuple):
@@ -32,7 +39,7 @@ def _hypothesis_value(data_input_tuple):
     """
     hyp_val = 0
     for i in range(len(parameter_vector) - 1):
-        hyp_val += data_input_tuple[i]*parameter_vector[i+1]
+        hyp_val += data_input_tuple[i] * parameter_vector[i + 1]
     hyp_val += parameter_vector[0]
     return hyp_val
 
@@ -43,9 +50,9 @@ def output(example_no, data_set):
     :param example_no: example whose output is to be fetched
     :return: output for that example
     """
-    if data_set == 'train':
+    if data_set == "train":
         return train_data[example_no][1]
-    elif data_set == 'test':
+    elif data_set == "test":
         return test_data[example_no][1]
 
 
@@ -75,7 +82,7 @@ def summation_of_cost_derivative(index, end=m):
         if index == -1:
             summation_value += _error(i)
         else:
-            summation_value += _error(i)*train_data[i][0][index]
+            summation_value += _error(i) * train_data[i][0][index]
     return summation_value
 
 
@@ -85,7 +92,7 @@ def get_cost_derivative(index):
     :return: derivative wrt to that index
     Note: If index is -1, this means we are calculating summation wrt to biased parameter.
     """
-    cost_derivative_value = summation_of_cost_derivative(index, m)/m
+    cost_derivative_value = summation_of_cost_derivative(index, m) / m
     return cost_derivative_value
 
 
@@ -99,11 +106,16 @@ def run_gradient_descent():
         j += 1
         temp_parameter_vector = [0, 0, 0, 0]
         for i in range(0, len(parameter_vector)):
-            cost_derivative = get_cost_derivative(i-1)
-            temp_parameter_vector[i] = parameter_vector[i] - \
-                LEARNING_RATE*cost_derivative
-        if numpy.allclose(parameter_vector, temp_parameter_vector,
-                          atol=absolute_error_limit, rtol=relative_error_limit):
+            cost_derivative = get_cost_derivative(i - 1)
+            temp_parameter_vector[i] = (
+                parameter_vector[i] - LEARNING_RATE * cost_derivative
+            )
+        if numpy.allclose(
+            parameter_vector,
+            temp_parameter_vector,
+            atol=absolute_error_limit,
+            rtol=relative_error_limit,
+        ):
             break
         parameter_vector = temp_parameter_vector
     print(("Number of iterations:", j))
@@ -111,11 +123,11 @@ def run_gradient_descent():
 
 def test_gradient_descent():
     for i in range(len(test_data)):
-        print(("Actual output value:", output(i, 'test')))
-        print(("Hypothesis output:", calculate_hypothesis_value(i, 'test')))
+        print(("Actual output value:", output(i, "test")))
+        print(("Hypothesis output:", calculate_hypothesis_value(i, "test")))
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     run_gradient_descent()
     print("\nTesting gradient descent for a linear hypothesis function.\n")
     test_gradient_descent()
diff --git a/machine_learning/k_means_clust.py b/machine_learning/k_means_clust.py
index d0ce0f2599e0..4c643226b213 100644
--- a/machine_learning/k_means_clust.py
+++ b/machine_learning/k_means_clust.py
@@ -1,4 +1,4 @@
-'''README, Author - Anurag Kumar(mailto:anuragkumarak95@gmail.com)
+"""README, Author - Anurag Kumar(mailto:anuragkumarak95@gmail.com)
 
 Requirements:
   - sklearn
@@ -45,17 +45,18 @@
 
   5. Have fun..
 
-'''
+"""
 from sklearn.metrics import pairwise_distances
 import numpy as np
 
-TAG = 'K-MEANS-CLUST/ '
+TAG = "K-MEANS-CLUST/ "
+
 
 def get_initial_centroids(data, k, seed=None):
-    '''Randomly choose k data points as initial centroids'''
-    if seed is not None: # useful for obtaining consistent results
+    """Randomly choose k data points as initial centroids"""
+    if seed is not None:  # useful for obtaining consistent results
         np.random.seed(seed)
-    n = data.shape[0] # number of data points
+    n = data.shape[0]  # number of data points
 
     # Pick K indices from range [0, N).
     rand_indices = np.random.randint(0, n, k)
@@ -63,30 +64,33 @@ def get_initial_centroids(data, k, seed=None):
     # Keep centroids as dense format, as many entries will be nonzero due to averaging.
     # As long as at least one document in a cluster contains a word,
     # it will carry a nonzero weight in the TF-IDF vector of the centroid.
-    centroids = data[rand_indices,:]
+    centroids = data[rand_indices, :]
 
     return centroids
 
-def centroid_pairwise_dist(X,centroids):
-    return pairwise_distances(X,centroids,metric='euclidean')
+
+def centroid_pairwise_dist(X, centroids):
+    return pairwise_distances(X, centroids, metric="euclidean")
+
 
 def assign_clusters(data, centroids):
 
     # Compute distances between each data point and the set of centroids:
     # Fill in the blank (RHS only)
-    distances_from_centroids = centroid_pairwise_dist(data,centroids)
+    distances_from_centroids = centroid_pairwise_dist(data, centroids)
 
     # Compute cluster assignments for each data point:
     # Fill in the blank (RHS only)
-    cluster_assignment = np.argmin(distances_from_centroids,axis=1)
+    cluster_assignment = np.argmin(distances_from_centroids, axis=1)
 
     return cluster_assignment
 
+
 def revise_centroids(data, k, cluster_assignment):
     new_centroids = []
     for i in range(k):
         # Select all data points that belong to cluster i. Fill in the blank (RHS only)
-        member_data_points = data[cluster_assignment==i]
+        member_data_points = data[cluster_assignment == i]
         # Compute the mean of the data points. Fill in the blank (RHS only)
         centroid = member_data_points.mean(axis=0)
         new_centroids.append(centroid)
@@ -94,79 +98,102 @@ def revise_centroids(data, k, cluster_assignment):
 
     return new_centroids
 
+
 def compute_heterogeneity(data, k, centroids, cluster_assignment):
 
     heterogeneity = 0.0
     for i in range(k):
 
         # Select all data points that belong to cluster i. Fill in the blank (RHS only)
-        member_data_points = data[cluster_assignment==i, :]
+        member_data_points = data[cluster_assignment == i, :]
 
-        if member_data_points.shape[0] > 0: # check if i-th cluster is non-empty
+        if member_data_points.shape[0] > 0:  # check if i-th cluster is non-empty
             # Compute distances from centroid to data points (RHS only)
-            distances = pairwise_distances(member_data_points, [centroids[i]], metric='euclidean')
-            squared_distances = distances**2
+            distances = pairwise_distances(
+                member_data_points, [centroids[i]], metric="euclidean"
+            )
+            squared_distances = distances ** 2
             heterogeneity += np.sum(squared_distances)
 
     return heterogeneity
 
+
 from matplotlib import pyplot as plt
+
+
 def plot_heterogeneity(heterogeneity, k):
-    plt.figure(figsize=(7,4))
+    plt.figure(figsize=(7, 4))
     plt.plot(heterogeneity, linewidth=4)
-    plt.xlabel('# Iterations')
-    plt.ylabel('Heterogeneity')
-    plt.title('Heterogeneity of clustering over time, K={0:d}'.format(k))
-    plt.rcParams.update({'font.size': 16})
+    plt.xlabel("# Iterations")
+    plt.ylabel("Heterogeneity")
+    plt.title("Heterogeneity of clustering over time, K={0:d}".format(k))
+    plt.rcParams.update({"font.size": 16})
     plt.show()
 
-def kmeans(data, k, initial_centroids, maxiter=500, record_heterogeneity=None, verbose=False):
-    '''This function runs k-means on given data and initial set of centroids.
+
+def kmeans(
+    data, k, initial_centroids, maxiter=500, record_heterogeneity=None, verbose=False
+):
+    """This function runs k-means on given data and initial set of centroids.
        maxiter: maximum number of iterations to run.(default=500)
        record_heterogeneity: (optional) a list, to store the history of heterogeneity as function of iterations
                              if None, do not store the history.
-       verbose: if True, print how many data points changed their cluster labels in each iteration'''
+       verbose: if True, print how many data points changed their cluster labels in each iteration"""
     centroids = initial_centroids[:]
     prev_cluster_assignment = None
 
     for itr in range(maxiter):
         if verbose:
-            print(itr, end='')
+            print(itr, end="")
 
         # 1. Make cluster assignments using nearest centroids
-        cluster_assignment = assign_clusters(data,centroids)
+        cluster_assignment = assign_clusters(data, centroids)
 
         # 2. Compute a new centroid for each of the k clusters, averaging all data points assigned to that cluster.
-        centroids = revise_centroids(data,k, cluster_assignment)
+        centroids = revise_centroids(data, k, cluster_assignment)
 
         # Check for convergence: if none of the assignments changed, stop
-        if prev_cluster_assignment is not None and \
-          (prev_cluster_assignment==cluster_assignment).all():
+        if (
+            prev_cluster_assignment is not None
+            and (prev_cluster_assignment == cluster_assignment).all()
+        ):
             break
 
         # Print number of new assignments
         if prev_cluster_assignment is not None:
-            num_changed = np.sum(prev_cluster_assignment!=cluster_assignment)
+            num_changed = np.sum(prev_cluster_assignment != cluster_assignment)
             if verbose:
-                print('    {0:5d} elements changed their cluster assignment.'.format(num_changed))
+                print(
+                    "    {0:5d} elements changed their cluster assignment.".format(
+                        num_changed
+                    )
+                )
 
         # Record heterogeneity convergence metric
         if record_heterogeneity is not None:
             # YOUR CODE HERE
-            score = compute_heterogeneity(data,k,centroids,cluster_assignment)
+            score = compute_heterogeneity(data, k, centroids, cluster_assignment)
             record_heterogeneity.append(score)
 
         prev_cluster_assignment = cluster_assignment[:]
 
     return centroids, cluster_assignment
 
+
 # Mock test below
-if False: # change to true to run this test case.
+if False:  # change to true to run this test case.
     import sklearn.datasets as ds
+
     dataset = ds.load_iris()
     k = 3
     heterogeneity = []
-    initial_centroids = get_initial_centroids(dataset['data'], k, seed=0)
-    centroids, cluster_assignment = kmeans(dataset['data'], k, initial_centroids, maxiter=400,
-                                        record_heterogeneity=heterogeneity, verbose=True)
+    initial_centroids = get_initial_centroids(dataset["data"], k, seed=0)
+    centroids, cluster_assignment = kmeans(
+        dataset["data"],
+        k,
+        initial_centroids,
+        maxiter=400,
+        record_heterogeneity=heterogeneity,
+        verbose=True,
+    )
     plot_heterogeneity(heterogeneity, k)
diff --git a/machine_learning/knn_sklearn.py b/machine_learning/knn_sklearn.py
index 64582564304f..a371e30f5403 100644
--- a/machine_learning/knn_sklearn.py
+++ b/machine_learning/knn_sklearn.py
@@ -2,27 +2,30 @@
 from sklearn.datasets import load_iris
 from sklearn.neighbors import KNeighborsClassifier
 
-#Load iris file
+# Load iris file
 iris = load_iris()
 iris.keys()
 
 
-print('Target names: \n {} '.format(iris.target_names))
-print('\n Features: \n {}'.format(iris.feature_names))
+print("Target names: \n {} ".format(iris.target_names))
+print("\n Features: \n {}".format(iris.feature_names))
 
-#Train set e Test set
-X_train, X_test, y_train, y_test = train_test_split(iris['data'],iris['target'], random_state=4)
+# Train set e Test set
+X_train, X_test, y_train, y_test = train_test_split(
+    iris["data"], iris["target"], random_state=4
+)
 
-#KNN
+# KNN
 
-knn = KNeighborsClassifier (n_neighbors = 1)
+knn = KNeighborsClassifier(n_neighbors=1)
 knn.fit(X_train, y_train)
 
-#new array to test
-X_new = [[1,2,1,4],
-		 [2,3,4,5]]	
+# new array to test
+X_new = [[1, 2, 1, 4], [2, 3, 4, 5]]
 
 prediction = knn.predict(X_new)
 
-print('\nNew array: \n {}'
-	  '\n\nTarget Names Prediction: \n {}'.format(X_new, iris['target_names'][prediction]))
+print(
+    "\nNew array: \n {}"
+    "\n\nTarget Names Prediction: \n {}".format(X_new, iris["target_names"][prediction])
+)
diff --git a/machine_learning/linear_regression.py b/machine_learning/linear_regression.py
index 9d9738fced8d..b666feddccc7 100644
--- a/machine_learning/linear_regression.py
+++ b/machine_learning/linear_regression.py
@@ -16,21 +16,22 @@ def collect_dataset():
     The dataset contains ADR vs Rating of a Player
     :return : dataset obtained from the link, as matrix
     """
-    response = requests.get('https://raw.githubusercontent.com/yashLadha/' +
-                            'The_Math_of_Intelligence/master/Week1/ADRvs' +
-                            'Rating.csv')
+    response = requests.get(
+        "https://raw.githubusercontent.com/yashLadha/"
+        + "The_Math_of_Intelligence/master/Week1/ADRvs"
+        + "Rating.csv"
+    )
     lines = response.text.splitlines()
     data = []
     for item in lines:
-        item = item.split(',')
+        item = item.split(",")
         data.append(item)
     data.pop(0)  # This is for removing the labels from the list
     dataset = np.matrix(data)
     return dataset
 
 
-def run_steep_gradient_descent(data_x, data_y,
-                               len_data, alpha, theta):
+def run_steep_gradient_descent(data_x, data_y, len_data, alpha, theta):
     """ Run steep gradient descent and updates the Feature vector accordingly_
     :param data_x   : contains the dataset
     :param data_y   : contains the output associated with each data-entry
@@ -79,10 +80,9 @@ def run_linear_regression(data_x, data_y):
     theta = np.zeros((1, no_features))
 
     for i in range(0, iterations):
-        theta = run_steep_gradient_descent(data_x, data_y,
-                                           len_data, alpha, theta)
+        theta = run_steep_gradient_descent(data_x, data_y, len_data, alpha, theta)
         error = sum_of_square_error(data_x, data_y, len_data, theta)
-        print('At Iteration %d - Error is %.5f ' % (i + 1, error))
+        print("At Iteration %d - Error is %.5f " % (i + 1, error))
 
     return theta
 
@@ -97,10 +97,10 @@ def main():
 
     theta = run_linear_regression(data_x, data_y)
     len_result = theta.shape[1]
-    print('Resultant Feature vector : ')
+    print("Resultant Feature vector : ")
     for i in range(0, len_result):
-        print('%.5f' % (theta[0, i]))
+        print("%.5f" % (theta[0, i]))
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
diff --git a/machine_learning/logistic_regression.py b/machine_learning/logistic_regression.py
index b2749f1be260..f23d400ced55 100644
--- a/machine_learning/logistic_regression.py
+++ b/machine_learning/logistic_regression.py
@@ -9,8 +9,8 @@
 
 # importing all the required libraries
 
-''' Implementing logistic regression for classification problem
-     Helpful resources : 1.Coursera ML course    2.https://medium.com/@martinpella/logistic-regression-from-scratch-in-python-124c5636b8ac'''
+""" Implementing logistic regression for classification problem
+     Helpful resources : 1.Coursera ML course    2.https://medium.com/@martinpella/logistic-regression-from-scratch-in-python-124c5636b8ac"""
 
 import numpy as np
 import matplotlib.pyplot as plt
@@ -24,6 +24,7 @@
 
 # sigmoid function or logistic function is used as a hypothesis function in classification problems
 
+
 def sigmoid_function(z):
     return 1 / (1 + np.exp(-z))
 
@@ -31,17 +32,14 @@ def sigmoid_function(z):
 def cost_function(h, y):
     return (-y * np.log(h) - (1 - y) * np.log(1 - h)).mean()
 
+
 def log_likelihood(X, Y, weights):
     scores = np.dot(X, weights)
-    return np.sum(Y*scores - np.log(1 + np.exp(scores)) )
+    return np.sum(Y * scores - np.log(1 + np.exp(scores)))
+
 
 # here alpha is the learning rate, X is the feature matrix,y is the target matrix
-def logistic_reg(
-    alpha,
-    X,
-    y,
-    max_iterations=70000,
-    ):
+def logistic_reg(alpha, X, y, max_iterations=70000):
     theta = np.zeros(X.shape[1])
 
     for iterations in range(max_iterations):
@@ -53,42 +51,35 @@ def logistic_reg(
         h = sigmoid_function(z)
         J = cost_function(h, y)
         if iterations % 100 == 0:
-            print(f'loss: {J} \t')  # printing the loss after every 100 iterations
+            print(f"loss: {J} \t")  # printing the loss after every 100 iterations
     return theta
 
+
 # In[68]:
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     iris = datasets.load_iris()
     X = iris.data[:, :2]
     y = (iris.target != 0) * 1
 
     alpha = 0.1
-    theta = logistic_reg(alpha,X,y,max_iterations=70000)
-    print("theta: ",theta)  # printing the theta i.e our weights vector
-
+    theta = logistic_reg(alpha, X, y, max_iterations=70000)
+    print("theta: ", theta)  # printing the theta i.e our weights vector
 
     def predict_prob(X):
-        return sigmoid_function(np.dot(X, theta))  # predicting the value of probability from the logistic regression algorithm
-
+        return sigmoid_function(
+            np.dot(X, theta)
+        )  # predicting the value of probability from the logistic regression algorithm
 
     plt.figure(figsize=(10, 6))
-    plt.scatter(X[y == 0][:, 0], X[y == 0][:, 1], color='b', label='0')
-    plt.scatter(X[y == 1][:, 0], X[y == 1][:, 1], color='r', label='1')
+    plt.scatter(X[y == 0][:, 0], X[y == 0][:, 1], color="b", label="0")
+    plt.scatter(X[y == 1][:, 0], X[y == 1][:, 1], color="r", label="1")
     (x1_min, x1_max) = (X[:, 0].min(), X[:, 0].max())
     (x2_min, x2_max) = (X[:, 1].min(), X[:, 1].max())
-    (xx1, xx2) = np.meshgrid(np.linspace(x1_min, x1_max),
-                             np.linspace(x2_min, x2_max))
+    (xx1, xx2) = np.meshgrid(np.linspace(x1_min, x1_max), np.linspace(x2_min, x2_max))
     grid = np.c_[xx1.ravel(), xx2.ravel()]
     probs = predict_prob(grid).reshape(xx1.shape)
-    plt.contour(
-        xx1,
-        xx2,
-        probs,
-        [0.5],
-        linewidths=1,
-        colors='black',
-        )
+    plt.contour(xx1, xx2, probs, [0.5], linewidths=1, colors="black")
 
     plt.legend()
     plt.show()
diff --git a/machine_learning/random_forest_classification/random_forest_classification.py b/machine_learning/random_forest_classification/random_forest_classification.py
index 81016387ecc7..6aed4e6e66de 100644
--- a/machine_learning/random_forest_classification/random_forest_classification.py
+++ b/machine_learning/random_forest_classification/random_forest_classification.py
@@ -8,23 +8,30 @@
 
 # Importing the dataset
 script_dir = os.path.dirname(os.path.realpath(__file__))
-dataset = pd.read_csv(os.path.join(script_dir, 'Social_Network_Ads.csv'))
+dataset = pd.read_csv(os.path.join(script_dir, "Social_Network_Ads.csv"))
 X = dataset.iloc[:, [2, 3]].values
 y = dataset.iloc[:, 4].values
 
 # Splitting the dataset into the Training set and Test set
 from sklearn.model_selection import train_test_split
-X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25, random_state = 0)
+
+X_train, X_test, y_train, y_test = train_test_split(
+    X, y, test_size=0.25, random_state=0
+)
 
 # Feature Scaling
 from sklearn.preprocessing import StandardScaler
+
 sc = StandardScaler()
 X_train = sc.fit_transform(X_train)
 X_test = sc.transform(X_test)
 
 # Fitting Random Forest Classification to the Training set
 from sklearn.ensemble import RandomForestClassifier
-classifier = RandomForestClassifier(n_estimators = 10, criterion = 'entropy', random_state = 0)
+
+classifier = RandomForestClassifier(
+    n_estimators=10, criterion="entropy", random_state=0
+)
 classifier.fit(X_train, y_train)
 
 # Predicting the Test set results
@@ -32,40 +39,65 @@
 
 # Making the Confusion Matrix
 from sklearn.metrics import confusion_matrix
+
 cm = confusion_matrix(y_test, y_pred)
 
 # Visualising the Training set results
 from matplotlib.colors import ListedColormap
+
 X_set, y_set = X_train, y_train
-X1, X2 = np.meshgrid(np.arange(start = X_set[:, 0].min() - 1, stop = X_set[:, 0].max() + 1, step = 0.01),
-                     np.arange(start = X_set[:, 1].min() - 1, stop = X_set[:, 1].max() + 1, step = 0.01))
-plt.contourf(X1, X2, classifier.predict(np.array([X1.ravel(), X2.ravel()]).T).reshape(X1.shape),
-             alpha = 0.75, cmap = ListedColormap(('red', 'green')))
+X1, X2 = np.meshgrid(
+    np.arange(start=X_set[:, 0].min() - 1, stop=X_set[:, 0].max() + 1, step=0.01),
+    np.arange(start=X_set[:, 1].min() - 1, stop=X_set[:, 1].max() + 1, step=0.01),
+)
+plt.contourf(
+    X1,
+    X2,
+    classifier.predict(np.array([X1.ravel(), X2.ravel()]).T).reshape(X1.shape),
+    alpha=0.75,
+    cmap=ListedColormap(("red", "green")),
+)
 plt.xlim(X1.min(), X1.max())
 plt.ylim(X2.min(), X2.max())
 for i, j in enumerate(np.unique(y_set)):
-    plt.scatter(X_set[y_set == j, 0], X_set[y_set == j, 1],
-                c = ListedColormap(('red', 'green'))(i), label = j)
-plt.title('Random Forest Classification (Training set)')
-plt.xlabel('Age')
-plt.ylabel('Estimated Salary')
+    plt.scatter(
+        X_set[y_set == j, 0],
+        X_set[y_set == j, 1],
+        c=ListedColormap(("red", "green"))(i),
+        label=j,
+    )
+plt.title("Random Forest Classification (Training set)")
+plt.xlabel("Age")
+plt.ylabel("Estimated Salary")
 plt.legend()
 plt.show()
 
 # Visualising the Test set results
 from matplotlib.colors import ListedColormap
+
 X_set, y_set = X_test, y_test
-X1, X2 = np.meshgrid(np.arange(start = X_set[:, 0].min() - 1, stop = X_set[:, 0].max() + 1, step = 0.01),
-                     np.arange(start = X_set[:, 1].min() - 1, stop = X_set[:, 1].max() + 1, step = 0.01))
-plt.contourf(X1, X2, classifier.predict(np.array([X1.ravel(), X2.ravel()]).T).reshape(X1.shape),
-             alpha = 0.75, cmap = ListedColormap(('red', 'green')))
+X1, X2 = np.meshgrid(
+    np.arange(start=X_set[:, 0].min() - 1, stop=X_set[:, 0].max() + 1, step=0.01),
+    np.arange(start=X_set[:, 1].min() - 1, stop=X_set[:, 1].max() + 1, step=0.01),
+)
+plt.contourf(
+    X1,
+    X2,
+    classifier.predict(np.array([X1.ravel(), X2.ravel()]).T).reshape(X1.shape),
+    alpha=0.75,
+    cmap=ListedColormap(("red", "green")),
+)
 plt.xlim(X1.min(), X1.max())
 plt.ylim(X2.min(), X2.max())
 for i, j in enumerate(np.unique(y_set)):
-    plt.scatter(X_set[y_set == j, 0], X_set[y_set == j, 1],
-                c = ListedColormap(('red', 'green'))(i), label = j)
-plt.title('Random Forest Classification (Test set)')
-plt.xlabel('Age')
-plt.ylabel('Estimated Salary')
+    plt.scatter(
+        X_set[y_set == j, 0],
+        X_set[y_set == j, 1],
+        c=ListedColormap(("red", "green"))(i),
+        label=j,
+    )
+plt.title("Random Forest Classification (Test set)")
+plt.xlabel("Age")
+plt.ylabel("Estimated Salary")
 plt.legend()
 plt.show()
diff --git a/machine_learning/random_forest_regression/random_forest_regression.py b/machine_learning/random_forest_regression/random_forest_regression.py
index 85ce0676b598..2599e97e957e 100644
--- a/machine_learning/random_forest_regression/random_forest_regression.py
+++ b/machine_learning/random_forest_regression/random_forest_regression.py
@@ -8,7 +8,7 @@
 
 # Importing the dataset
 script_dir = os.path.dirname(os.path.realpath(__file__))
-dataset = pd.read_csv(os.path.join(script_dir, 'Position_Salaries.csv'))
+dataset = pd.read_csv(os.path.join(script_dir, "Position_Salaries.csv"))
 X = dataset.iloc[:, 1:2].values
 y = dataset.iloc[:, 2].values
 
@@ -26,7 +26,8 @@
 
 # Fitting Random Forest Regression to the dataset
 from sklearn.ensemble import RandomForestRegressor
-regressor = RandomForestRegressor(n_estimators = 10, random_state = 0)
+
+regressor = RandomForestRegressor(n_estimators=10, random_state=0)
 regressor.fit(X, y)
 
 # Predicting a new result
@@ -35,9 +36,9 @@
 # Visualising the Random Forest Regression results (higher resolution)
 X_grid = np.arange(min(X), max(X), 0.01)
 X_grid = X_grid.reshape((len(X_grid), 1))
-plt.scatter(X, y, color = 'red')
-plt.plot(X_grid, regressor.predict(X_grid), color = 'blue')
-plt.title('Truth or Bluff (Random Forest Regression)')
-plt.xlabel('Position level')
-plt.ylabel('Salary')
+plt.scatter(X, y, color="red")
+plt.plot(X_grid, regressor.predict(X_grid), color="blue")
+plt.title("Truth or Bluff (Random Forest Regression)")
+plt.xlabel("Position level")
+plt.ylabel("Salary")
 plt.show()
diff --git a/machine_learning/scoring_functions.py b/machine_learning/scoring_functions.py
index a2d97b09ded2..2b24287b3726 100755
--- a/machine_learning/scoring_functions.py
+++ b/machine_learning/scoring_functions.py
@@ -14,7 +14,7 @@
     and types of data
 """
 
-#Mean Absolute Error
+# Mean Absolute Error
 def mae(predict, actual):
     predict = np.array(predict)
     actual = np.array(actual)
@@ -24,7 +24,8 @@ def mae(predict, actual):
 
     return score
 
-#Mean Squared Error
+
+# Mean Squared Error
 def mse(predict, actual):
     predict = np.array(predict)
     actual = np.array(actual)
@@ -35,7 +36,8 @@ def mse(predict, actual):
     score = square_diff.mean()
     return score
 
-#Root Mean Squared Error
+
+# Root Mean Squared Error
 def rmse(predict, actual):
     predict = np.array(predict)
     actual = np.array(actual)
@@ -46,13 +48,14 @@ def rmse(predict, actual):
     score = np.sqrt(mean_square_diff)
     return score
 
-#Root Mean Square Logarithmic Error
+
+# Root Mean Square Logarithmic Error
 def rmsle(predict, actual):
     predict = np.array(predict)
     actual = np.array(actual)
 
-    log_predict = np.log(predict+1)
-    log_actual = np.log(actual+1)
+    log_predict = np.log(predict + 1)
+    log_actual = np.log(actual + 1)
 
     difference = log_predict - log_actual
     square_diff = np.square(difference)
@@ -62,14 +65,15 @@ def rmsle(predict, actual):
 
     return score
 
-#Mean Bias Deviation
+
+# Mean Bias Deviation
 def mbd(predict, actual):
     predict = np.array(predict)
     actual = np.array(actual)
 
     difference = predict - actual
-    numerator = np.sum(difference) / len(predict) 
-    denumerator =  np.sum(actual) / len(predict)
+    numerator = np.sum(difference) / len(predict)
+    denumerator = np.sum(actual) / len(predict)
     print(numerator)
     print(denumerator)
 
diff --git a/machine_learning/sequential_minimum_optimization.py b/machine_learning/sequential_minimum_optimization.py
index 0b5d788e92e1..1d4e4a276bc1 100644
--- a/machine_learning/sequential_minimum_optimization.py
+++ b/machine_learning/sequential_minimum_optimization.py
@@ -41,11 +41,20 @@
 from sklearn.datasets import make_blobs, make_circles
 from sklearn.preprocessing import StandardScaler
 
-CANCER_DATASET_URL = 'http://archive.ics.uci.edu/ml/machine-learning-databases/breast-cancer-wisconsin/wdbc.data'
+CANCER_DATASET_URL = "http://archive.ics.uci.edu/ml/machine-learning-databases/breast-cancer-wisconsin/wdbc.data"
 
 
 class SmoSVM(object):
-    def __init__(self, train, kernel_func, alpha_list=None, cost=0.4, b=0.0, tolerance=0.001, auto_norm=True):
+    def __init__(
+        self,
+        train,
+        kernel_func,
+        alpha_list=None,
+        cost=0.4,
+        b=0.0,
+        tolerance=0.001,
+        auto_norm=True,
+    ):
         self._init = True
         self._auto_norm = auto_norm
         self._c = np.float64(cost)
@@ -91,13 +100,25 @@ def fit(self):
             self.alphas[i1], self.alphas[i2] = a1_new, a2_new
 
             # 3: update threshold(b)
-            b1_new = np.float64(-e1 - y1 * K(i1, i1) * (a1_new - a1) - y2 * K(i2, i1) * (a2_new - a2) + self._b)
-            b2_new = np.float64(-e2 - y2 * K(i2, i2) * (a2_new - a2) - y1 * K(i1, i2) * (a1_new - a1) + self._b)
+            b1_new = np.float64(
+                -e1
+                - y1 * K(i1, i1) * (a1_new - a1)
+                - y2 * K(i2, i1) * (a2_new - a2)
+                + self._b
+            )
+            b2_new = np.float64(
+                -e2
+                - y2 * K(i2, i2) * (a2_new - a2)
+                - y1 * K(i1, i2) * (a1_new - a1)
+                + self._b
+            )
             if 0.0 < a1_new < self._c:
                 b = b1_new
             if 0.0 < a2_new < self._c:
                 b = b2_new
-            if not (np.float64(0) < a2_new < self._c) and not (np.float64(0) < a1_new < self._c):
+            if not (np.float64(0) < a2_new < self._c) and not (
+                np.float64(0) < a1_new < self._c
+            ):
                 b = (b1_new + b2_new) / 2.0
             b_old = self._b
             self._b = b
@@ -107,7 +128,11 @@ def fit(self):
             for s in self.unbound:
                 if s == i1 or s == i2:
                     continue
-                self._error[s] += y1 * (a1_new - a1) * K(i1, s) + y2 * (a2_new - a2) * K(i2, s) + (self._b - b_old)
+                self._error[s] += (
+                    y1 * (a1_new - a1) * K(i1, s)
+                    + y2 * (a2_new - a2) * K(i2, s)
+                    + (self._b - b_old)
+                )
 
             # if i1 or i2 is non-bound,update there error value to zero
             if self._is_unbound(i1):
@@ -119,7 +144,9 @@ def fit(self):
     def predict(self, test_samples, classify=True):
 
         if test_samples.shape[1] > self.samples.shape[1]:
-            raise ValueError("Test samples' feature length does not equal to that of train samples")
+            raise ValueError(
+                "Test samples' feature length does not equal to that of train samples"
+            )
 
         if self._auto_norm:
             test_samples = self._norm(test_samples)
@@ -173,14 +200,23 @@ def _calculate_k_matrix(self):
         k_matrix = np.zeros([self.length, self.length])
         for i in self._all_samples:
             for j in self._all_samples:
-                k_matrix[i, j] = np.float64(self.Kernel(self.samples[i, :], self.samples[j, :]))
+                k_matrix[i, j] = np.float64(
+                    self.Kernel(self.samples[i, :], self.samples[j, :])
+                )
         return k_matrix
 
     # Predict test sample's tag
     def _predict(self, sample):
         k = self._k
-        predicted_value = np.sum(
-            [self.alphas[i1] * self.tags[i1] * k(i1, sample) for i1 in self._all_samples]) + self._b
+        predicted_value = (
+            np.sum(
+                [
+                    self.alphas[i1] * self.tags[i1] * k(i1, sample)
+                    for i1 in self._all_samples
+                ]
+            )
+            + self._b
+        )
         return predicted_value
 
     # Choose alpha1 and alpha2
@@ -200,23 +236,27 @@ def _choose_a1(self):
         while True:
             all_not_obey = True
             # all sample
-            print('scanning all sample!')
+            print("scanning all sample!")
             for i1 in [i for i in self._all_samples if self._check_obey_kkt(i)]:
                 all_not_obey = False
                 yield from self._choose_a2(i1)
 
             # non-bound sample
-            print('scanning non-bound sample!')
+            print("scanning non-bound sample!")
             while True:
                 not_obey = True
-                for i1 in [i for i in self._all_samples if self._check_obey_kkt(i) and self._is_unbound(i)]:
+                for i1 in [
+                    i
+                    for i in self._all_samples
+                    if self._check_obey_kkt(i) and self._is_unbound(i)
+                ]:
                     not_obey = False
                     yield from self._choose_a2(i1)
                 if not_obey:
-                    print('all non-bound samples fit the KKT condition!')
+                    print("all non-bound samples fit the KKT condition!")
                     break
             if all_not_obey:
-                print('all samples fit the KKT condition! Optimization done!')
+                print("all samples fit the KKT condition! Optimization done!")
                 break
         return False
 
@@ -231,7 +271,11 @@ def _choose_a2(self, i1):
 
         if len(self.unbound) > 0:
             tmp_error = self._error.copy().tolist()
-            tmp_error_dict = {index: value for index, value in enumerate(tmp_error) if self._is_unbound(index)}
+            tmp_error_dict = {
+                index: value
+                for index, value in enumerate(tmp_error)
+                if self._is_unbound(index)
+            }
             if self._e(i1) >= 0:
                 i2 = min(tmp_error_dict, key=lambda index: tmp_error_dict[index])
             else:
@@ -289,8 +333,20 @@ def _get_new_alpha(self, i1, i2, a1, a2, e1, e2, y1, y2):
             # way 1
             f1 = y1 * (e1 + b) - a1 * K(i1, i1) - s * a2 * K(i1, i2)
             f2 = y2 * (e2 + b) - a2 * K(i2, i2) - s * a1 * K(i1, i2)
-            ol = l1 * f1 + L * f2 + 1 / 2 * l1 ** 2 * K(i1, i1) + 1 / 2 * L ** 2 * K(i2, i2) + s * L * l1 * K(i1, i2)
-            oh = h1 * f1 + H * f2 + 1 / 2 * h1 ** 2 * K(i1, i1) + 1 / 2 * H ** 2 * K(i2, i2) + s * H * h1 * K(i1, i2)
+            ol = (
+                l1 * f1
+                + L * f2
+                + 1 / 2 * l1 ** 2 * K(i1, i1)
+                + 1 / 2 * L ** 2 * K(i2, i2)
+                + s * L * l1 * K(i1, i2)
+            )
+            oh = (
+                h1 * f1
+                + H * f2
+                + 1 / 2 * h1 ** 2 * K(i1, i1)
+                + 1 / 2 * H ** 2 * K(i2, i2)
+                + s * H * h1 * K(i1, i2)
+            )
             """
             # way 2
             Use objective function check which alpha2 new could get the minimal objectives
@@ -370,14 +426,10 @@ def _rbf(self, v1, v2):
     def _check(self):
         if self._kernel == self._rbf:
             if self.gamma < 0:
-                raise ValueError('gamma value must greater than 0')
+                raise ValueError("gamma value must greater than 0")
 
     def _get_kernel(self, kernel_name):
-        maps = {
-            'linear': self._linear,
-            'poly': self._polynomial,
-            'rbf': self._rbf
-        }
+        maps = {"linear": self._linear, "poly": self._polynomial, "rbf": self._rbf}
         return maps[kernel_name]
 
     def __call__(self, v1, v2):
@@ -390,34 +442,35 @@ def __repr__(self):
 def count_time(func):
     def call_func(*args, **kwargs):
         import time
+
         start_time = time.time()
         func(*args, **kwargs)
         end_time = time.time()
-        print('smo algorithm cost {} seconds'.format(end_time - start_time))
+        print("smo algorithm cost {} seconds".format(end_time - start_time))
 
     return call_func
 
 
 @count_time
 def test_cancel_data():
-    print('Hello!\r\nStart test svm by smo algorithm!')
+    print("Hello!\r\nStart test svm by smo algorithm!")
     # 0: download dataset and load into pandas' dataframe
-    if not os.path.exists(r'cancel_data.csv'):
+    if not os.path.exists(r"cancel_data.csv"):
         request = urllib.request.Request(
             CANCER_DATASET_URL,
-            headers={'User-Agent': 'Mozilla/4.0 (compatible; MSIE 5.5; Windows NT)'}
+            headers={"User-Agent": "Mozilla/4.0 (compatible; MSIE 5.5; Windows NT)"},
         )
         response = urllib.request.urlopen(request)
-        content = response.read().decode('utf-8')
-        with open(r'cancel_data.csv', 'w') as f:
+        content = response.read().decode("utf-8")
+        with open(r"cancel_data.csv", "w") as f:
             f.write(content)
 
-    data = pd.read_csv(r'cancel_data.csv', header=None)
+    data = pd.read_csv(r"cancel_data.csv", header=None)
 
     # 1: pre-processing data
     del data[data.columns.tolist()[0]]
     data = data.dropna(axis=0)
-    data = data.replace({'M': np.float64(1), 'B': np.float64(-1)})
+    data = data.replace({"M": np.float64(1), "B": np.float64(-1)})
     samples = np.array(data)[:, :]
 
     # 2: deviding data into train_data data and test_data data
@@ -425,11 +478,18 @@ def test_cancel_data():
     test_tags, test_samples = test_data[:, 0], test_data[:, 1:]
 
     # 3: choose kernel function,and set initial alphas to zero(optional)
-    mykernel = Kernel(kernel='rbf', degree=5, coef0=1, gamma=0.5)
+    mykernel = Kernel(kernel="rbf", degree=5, coef0=1, gamma=0.5)
     al = np.zeros(train_data.shape[0])
 
     # 4: calculating best alphas using SMO algorithm and predict test_data samples
-    mysvm = SmoSVM(train=train_data, kernel_func=mykernel, alpha_list=al, cost=0.4, b=0.0, tolerance=0.001)
+    mysvm = SmoSVM(
+        train=train_data,
+        kernel_func=mykernel,
+        alpha_list=al,
+        cost=0.4,
+        b=0.0,
+        tolerance=0.001,
+    )
     mysvm.fit()
     predict = mysvm.predict(test_samples)
 
@@ -439,14 +499,18 @@ def test_cancel_data():
     for i in range(test_tags.shape[0]):
         if test_tags[i] == predict[i]:
             score += 1
-    print('\r\nall: {}\r\nright: {}\r\nfalse: {}'.format(test_num, score, test_num - score))
+    print(
+        "\r\nall: {}\r\nright: {}\r\nfalse: {}".format(
+            test_num, score, test_num - score
+        )
+    )
     print("Rough Accuracy: {}".format(score / test_tags.shape[0]))
 
 
 def test_demonstration():
     # change stdout
-    print('\r\nStart plot,please wait!!!')
-    sys.stdout = open(os.devnull, 'w')
+    print("\r\nStart plot,please wait!!!")
+    sys.stdout = open(os.devnull, "w")
 
     ax1 = plt.subplot2grid((2, 2), (0, 0))
     ax2 = plt.subplot2grid((2, 2), (0, 1))
@@ -464,32 +528,50 @@ def test_demonstration():
     sys.stdout = sys.__stdout__
     print("Plot done!!!")
 
+
 def test_linear_kernel(ax, cost):
-    train_x, train_y = make_blobs(n_samples=500, centers=2,
-                                  n_features=2, random_state=1)
+    train_x, train_y = make_blobs(
+        n_samples=500, centers=2, n_features=2, random_state=1
+    )
     train_y[train_y == 0] = -1
     scaler = StandardScaler()
     train_x_scaled = scaler.fit_transform(train_x, train_y)
     train_data = np.hstack((train_y.reshape(500, 1), train_x_scaled))
-    mykernel = Kernel(kernel='linear', degree=5, coef0=1, gamma=0.5)
-    mysvm = SmoSVM(train=train_data, kernel_func=mykernel, cost=cost, tolerance=0.001, auto_norm=False)
+    mykernel = Kernel(kernel="linear", degree=5, coef0=1, gamma=0.5)
+    mysvm = SmoSVM(
+        train=train_data,
+        kernel_func=mykernel,
+        cost=cost,
+        tolerance=0.001,
+        auto_norm=False,
+    )
     mysvm.fit()
     plot_partition_boundary(mysvm, train_data, ax=ax)
 
 
 def test_rbf_kernel(ax, cost):
-    train_x, train_y = make_circles(n_samples=500, noise=0.1, factor=0.1, random_state=1)
+    train_x, train_y = make_circles(
+        n_samples=500, noise=0.1, factor=0.1, random_state=1
+    )
     train_y[train_y == 0] = -1
     scaler = StandardScaler()
     train_x_scaled = scaler.fit_transform(train_x, train_y)
     train_data = np.hstack((train_y.reshape(500, 1), train_x_scaled))
-    mykernel = Kernel(kernel='rbf', degree=5, coef0=1, gamma=0.5)
-    mysvm = SmoSVM(train=train_data, kernel_func=mykernel, cost=cost, tolerance=0.001, auto_norm=False)
+    mykernel = Kernel(kernel="rbf", degree=5, coef0=1, gamma=0.5)
+    mysvm = SmoSVM(
+        train=train_data,
+        kernel_func=mykernel,
+        cost=cost,
+        tolerance=0.001,
+        auto_norm=False,
+    )
     mysvm.fit()
     plot_partition_boundary(mysvm, train_data, ax=ax)
 
 
-def plot_partition_boundary(model, train_data, ax, resolution=100, colors=('b', 'k', 'r')):
+def plot_partition_boundary(
+    model, train_data, ax, resolution=100, colors=("b", "k", "r")
+):
     """
     We can not get the optimum w of our kernel svm model which is different from linear svm.
     For this reason, we generate randomly destributed points with high desity and prediced values of these points are
@@ -502,25 +584,44 @@ def plot_partition_boundary(model, train_data, ax, resolution=100, colors=('b',
     train_data_tags = train_data[:, 0]
     xrange = np.linspace(train_data_x.min(), train_data_x.max(), resolution)
     yrange = np.linspace(train_data_y.min(), train_data_y.max(), resolution)
-    test_samples = np.array([(x, y) for x in xrange for y in yrange]).reshape(resolution * resolution, 2)
+    test_samples = np.array([(x, y) for x in xrange for y in yrange]).reshape(
+        resolution * resolution, 2
+    )
 
     test_tags = model.predict(test_samples, classify=False)
     grid = test_tags.reshape((len(xrange), len(yrange)))
 
     # Plot contour map which represents the partition boundary
-    ax.contour(xrange, yrange, np.mat(grid).T, levels=(-1, 0, 1), linestyles=('--', '-', '--'),
-               linewidths=(1, 1, 1),
-               colors=colors)
+    ax.contour(
+        xrange,
+        yrange,
+        np.mat(grid).T,
+        levels=(-1, 0, 1),
+        linestyles=("--", "-", "--"),
+        linewidths=(1, 1, 1),
+        colors=colors,
+    )
     # Plot all train samples
-    ax.scatter(train_data_x, train_data_y, c=train_data_tags, cmap=plt.cm.Dark2, lw=0, alpha=0.5)
+    ax.scatter(
+        train_data_x,
+        train_data_y,
+        c=train_data_tags,
+        cmap=plt.cm.Dark2,
+        lw=0,
+        alpha=0.5,
+    )
 
     # Plot support vectors
     support = model.support
-    ax.scatter(train_data_x[support], train_data_y[support], c=train_data_tags[support], cmap=plt.cm.Dark2)
+    ax.scatter(
+        train_data_x[support],
+        train_data_y[support],
+        c=train_data_tags[support],
+        cmap=plt.cm.Dark2,
+    )
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     test_cancel_data()
     test_demonstration()
     plt.show()
-
diff --git a/maths/3n+1.py b/maths/3n+1.py
index d6c14ff0f47d..6b2dfc785794 100644
--- a/maths/3n+1.py
+++ b/maths/3n+1.py
@@ -1,6 +1,7 @@
 from typing import Tuple, List
 
-def n31(a: int) -> Tuple[List[int], int]: 
+
+def n31(a: int) -> Tuple[List[int], int]:
     """
     Returns the Collatz sequence and its length of any postiver integer.
     >>> n31(4)
@@ -8,23 +9,29 @@ def n31(a: int) -> Tuple[List[int], int]:
     """
 
     if not isinstance(a, int):
-        raise TypeError('Must be int, not {0}'.format(type(a).__name__))
-    if a < 1: 
-        raise ValueError('Given integer must be greater than 1, not {0}'.format(a))
-    
+        raise TypeError("Must be int, not {0}".format(type(a).__name__))
+    if a < 1:
+        raise ValueError("Given integer must be greater than 1, not {0}".format(a))
+
     path = [a]
     while a != 1:
         if a % 2 == 0:
             a = a // 2
         else:
-            a = 3*a +1
+            a = 3 * a + 1
         path += [a]
     return path, len(path)
 
+
 def main():
     num = 4
-    path , length = n31(num)
-    print("The Collatz sequence of {0} took {1} steps. \nPath: {2}".format(num,length, path))
+    path, length = n31(num)
+    print(
+        "The Collatz sequence of {0} took {1} steps. \nPath: {2}".format(
+            num, length, path
+        )
+    )
+
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
diff --git a/maths/abs.py b/maths/abs.py
index 2734e58ceee6..4d15ee6e82a8 100644
--- a/maths/abs.py
+++ b/maths/abs.py
@@ -22,5 +22,5 @@ def main():
     print(abs_val(-34))  # = 34
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
diff --git a/maths/abs_max.py b/maths/abs_max.py
index 28f631f0100e..554e27f6ee66 100644
--- a/maths/abs_max.py
+++ b/maths/abs_max.py
@@ -1,4 +1,5 @@
-from typing import List 
+from typing import List
+
 
 def abs_max(x: List[int]) -> int:
     """
@@ -7,12 +8,13 @@ def abs_max(x: List[int]) -> int:
     >>> abs_max([3,-10,-2])
     -10
     """
-    j =x[0]
+    j = x[0]
     for i in x:
         if abs(i) > abs(j):
             j = i
     return j
 
+
 def abs_max_sort(x):
     """
     >>> abs_max_sort([0,5,1,11])
@@ -20,13 +22,14 @@ def abs_max_sort(x):
     >>> abs_max_sort([3,-10,-2])
     -10
     """
-    return sorted(x,key=abs)[-1]
+    return sorted(x, key=abs)[-1]
+
 
 def main():
-    a = [1,2,-11]
+    a = [1, 2, -11]
     assert abs_max(a) == -11
     assert abs_max_sort(a) == -11
 
-if __name__ == '__main__':
-    main()
 
+if __name__ == "__main__":
+    main()
diff --git a/maths/abs_min.py b/maths/abs_min.py
index abb0c9051b7d..eb84de37ce23 100644
--- a/maths/abs_min.py
+++ b/maths/abs_min.py
@@ -16,9 +16,9 @@ def absMin(x):
 
 
 def main():
-    a = [-3,-1,2,-11]
+    a = [-3, -1, 2, -11]
     print(absMin(a))  # = -1
 
 
-if __name__ == '__main__':
-    main()
\ No newline at end of file
+if __name__ == "__main__":
+    main()
diff --git a/maths/average_mean.py b/maths/average_mean.py
index 78387111022d..e04b63be0e19 100644
--- a/maths/average_mean.py
+++ b/maths/average_mean.py
@@ -16,5 +16,5 @@ def main():
     average([2, 4, 6, 8, 20, 50, 70])
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
diff --git a/maths/average_median.py b/maths/average_median.py
index eab0107d8da8..ccb250d7718c 100644
--- a/maths/average_median.py
+++ b/maths/average_median.py
@@ -24,11 +24,13 @@ def median(nums):
         med = sorted_list[mid_index]
     return med
 
+
 def main():
     print("Odd number of numbers:")
     print(median([2, 4, 6, 8, 20, 50, 70]))
     print("Even number of numbers:")
     print(median([2, 4, 6, 8, 20, 50]))
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
     main()
diff --git a/maths/basic_maths.py b/maths/basic_maths.py
index cd7bac0113b8..34ffd1031527 100644
--- a/maths/basic_maths.py
+++ b/maths/basic_maths.py
@@ -49,7 +49,7 @@ def sum_of_divisors(n):
         temp += 1
         n = int(n / 2)
     if temp > 1:
-        s *= (2**temp - 1) / (2 - 1)
+        s *= (2 ** temp - 1) / (2 - 1)
 
     for i in range(3, int(math.sqrt(n)) + 1, 2):
         temp = 1
@@ -57,7 +57,7 @@ def sum_of_divisors(n):
             temp += 1
             n = int(n / i)
         if temp > 1:
-            s *= (i**temp - 1) / (i - 1)
+            s *= (i ** temp - 1) / (i - 1)
 
     return s
 
@@ -80,5 +80,5 @@ def main():
     print(euler_phi(100))
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
diff --git a/maths/binary_exponentiation.py b/maths/binary_exponentiation.py
index a8d736adfea0..57c4b8686f5c 100644
--- a/maths/binary_exponentiation.py
+++ b/maths/binary_exponentiation.py
@@ -6,10 +6,10 @@
 
 def binary_exponentiation(a, n):
 
-    if (n == 0):
+    if n == 0:
         return 1
 
-    elif (n % 2 == 1):
+    elif n % 2 == 1:
         return binary_exponentiation(a, n - 1) * a
 
     else:
diff --git a/maths/collatz_sequence.py b/maths/collatz_sequence.py
index 9f88453d518b..c83da3f0f0e8 100644
--- a/maths/collatz_sequence.py
+++ b/maths/collatz_sequence.py
@@ -10,10 +10,10 @@ def collatz_sequence(n):
     """
     sequence = [n]
     while n != 1:
-        if n % 2 == 0:# even
-            n //= 2 
+        if n % 2 == 0:  # even
+            n //= 2
         else:
-            n = 3*n +1
+            n = 3 * n + 1
         sequence.append(n)
     return sequence
 
@@ -22,7 +22,8 @@ def main():
     n = 43
     sequence = collatz_sequence(n)
     print(sequence)
-    print("collatz sequence from %d took %d steps."%(n,len(sequence)))
+    print("collatz sequence from %d took %d steps." % (n, len(sequence)))
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
     main()
diff --git a/maths/extended_euclidean_algorithm.py b/maths/extended_euclidean_algorithm.py
index fc3798e7e432..fe81bcfaf71d 100644
--- a/maths/extended_euclidean_algorithm.py
+++ b/maths/extended_euclidean_algorithm.py
@@ -61,12 +61,12 @@ def extended_euclidean_algorithm(m, n):
 def main():
     """Call Extended Euclidean Algorithm."""
     if len(sys.argv) < 3:
-        print('2 integer arguments required')
+        print("2 integer arguments required")
         exit(1)
     m = int(sys.argv[1])
     n = int(sys.argv[2])
     print(extended_euclidean_algorithm(m, n))
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
diff --git a/maths/factorial_recursive.py b/maths/factorial_recursive.py
index 06173dcbcd7d..f346c65f1962 100644
--- a/maths/factorial_recursive.py
+++ b/maths/factorial_recursive.py
@@ -11,4 +11,4 @@ def fact(n):
 where i ranges from 1 to 20.
 """
 for i in range(1, 21):
-    print(i, ": ", fact(i), sep='')
+    print(i, ": ", fact(i), sep="")
diff --git a/maths/fermat_little_theorem.py b/maths/fermat_little_theorem.py
index 8cf60dafe3ca..24d558115795 100644
--- a/maths/fermat_little_theorem.py
+++ b/maths/fermat_little_theorem.py
@@ -6,10 +6,10 @@
 
 def binary_exponentiation(a, n, mod):
 
-    if (n == 0):
+    if n == 0:
         return 1
 
-    elif (n % 2 == 1):
+    elif n % 2 == 1:
         return (binary_exponentiation(a, n - 1, mod) * a) % mod
 
     else:
diff --git a/maths/fibonacci.py b/maths/fibonacci.py
index 0a0611f21379..5ba9f6636364 100644
--- a/maths/fibonacci.py
+++ b/maths/fibonacci.py
@@ -21,10 +21,11 @@ def timer_wrapper(*args, **kwargs):
         func(*args, **kwargs)
         end = time.time()
         if int(end - start) > 0:
-            print(f'Run time for {func.__name__}: {(end - start):0.2f}s')
+            print(f"Run time for {func.__name__}: {(end - start):0.2f}s")
         else:
-            print(f'Run time for {func.__name__}: {(end - start)*1000:0.2f}ms')
+            print(f"Run time for {func.__name__}: {(end - start)*1000:0.2f}ms")
         return func(*args, **kwargs)
+
     return timer_wrapper
 
 
@@ -69,9 +70,13 @@ def _check_number_input(n, min_thresh, max_thresh=None):
     except ValueLessThanZero:
         print("Incorrect Input: number must not be less than 0")
     except ValueTooSmallError:
-        print(f'Incorrect Input: input number must be > {min_thresh} for the recursive calculation')
+        print(
+            f"Incorrect Input: input number must be > {min_thresh} for the recursive calculation"
+        )
     except ValueTooLargeError:
-        print(f'Incorrect Input: input number must be < {max_thresh} for the recursive calculation')
+        print(
+            f"Incorrect Input: input number must be < {max_thresh} for the recursive calculation"
+        )
     return False
 
 
@@ -86,8 +91,8 @@ def fib_iterative(n):
     if _check_number_input(n, 2):
         seq_out = [0, 1]
         a, b = 0, 1
-        for _ in range(n-len(seq_out)):
-            a, b = b, a+b
+        for _ in range(n - len(seq_out)):
+            a, b = b, a + b
             seq_out.append(b)
         return seq_out
 
@@ -106,12 +111,14 @@ def fib_formula(n):
         phi_1 = Decimal(1 + sqrt) / Decimal(2)
         phi_2 = Decimal(1 - sqrt) / Decimal(2)
         for i in range(2, n):
-            temp_out = ((phi_1**Decimal(i)) - (phi_2**Decimal(i))) * (Decimal(sqrt) ** Decimal(-1))
+            temp_out = ((phi_1 ** Decimal(i)) - (phi_2 ** Decimal(i))) * (
+                Decimal(sqrt) ** Decimal(-1)
+            )
             seq_out.append(int(temp_out))
         return seq_out
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     num = 20
     # print(f'{fib_recursive(num)}\n')
     # print(f'{fib_iterative(num)}\n')
diff --git a/maths/fibonacci_sequence_recursion.py b/maths/fibonacci_sequence_recursion.py
index 9190e7fc7a40..3a565a458631 100644
--- a/maths/fibonacci_sequence_recursion.py
+++ b/maths/fibonacci_sequence_recursion.py
@@ -1,14 +1,17 @@
 # Fibonacci Sequence Using Recursion
 
+
 def recur_fibo(n):
     if n <= 1:
         return n
     else:
-        (recur_fibo(n-1) + recur_fibo(n-2))
+        (recur_fibo(n - 1) + recur_fibo(n - 2))
+
 
 def isPositiveInteger(limit):
     return limit >= 0
 
+
 def main():
     limit = int(input("How many terms to include in fibonacci series: "))
     if isPositiveInteger(limit):
@@ -17,5 +20,6 @@ def main():
     else:
         print("Please enter a positive integer: ")
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
     main()
diff --git a/maths/find_lcm.py b/maths/find_lcm.py
index f7ac958070b5..dffadd1f3c5b 100644
--- a/maths/find_lcm.py
+++ b/maths/find_lcm.py
@@ -10,14 +10,14 @@ def find_lcm(num_1, num_2):
        >>> find_lcm(12,76)
        228
     """
-    if num_1>=num_2:
-        max_num=num_1
+    if num_1 >= num_2:
+        max_num = num_1
     else:
-        max_num=num_2
-    
+        max_num = num_2
+
     lcm = max_num
     while True:
-        if ((lcm % num_1 == 0) and (lcm % num_2 == 0)):
+        if (lcm % num_1 == 0) and (lcm % num_2 == 0):
             break
         lcm += max_num
     return lcm
@@ -25,10 +25,10 @@ def find_lcm(num_1, num_2):
 
 def main():
     """Use test numbers to run the find_lcm algorithm."""
-    num_1 = int(input().strip()) 
-    num_2 = int(input().strip()) 
+    num_1 = int(input().strip())
+    num_2 = int(input().strip())
     print(find_lcm(num_1, num_2))
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
diff --git a/maths/find_max.py b/maths/find_max.py
index 0ce49a68c348..7cc82aacfb09 100644
--- a/maths/find_max.py
+++ b/maths/find_max.py
@@ -1,14 +1,17 @@
 # NguyenU
 
+
 def find_max(nums):
     max = nums[0]
     for x in nums:
-      if x > max:
-        max = x
+        if x > max:
+            max = x
     print(max)
 
+
 def main():
-  find_max([2, 4, 9, 7, 19, 94, 5])
+    find_max([2, 4, 9, 7, 19, 94, 5])
+
 
-if __name__ == '__main__':
-  main()
+if __name__ == "__main__":
+    main()
diff --git a/maths/find_min.py b/maths/find_min.py
index c720da268a25..e24982a9369b 100644
--- a/maths/find_min.py
+++ b/maths/find_min.py
@@ -3,6 +3,7 @@
 
 def main():
     """Find Minimum Number in a List."""
+
     def find_min(x):
         min_num = x[0]
         for i in x:
@@ -13,5 +14,5 @@ def find_min(x):
     print(find_min([0, 1, 2, 3, 4, 5, -3, 24, -56]))  # = -56
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
diff --git a/maths/gaussian.py b/maths/gaussian.py
index f3a47a3f6a1b..e5f55dfaffd1 100644
--- a/maths/gaussian.py
+++ b/maths/gaussian.py
@@ -1,4 +1,3 @@
-
 """
 Reference: https://en.wikipedia.org/wiki/Gaussian_function
 
@@ -9,7 +8,6 @@
 from numpy import pi, sqrt, exp
 
 
-
 def gaussian(x, mu: float = 0.0, sigma: float = 1.0) -> int:
     """
     >>> gaussian(1)
diff --git a/maths/greater_common_divisor.py b/maths/greater_common_divisor.py
index adc7811e8317..ec608488a61f 100644
--- a/maths/greater_common_divisor.py
+++ b/maths/greater_common_divisor.py
@@ -13,7 +13,7 @@ def gcd(a, b):
 def main():
     """Call GCD Function."""
     try:
-        nums = input("Enter two Integers separated by comma (,): ").split(',')
+        nums = input("Enter two Integers separated by comma (,): ").split(",")
         num_1 = int(nums[0])
         num_2 = int(nums[1])
     except (IndexError, UnboundLocalError, ValueError):
@@ -21,5 +21,5 @@ def main():
     print(f"gcd({num_1}, {num_2}) = {gcd(num_1, num_2)}")
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
diff --git a/maths/lucas_series.py b/maths/lucas_series.py
index 9ae437dc9f54..22ad893a6567 100644
--- a/maths/lucas_series.py
+++ b/maths/lucas_series.py
@@ -1,5 +1,6 @@
 # Lucas Sequence Using Recursion
 
+
 def recur_luc(n):
     """
     >>> recur_luc(1)
diff --git a/maths/matrix_exponentiation.py b/maths/matrix_exponentiation.py
index f80f6c3cad5e..c20292735a92 100644
--- a/maths/matrix_exponentiation.py
+++ b/maths/matrix_exponentiation.py
@@ -85,8 +85,9 @@ def simple_fibonacci_time():
 """
     code = "simple_fibonacci(randint(1,70000), 1, 1)"
     exec_time = timeit.timeit(setup=setup, stmt=code, number=100)
-    print("Without matrix exponentiation the average execution time is ",
-          exec_time / 100)
+    print(
+        "Without matrix exponentiation the average execution time is ", exec_time / 100
+    )
     return exec_time
 
 
diff --git a/maths/modular_exponential.py b/maths/modular_exponential.py
index 750de7cba99e..8715e17147ff 100644
--- a/maths/modular_exponential.py
+++ b/maths/modular_exponential.py
@@ -21,5 +21,5 @@ def main():
     print(modular_exponential(3, 200, 13))
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
diff --git a/maths/newton_raphson.py b/maths/newton_raphson.py
index d89f264acdd8..093cc4438416 100644
--- a/maths/newton_raphson.py
+++ b/maths/newton_raphson.py
@@ -1,4 +1,4 @@
-'''
+"""
     Author: P Shreyas Shetty
     Implementation of Newton-Raphson method for solving equations of kind
     f(x) = 0. It is an iterative method where solution is found by the expression
@@ -6,27 +6,29 @@
     If no solution exists, then either the solution will not be found when iteration
     limit is reached or the gradient f'(x[n]) approaches zero. In both cases, exception
     is raised. If iteration limit is reached, try increasing maxiter.
-    '''
+    """
 
 import math as m
 
+
 def calc_derivative(f, a, h=0.001):
-    '''
+    """
      Calculates derivative at point a for function f using finite difference
      method
-    '''
-    return (f(a+h)-f(a-h))/(2*h)
+    """
+    return (f(a + h) - f(a - h)) / (2 * h)
+
+
+def newton_raphson(f, x0=0, maxiter=100, step=0.0001, maxerror=1e-6, logsteps=False):
 
-def newton_raphson(f, x0=0, maxiter=100, step=0.0001, maxerror=1e-6,logsteps=False):
-    
-    a = x0 #set the initial guess
+    a = x0  # set the initial guess
     steps = [a]
     error = abs(f(a))
-    f1 = lambda x:calc_derivative(f, x, h=step) #Derivative of f(x)
+    f1 = lambda x: calc_derivative(f, x, h=step)  # Derivative of f(x)
     for _ in range(maxiter):
         if f1(a) == 0:
             raise ValueError("No converging solution found")
-        a = a - f(a)/f1(a) #Calculate the next estimate
+        a = a - f(a) / f1(a)  # Calculate the next estimate
         if logsteps:
             steps.append(a)
         if error < maxerror:
@@ -34,14 +36,18 @@ def newton_raphson(f, x0=0, maxiter=100, step=0.0001, maxerror=1e-6,logsteps=Fal
     else:
         raise ValueError("Iteration limit reached, no converging solution found")
     if logsteps:
-        #If logstep is true, then log intermediate steps
+        # If logstep is true, then log intermediate steps
         return a, error, steps
     return a, error
- 
-if __name__ == '__main__':
+
+
+if __name__ == "__main__":
     import matplotlib.pyplot as plt
-    f = lambda x:m.tanh(x)**2-m.exp(3*x)
-    solution, error, steps = newton_raphson(f, x0=10, maxiter=1000, step=1e-6, logsteps=True)
+
+    f = lambda x: m.tanh(x) ** 2 - m.exp(3 * x)
+    solution, error, steps = newton_raphson(
+        f, x0=10, maxiter=1000, step=1e-6, logsteps=True
+    )
     plt.plot([abs(f(x)) for x in steps])
     plt.xlabel("step")
     plt.ylabel("error")
diff --git a/maths/polynomial_evaluation.py b/maths/polynomial_evaluation.py
index b4f18b9fa106..3c91ecd93031 100644
--- a/maths/polynomial_evaluation.py
+++ b/maths/polynomial_evaluation.py
@@ -11,7 +11,7 @@ def evaluate_poly(poly, x):
         79800.0
     """
 
-    return sum(c*(x**i) for i, c in enumerate(poly))
+    return sum(c * (x ** i) for i, c in enumerate(poly))
 
 
 if __name__ == "__main__":
diff --git a/maths/prime_check.py b/maths/prime_check.py
index 9249834dc069..e60281228fda 100644
--- a/maths/prime_check.py
+++ b/maths/prime_check.py
@@ -40,12 +40,13 @@ def test_primes(self):
         self.assertTrue(prime_check(29))
 
     def test_not_primes(self):
-        self.assertFalse(prime_check(-19),
-                         "Negative numbers are not prime.")
-        self.assertFalse(prime_check(0),
-                         "Zero doesn't have any divider, primes must have two")
-        self.assertFalse(prime_check(1),
-                         "One just have 1 divider, primes must have two.")
+        self.assertFalse(prime_check(-19), "Negative numbers are not prime.")
+        self.assertFalse(
+            prime_check(0), "Zero doesn't have any divider, primes must have two"
+        )
+        self.assertFalse(
+            prime_check(1), "One just have 1 divider, primes must have two."
+        )
         self.assertFalse(prime_check(2 * 2))
         self.assertFalse(prime_check(2 * 3))
         self.assertFalse(prime_check(3 * 3))
@@ -53,5 +54,5 @@ def test_not_primes(self):
         self.assertFalse(prime_check(3 * 5 * 7))
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()
diff --git a/maths/radix2_fft.py b/maths/radix2_fft.py
index c7ffe96528b4..3911fea1d04d 100644
--- a/maths/radix2_fft.py
+++ b/maths/radix2_fft.py
@@ -65,12 +65,7 @@ def __init__(self, polyA=[0], polyB=[0]):
 
         # Add 0 to make lengths equal a power of 2
         self.C_max_length = int(
-            2
-            ** np.ceil(
-                np.log2(
-                    len(self.polyA) + len(self.polyB) - 1
-                )
-            )
+            2 ** np.ceil(np.log2(len(self.polyA) + len(self.polyB) - 1))
         )
 
         while len(self.polyA) < self.C_max_length:
@@ -78,9 +73,7 @@ def __init__(self, polyA=[0], polyB=[0]):
         while len(self.polyB) < self.C_max_length:
             self.polyB.append(0)
         # A complex root used for the fourier transform
-        self.root = complex(
-            mpmath.root(x=1, n=self.C_max_length, k=1)
-        )
+        self.root = complex(mpmath.root(x=1, n=self.C_max_length, k=1))
 
         # The product
         self.product = self.__multiply()
@@ -102,27 +95,15 @@ def __DFT(self, which):
 
             # First half of next step
             current_root = 1
-            for j in range(
-                self.C_max_length // (next_ncol * 2)
-            ):
+            for j in range(self.C_max_length // (next_ncol * 2)):
                 for i in range(next_ncol):
-                    new_dft[i].append(
-                        dft[i][j]
-                        + current_root
-                        * dft[i + next_ncol][j]
-                    )
+                    new_dft[i].append(dft[i][j] + current_root * dft[i + next_ncol][j])
                 current_root *= root
             # Second half of next step
             current_root = 1
-            for j in range(
-                self.C_max_length // (next_ncol * 2)
-            ):
+            for j in range(self.C_max_length // (next_ncol * 2)):
                 for i in range(next_ncol):
-                    new_dft[i].append(
-                        dft[i][j]
-                        - current_root
-                        * dft[i + next_ncol][j]
-                    )
+                    new_dft[i].append(dft[i][j] - current_root * dft[i + next_ncol][j])
                 current_root *= root
             # Update
             dft = new_dft
@@ -133,12 +114,7 @@ def __DFT(self, which):
     def __multiply(self):
         dftA = self.__DFT("A")
         dftB = self.__DFT("B")
-        inverseC = [
-            [
-                dftA[i] * dftB[i]
-                for i in range(self.C_max_length)
-            ]
-        ]
+        inverseC = [[dftA[i] * dftB[i] for i in range(self.C_max_length)]]
         del dftA
         del dftB
 
@@ -158,11 +134,7 @@ def __multiply(self):
                     new_inverseC[i].append(
                         (
                             inverseC[i][j]
-                            + inverseC[i][
-                                j
-                                + self.C_max_length
-                                // next_ncol
-                            ]
+                            + inverseC[i][j + self.C_max_length // next_ncol]
                         )
                         / 2
                     )
@@ -170,11 +142,7 @@ def __multiply(self):
                     new_inverseC[i + next_ncol // 2].append(
                         (
                             inverseC[i][j]
-                            - inverseC[i][
-                                j
-                                + self.C_max_length
-                                // next_ncol
-                            ]
+                            - inverseC[i][j + self.C_max_length // next_ncol]
                         )
                         / (2 * current_root)
                     )
@@ -183,10 +151,7 @@ def __multiply(self):
             inverseC = new_inverseC
             next_ncol *= 2
         # Unpack
-        inverseC = [
-            round(x[0].real, 8) + round(x[0].imag, 8) * 1j
-            for x in inverseC
-        ]
+        inverseC = [round(x[0].real, 8) + round(x[0].imag, 8) * 1j for x in inverseC]
 
         # Remove leading 0's
         while inverseC[-1] == 0:
@@ -196,20 +161,13 @@ def __multiply(self):
     # Overwrite __str__ for print(); Shows A, B and A*B
     def __str__(self):
         A = "A = " + " + ".join(
-            f"{coef}*x^{i}"
-            for coef, i in enumerate(
-                self.polyA[: self.len_A]
-            )
+            f"{coef}*x^{i}" for coef, i in enumerate(self.polyA[: self.len_A])
         )
         B = "B = " + " + ".join(
-            f"{coef}*x^{i}"
-            for coef, i in enumerate(
-                self.polyB[: self.len_B]
-            )
+            f"{coef}*x^{i}" for coef, i in enumerate(self.polyB[: self.len_B])
         )
         C = "A*B = " + " + ".join(
-            f"{coef}*x^{i}"
-            for coef, i in enumerate(self.product)
+            f"{coef}*x^{i}" for coef, i in enumerate(self.product)
         )
 
         return "\n".join((A, B, C))
diff --git a/maths/segmented_sieve.py b/maths/segmented_sieve.py
index b15ec2480678..c1cc497ad33e 100644
--- a/maths/segmented_sieve.py
+++ b/maths/segmented_sieve.py
@@ -48,4 +48,4 @@ def sieve(n):
     return prime
 
 
-print(sieve(10**6))
+print(sieve(10 ** 6))
diff --git a/maths/simpson_rule.py b/maths/simpson_rule.py
index 5cf9c14b07ee..f4620be8e70f 100644
--- a/maths/simpson_rule.py
+++ b/maths/simpson_rule.py
@@ -1,4 +1,3 @@
-
 """
 Numerical integration or quadrature for a smooth function f with known values at x_i
 
@@ -8,39 +7,45 @@
 "Simpson Rule"
 
 """
+
+
 def method_2(boundary, steps):
-# "Simpson Rule"
-# int(f) = delta_x/2 * (b-a)/3*(f1 + 4f2 + 2f_3 + ... + fn)
+    # "Simpson Rule"
+    # int(f) = delta_x/2 * (b-a)/3*(f1 + 4f2 + 2f_3 + ... + fn)
     h = (boundary[1] - boundary[0]) / steps
     a = boundary[0]
     b = boundary[1]
-    x_i = make_points(a,b,h)
+    x_i = make_points(a, b, h)
     y = 0.0
-    y += (h/3.0)*f(a)
+    y += (h / 3.0) * f(a)
     cnt = 2
     for i in x_i:
-        y += (h/3)*(4-2*(cnt%2))*f(i)
+        y += (h / 3) * (4 - 2 * (cnt % 2)) * f(i)
         cnt += 1
-    y += (h/3.0)*f(b)
+    y += (h / 3.0) * f(b)
     return y
 
-def make_points(a,b,h):
+
+def make_points(a, b, h):
     x = a + h
-    while x < (b-h):
+    while x < (b - h):
         yield x
         x = x + h
 
-def f(x): #enter your function here
-    y = (x-0)*(x-0)
+
+def f(x):  # enter your function here
+    y = (x - 0) * (x - 0)
     return y
 
+
 def main():
-    a = 0.0 #Lower bound of integration
-    b = 1.0    #Upper bound of integration
-    steps = 10.0        #define number of steps or resolution
-    boundary = [a, b]    #define boundary of integration
+    a = 0.0  # Lower bound of integration
+    b = 1.0  # Upper bound of integration
+    steps = 10.0  # define number of steps or resolution
+    boundary = [a, b]  # define boundary of integration
     y = method_2(boundary, steps)
-    print('y = {0}'.format(y))
+    print("y = {0}".format(y))
+
 
-if __name__ == '__main__':
-        main()
+if __name__ == "__main__":
+    main()
diff --git a/maths/trapezoidal_rule.py b/maths/trapezoidal_rule.py
index f5e5fbbc2662..0f321317614d 100644
--- a/maths/trapezoidal_rule.py
+++ b/maths/trapezoidal_rule.py
@@ -7,38 +7,44 @@
 "extended trapezoidal rule"
 
 """
+
+
 def method_1(boundary, steps):
-# "extended trapezoidal rule"
-# int(f) = dx/2 * (f1 + 2f2 + ... + fn)
-	h = (boundary[1] - boundary[0]) / steps
-	a = boundary[0]
-	b = boundary[1]
-	x_i = make_points(a,b,h)
-	y = 0.0
-	y += (h/2.0)*f(a)
-	for i in x_i:
-		#print(i)
-		y += h*f(i)
-	y += (h/2.0)*f(b)
-	return y
-
-def make_points(a,b,h):
-	x = a + h
-	while x < (b-h):
-		yield x
-		x = x + h
-
-def f(x): #enter your function here
-	y = (x-0)*(x-0)
-	return y
+    # "extended trapezoidal rule"
+    # int(f) = dx/2 * (f1 + 2f2 + ... + fn)
+    h = (boundary[1] - boundary[0]) / steps
+    a = boundary[0]
+    b = boundary[1]
+    x_i = make_points(a, b, h)
+    y = 0.0
+    y += (h / 2.0) * f(a)
+    for i in x_i:
+        # print(i)
+        y += h * f(i)
+    y += (h / 2.0) * f(b)
+    return y
+
+
+def make_points(a, b, h):
+    x = a + h
+    while x < (b - h):
+        yield x
+        x = x + h
+
+
+def f(x):  # enter your function here
+    y = (x - 0) * (x - 0)
+    return y
+
 
 def main():
-	a = 0.0 #Lower bound of integration
-	b = 1.0	#Upper bound of integration
-	steps = 10.0		#define number of steps or resolution
-	boundary = [a, b]	#define boundary of integration
-	y = method_1(boundary, steps)
-	print('y = {0}'.format(y))
-
-if __name__ == '__main__':
-	main()
+    a = 0.0  # Lower bound of integration
+    b = 1.0  # Upper bound of integration
+    steps = 10.0  # define number of steps or resolution
+    boundary = [a, b]  # define boundary of integration
+    y = method_1(boundary, steps)
+    print("y = {0}".format(y))
+
+
+if __name__ == "__main__":
+    main()
diff --git a/maths/zellers_congruence.py b/maths/zellers_congruence.py
index 67c5550802ea..277ecfaf0da9 100644
--- a/maths/zellers_congruence.py
+++ b/maths/zellers_congruence.py
@@ -68,24 +68,16 @@ def zeller(date_input: str) -> str:
 
     # Days of the week for response
     days = {
-        '0': 'Sunday',
-        '1': 'Monday',
-        '2': 'Tuesday',
-        '3': 'Wednesday',
-        '4': 'Thursday',
-        '5': 'Friday',
-        '6': 'Saturday'
+        "0": "Sunday",
+        "1": "Monday",
+        "2": "Tuesday",
+        "3": "Wednesday",
+        "4": "Thursday",
+        "5": "Friday",
+        "6": "Saturday",
     }
 
-    convert_datetime_days = {
-        0:1,
-        1:2,
-        2:3,
-        3:4,
-        4:5,
-        5:6,
-        6:0
-    }
+    convert_datetime_days = {0: 1, 1: 2, 2: 3, 3: 4, 4: 5, 5: 6, 6: 0}
 
     # Validate
     if not 0 < len(date_input) < 11:
@@ -97,9 +89,9 @@ def zeller(date_input: str) -> str:
     if not 0 < m < 13:
         raise ValueError("Month must be between 1 - 12")
 
-    sep_1:str = date_input[2]
+    sep_1: str = date_input[2]
     # Validate
-    if sep_1 not in ["-","/"]:
+    if sep_1 not in ["-", "/"]:
         raise ValueError("Date seperator must be '-' or '/'")
 
     # Get day
@@ -111,14 +103,16 @@ def zeller(date_input: str) -> str:
     # Get second seperator
     sep_2: str = date_input[5]
     # Validate
-    if sep_2 not in ["-","/"]:
+    if sep_2 not in ["-", "/"]:
         raise ValueError("Date seperator must be '-' or '/'")
 
     # Get year
     y: int = int(date_input[6] + date_input[7] + date_input[8] + date_input[9])
     # Arbitrary year range
     if not 45 < y < 8500:
-        raise ValueError("Year out of range. There has to be some sort of limit...right?")
+        raise ValueError(
+            "Year out of range. There has to be some sort of limit...right?"
+        )
 
     # Get datetime obj for validation
     dt_ck = datetime.date(int(y), int(m), int(d))
@@ -130,13 +124,13 @@ def zeller(date_input: str) -> str:
     # maths var
     c: int = int(str(y)[:2])
     k: int = int(str(y)[2:])
-    t: int = int(2.6*m - 5.39)
+    t: int = int(2.6 * m - 5.39)
     u: int = int(c / 4)
     v: int = int(k / 4)
     x: int = int(d + k)
     z: int = int(t + u + v + x)
     w: int = int(z - (2 * c))
-    f: int = round(w%7)
+    f: int = round(w % 7)
     # End math
 
     # Validate math
@@ -147,10 +141,16 @@ def zeller(date_input: str) -> str:
     response: str = f"Your date {date_input}, is a {days[str(f)]}!"
     return response
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
     import doctest
+
     doctest.testmod()
-    parser = argparse.ArgumentParser(description='Find out what day of the week nearly any date is or was. Enter date as a string in the mm-dd-yyyy or mm/dd/yyyy format')
-    parser.add_argument('date_input', type=str, help='Date as a string (mm-dd-yyyy or mm/dd/yyyy)')
+    parser = argparse.ArgumentParser(
+        description="Find out what day of the week nearly any date is or was. Enter date as a string in the mm-dd-yyyy or mm/dd/yyyy format"
+    )
+    parser.add_argument(
+        "date_input", type=str, help="Date as a string (mm-dd-yyyy or mm/dd/yyyy)"
+    )
     args = parser.parse_args()
     zeller(args.date_input)
diff --git a/matrix/matrix_class.py b/matrix/matrix_class.py
index c82fb2cf6464..a8066e319559 100644
--- a/matrix/matrix_class.py
+++ b/matrix/matrix_class.py
@@ -311,8 +311,10 @@ def __mul__(self, other):
             return Matrix([[element * other for element in row] for row in self.rows])
         elif isinstance(other, Matrix):
             if self.num_columns != other.num_rows:
-                raise ValueError("The number of columns in the first matrix must "
-                                 "be equal to the number of rows in the second")
+                raise ValueError(
+                    "The number of columns in the first matrix must "
+                    "be equal to the number of rows in the second"
+                )
             return Matrix(
                 [
                     [Matrix.dot_product(row, column) for column in other.columns()]
@@ -320,7 +322,9 @@ def __mul__(self, other):
                 ]
             )
         else:
-            raise TypeError("A Matrix can only be multiplied by an int, float, or another matrix")
+            raise TypeError(
+                "A Matrix can only be multiplied by an int, float, or another matrix"
+            )
 
     def __pow__(self, other):
         if not isinstance(other, int):
diff --git a/matrix/matrix_operation.py b/matrix/matrix_operation.py
index b32a4dcf7af3..5ca61b4ed023 100644
--- a/matrix/matrix_operation.py
+++ b/matrix/matrix_operation.py
@@ -39,8 +39,10 @@ def multiply(matrix_a, matrix_b):
         rows, cols = _verify_matrix_sizes(matrix_a, matrix_b)
 
         if cols[0] != rows[1]:
-            raise ValueError(f'Cannot multiply matrix of dimensions ({rows[0]},{cols[0]}) '
-                             f'and ({rows[1]},{cols[1]})')
+            raise ValueError(
+                f"Cannot multiply matrix of dimensions ({rows[0]},{cols[0]}) "
+                f"and ({rows[1]},{cols[1]})"
+            )
         for i in range(rows[0]):
             list_1 = []
             for j in range(cols[1]):
@@ -59,7 +61,7 @@ def identity(n):
     :return: Identity matrix of shape [n, n]
     """
     n = int(n)
-    return [[int(row == column) for column in range(n)] for row in range(n)] 
+    return [[int(row == column) for column in range(n)] for row in range(n)]
 
 
 def transpose(matrix, return_map=True):
@@ -75,15 +77,15 @@ def transpose(matrix, return_map=True):
 
 
 def minor(matrix, row, column):
-    minor = matrix[:row] + matrix[row + 1:]
-    minor = [row[:column] + row[column + 1:] for row in minor]
+    minor = matrix[:row] + matrix[row + 1 :]
+    minor = [row[:column] + row[column + 1 :] for row in minor]
     return minor
 
 
 def determinant(matrix):
     if len(matrix) == 1:
         return matrix[0][0]
-    
+
     res = 0
     for x in range(len(matrix)):
         res += matrix[0][x] * determinant(minor(matrix, 0, x)) * (-1) ** x
@@ -99,10 +101,13 @@ def inverse(matrix):
     for i in range(len(matrix)):
         for j in range(len(matrix)):
             matrix_minor[i].append(determinant(minor(matrix, i, j)))
-    
-    cofactors = [[x * (-1) ** (row + col) for col, x in enumerate(matrix_minor[row])] for row in range(len(matrix))]
+
+    cofactors = [
+        [x * (-1) ** (row + col) for col, x in enumerate(matrix_minor[row])]
+        for row in range(len(matrix))
+    ]
     adjugate = transpose(cofactors)
-    return scalar_multiply(adjugate, 1/det)
+    return scalar_multiply(adjugate, 1 / det)
 
 
 def _check_not_integer(matrix):
@@ -122,8 +127,10 @@ def _verify_matrix_sizes(matrix_a, matrix_b):
     shape = _shape(matrix_a)
     shape += _shape(matrix_b)
     if shape[0] != shape[2] or shape[1] != shape[3]:
-        raise ValueError(f"operands could not be broadcast together with shape "
-                         f"({shape[0], shape[1]}), ({shape[2], shape[3]})")
+        raise ValueError(
+            f"operands could not be broadcast together with shape "
+            f"({shape[0], shape[1]}), ({shape[2], shape[3]})"
+        )
     return [shape[0], shape[2]], [shape[1], shape[3]]
 
 
@@ -132,13 +139,19 @@ def main():
     matrix_b = [[3, 4], [7, 4]]
     matrix_c = [[11, 12, 13, 14], [21, 22, 23, 24], [31, 32, 33, 34], [41, 42, 43, 44]]
     matrix_d = [[3, 0, 2], [2, 0, -2], [0, 1, 1]]
-    print('Add Operation, %s + %s = %s \n' %(matrix_a, matrix_b, (add(matrix_a, matrix_b))))
-    print('Multiply Operation, %s * %s = %s \n' %(matrix_a, matrix_b, multiply(matrix_a, matrix_b)))
-    print('Identity:  %s \n' %identity(5))
-    print('Minor of %s = %s \n' %(matrix_c, minor(matrix_c, 1, 2)))
-    print('Determinant of %s = %s \n' %(matrix_b, determinant(matrix_b)))
-    print('Inverse of %s = %s\n'%(matrix_d, inverse(matrix_d)))
-
-
-if __name__ == '__main__':
+    print(
+        "Add Operation, %s + %s = %s \n"
+        % (matrix_a, matrix_b, (add(matrix_a, matrix_b)))
+    )
+    print(
+        "Multiply Operation, %s * %s = %s \n"
+        % (matrix_a, matrix_b, multiply(matrix_a, matrix_b))
+    )
+    print("Identity:  %s \n" % identity(5))
+    print("Minor of %s = %s \n" % (matrix_c, minor(matrix_c, 1, 2)))
+    print("Determinant of %s = %s \n" % (matrix_b, determinant(matrix_b)))
+    print("Inverse of %s = %s\n" % (matrix_d, inverse(matrix_d)))
+
+
+if __name__ == "__main__":
     main()
diff --git a/matrix/nth_fibonacci_using_matrix_exponentiation.py b/matrix/nth_fibonacci_using_matrix_exponentiation.py
index 57cdfacd47dd..222779f454f9 100644
--- a/matrix/nth_fibonacci_using_matrix_exponentiation.py
+++ b/matrix/nth_fibonacci_using_matrix_exponentiation.py
@@ -13,6 +13,8 @@
 So we just need the n times multiplication of the matrix [1,1],[1,0]].
 We can decrease the n times multiplication by following the divide and conquer approach.
 """
+
+
 def multiply(matrix_a, matrix_b):
     matrix_c = []
     n = len(matrix_a)
diff --git a/matrix/searching_in_sorted_matrix.py b/matrix/searching_in_sorted_matrix.py
index 54913b350803..1b3eeedf3110 100644
--- a/matrix/searching_in_sorted_matrix.py
+++ b/matrix/searching_in_sorted_matrix.py
@@ -2,26 +2,21 @@ def search_in_a_sorted_matrix(mat, m, n, key):
     i, j = m - 1, 0
     while i >= 0 and j < n:
         if key == mat[i][j]:
-            print('Key %s found at row- %s column- %s' % (key, i + 1, j + 1))
+            print("Key %s found at row- %s column- %s" % (key, i + 1, j + 1))
             return
         if key < mat[i][j]:
             i -= 1
         else:
             j += 1
-    print('Key %s not found' % (key))
+    print("Key %s not found" % (key))
 
 
 def main():
-    mat = [
-        [2, 5, 7],
-        [4, 8, 13],
-        [9, 11, 15],
-        [12, 17, 20]
-    ]
+    mat = [[2, 5, 7], [4, 8, 13], [9, 11, 15], [12, 17, 20]]
     x = int(input("Enter the element to be searched:"))
     print(mat)
     search_in_a_sorted_matrix(mat, len(mat), len(mat[0]), x)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
diff --git a/matrix/sherman_morrison.py b/matrix/sherman_morrison.py
index 0d49d78509be..531b76cdeb94 100644
--- a/matrix/sherman_morrison.py
+++ b/matrix/sherman_morrison.py
@@ -28,7 +28,7 @@ def __str__(self):
 
         # Prefix
         s = "Matrix consist of %d rows and %d columns\n" % (self.row, self.column)
-        
+
         # Make string identifier
         max_element_length = 0
         for row_vector in self.array:
@@ -37,16 +37,18 @@ def __str__(self):
         string_format_identifier = "%%%ds" % (max_element_length,)
 
         # Make string and return
-        def single_line(row_vector): 
+        def single_line(row_vector):
             nonlocal string_format_identifier
             line = "["
             line += ", ".join(string_format_identifier % (obj,) for obj in row_vector)
             line += "]"
             return line
+
         s += "\n".join(single_line(row_vector) for row_vector in self.array)
         return s
 
-    def __repr__(self): return str(self)
+    def __repr__(self):
+        return str(self)
 
     def validateIndices(self, loc: tuple):
         """
@@ -60,9 +62,12 @@ def validateIndices(self, loc: tuple):
         >>> a.validateIndices((0, 0))
         True
         """
-        if not(isinstance(loc, (list, tuple)) and len(loc) == 2): return False
-        elif not(0 <= loc[0] < self.row and 0 <= loc[1] < self.column): return False
-        else: return True
+        if not (isinstance(loc, (list, tuple)) and len(loc) == 2):
+            return False
+        elif not (0 <= loc[0] < self.row and 0 <= loc[1] < self.column):
+            return False
+        else:
+            return True
 
     def __getitem__(self, loc: tuple):
         """
@@ -115,7 +120,7 @@ def __add__(self, another):
         result = Matrix(self.row, self.column)
         for r in range(self.row):
             for c in range(self.column):
-                result[r,c] = self[r,c] + another[r,c]
+                result[r, c] = self[r, c] + another[r, c]
         return result
 
     def __neg__(self):
@@ -135,10 +140,11 @@ def __neg__(self):
         result = Matrix(self.row, self.column)
         for r in range(self.row):
             for c in range(self.column):
-                result[r,c] = -self[r,c]
+                result[r, c] = -self[r, c]
         return result
 
-    def __sub__(self, another): return self + (-another)
+    def __sub__(self, another):
+        return self + (-another)
 
     def __mul__(self, another):
         """
@@ -154,21 +160,24 @@ def __mul__(self, another):
         [-2, -2, -6]
         """
 
-        if isinstance(another, (int, float)): # Scalar multiplication
+        if isinstance(another, (int, float)):  # Scalar multiplication
             result = Matrix(self.row, self.column)
             for r in range(self.row):
                 for c in range(self.column):
-                    result[r,c] = self[r,c] * another
+                    result[r, c] = self[r, c] * another
             return result
-        elif isinstance(another, Matrix): # Matrix multiplication
-            assert(self.column == another.row)
+        elif isinstance(another, Matrix):  # Matrix multiplication
+            assert self.column == another.row
             result = Matrix(self.row, another.column)
             for r in range(self.row):
                 for c in range(another.column):
                     for i in range(self.column):
-                        result[r,c] += self[r,i] * another[i,c]
+                        result[r, c] += self[r, i] * another[i, c]
             return result
-        else: raise TypeError("Unsupported type given for another (%s)" % (type(another),))
+        else:
+            raise TypeError(
+                "Unsupported type given for another (%s)" % (type(another),)
+            )
 
     def transpose(self):
         """
@@ -191,7 +200,7 @@ def transpose(self):
         result = Matrix(self.column, self.row)
         for r in range(self.row):
             for c in range(self.column):
-                result[c,r] = self[r,c]
+                result[c, r] = self[r, c]
         return result
 
     def ShermanMorrison(self, u, v):
@@ -220,28 +229,31 @@ def ShermanMorrison(self, u, v):
 
         # Size validation
         assert isinstance(u, Matrix) and isinstance(v, Matrix)
-        assert self.row == self.column == u.row == v.row # u, v should be column vector
-        assert u.column == v.column == 1 # u, v should be column vector
+        assert self.row == self.column == u.row == v.row  # u, v should be column vector
+        assert u.column == v.column == 1  # u, v should be column vector
 
         # Calculate
         vT = v.transpose()
         numerator_factor = (vT * self * u)[0, 0] + 1
-        if numerator_factor == 0: return None # It's not invertable
+        if numerator_factor == 0:
+            return None  # It's not invertable
         return self - ((self * u) * (vT * self) * (1.0 / numerator_factor))
 
+
 # Testing
 if __name__ == "__main__":
 
     def test1():
         # a^(-1)
         ainv = Matrix(3, 3, 0)
-        for i in range(3): ainv[i,i] = 1
+        for i in range(3):
+            ainv[i, i] = 1
         print("a^(-1) is %s" % (ainv,))
         # u, v
         u = Matrix(3, 1, 0)
-        u[0,0], u[1,0], u[2,0] = 1, 2, -3
+        u[0, 0], u[1, 0], u[2, 0] = 1, 2, -3
         v = Matrix(3, 1, 0)
-        v[0,0], v[1,0], v[2,0] = 4, -2, 5
+        v[0, 0], v[1, 0], v[2, 0] = 4, -2, 5
         print("u is %s" % (u,))
         print("v is %s" % (v,))
         print("uv^T is %s" % (u * v.transpose()))
@@ -250,6 +262,7 @@ def test1():
 
     def test2():
         import doctest
+
         doctest.testmod()
 
-    test2()
\ No newline at end of file
+    test2()
diff --git a/matrix/spiral_print.py b/matrix/spiral_print.py
index 447881e508e7..31d9fff84bfd 100644
--- a/matrix/spiral_print.py
+++ b/matrix/spiral_print.py
@@ -6,6 +6,8 @@
         i) matrix should be only one or two dimensional
         ii)column of all the row should be equal
 """
+
+
 def checkMatrix(a):
     # must be
     if type(a) == list and len(a) > 0:
@@ -51,7 +53,7 @@ def spiralPrint(a):
         # vertical printing up
         for i in range(matRow - 2, 0, -1):
             print(a[i][0]),
-        remainMat = [row[1:matCol - 1] for row in a[1:matRow - 1]]
+        remainMat = [row[1 : matCol - 1] for row in a[1 : matRow - 1]]
         if len(remainMat) > 0:
             spiralPrint(remainMat)
         else:
@@ -62,5 +64,5 @@ def spiralPrint(a):
 
 
 # driver code
-a = [[1 , 2, 3, 4],[5, 6, 7, 8],[9, 10, 11, 12]]
+a = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]
 spiralPrint(a)
diff --git a/matrix/tests/test_matrix_operation.py b/matrix/tests/test_matrix_operation.py
index 8b81b65d0fc8..f9f72cf59af8 100644
--- a/matrix/tests/test_matrix_operation.py
+++ b/matrix/tests/test_matrix_operation.py
@@ -29,8 +29,9 @@
 
 
 @pytest.mark.mat_ops
-@pytest.mark.parametrize(('mat1', 'mat2'), [(mat_a, mat_b), (mat_c, mat_d), (mat_d, mat_e),
-                                            (mat_f, mat_h)])
+@pytest.mark.parametrize(
+    ("mat1", "mat2"), [(mat_a, mat_b), (mat_c, mat_d), (mat_d, mat_e), (mat_f, mat_h)]
+)
 def test_addition(mat1, mat2):
     if (np.array(mat1)).shape < (2, 2) or (np.array(mat2)).shape < (2, 2):
         with pytest.raises(TypeError):
@@ -48,8 +49,9 @@ def test_addition(mat1, mat2):
 
 
 @pytest.mark.mat_ops
-@pytest.mark.parametrize(('mat1', 'mat2'), [(mat_a, mat_b), (mat_c, mat_d), (mat_d, mat_e),
-                                            (mat_f, mat_h)])
+@pytest.mark.parametrize(
+    ("mat1", "mat2"), [(mat_a, mat_b), (mat_c, mat_d), (mat_d, mat_e), (mat_f, mat_h)]
+)
 def test_subtraction(mat1, mat2):
     if (np.array(mat1)).shape < (2, 2) or (np.array(mat2)).shape < (2, 2):
         with pytest.raises(TypeError):
@@ -67,8 +69,9 @@ def test_subtraction(mat1, mat2):
 
 
 @pytest.mark.mat_ops
-@pytest.mark.parametrize(('mat1', 'mat2'), [(mat_a, mat_b), (mat_c, mat_d), (mat_d, mat_e),
-                                            (mat_f, mat_h)])
+@pytest.mark.parametrize(
+    ("mat1", "mat2"), [(mat_a, mat_b), (mat_c, mat_d), (mat_d, mat_e), (mat_f, mat_h)]
+)
 def test_multiplication(mat1, mat2):
     if (np.array(mat1)).shape < (2, 2) or (np.array(mat2)).shape < (2, 2):
         logger.info(f"\n\t{test_multiplication.__name__} returned integer")
@@ -81,7 +84,9 @@ def test_multiplication(mat1, mat2):
         assert theo == act
     else:
         with pytest.raises(ValueError):
-            logger.info(f"\n\t{test_multiplication.__name__} does not meet dim requirements")
+            logger.info(
+                f"\n\t{test_multiplication.__name__} does not meet dim requirements"
+            )
             assert matop.subtract(mat1, mat2)
 
 
@@ -100,7 +105,7 @@ def test_identity():
 
 
 @pytest.mark.mat_ops
-@pytest.mark.parametrize('mat', [mat_a, mat_b, mat_c, mat_d, mat_e, mat_f])
+@pytest.mark.parametrize("mat", [mat_a, mat_b, mat_c, mat_d, mat_e, mat_f])
 def test_transpose(mat):
     if (np.array(mat)).shape < (2, 2):
         with pytest.raises(TypeError):
diff --git a/networking_flow/ford_fulkerson.py b/networking_flow/ford_fulkerson.py
index d51f1f0661b3..0028c7cc577f 100644
--- a/networking_flow/ford_fulkerson.py
+++ b/networking_flow/ford_fulkerson.py
@@ -4,14 +4,15 @@
     (1) Start with initial flow as 0;
     (2) Choose augmenting path from source to sink and add path to flow;
 """
-    
+
+
 def BFS(graph, s, t, parent):
     # Return True if there is node that has not iterated.
-    visited = [False]*len(graph)
-    queue=[]
+    visited = [False] * len(graph)
+    queue = []
     queue.append(s)
     visited[s] = True
-    
+
     while queue:
         u = queue.pop(0)
         for ind in range(len(graph[u])):
@@ -21,36 +22,40 @@ def BFS(graph, s, t, parent):
                 parent[ind] = u
 
     return True if visited[t] else False
-     
+
+
 def FordFulkerson(graph, source, sink):
     # This array is filled by BFS and to store path
-    parent = [-1]*(len(graph))
-    max_flow = 0 
-    while BFS(graph, source, sink, parent) :
+    parent = [-1] * (len(graph))
+    max_flow = 0
+    while BFS(graph, source, sink, parent):
         path_flow = float("Inf")
         s = sink
 
-        while(s !=  source):
+        while s != source:
             # Find the minimum value in select path
-            path_flow = min (path_flow, graph[parent[s]][s])
+            path_flow = min(path_flow, graph[parent[s]][s])
             s = parent[s]
 
-        max_flow +=  path_flow
+        max_flow += path_flow
         v = sink
 
-        while(v !=  source):
+        while v != source:
             u = parent[v]
             graph[u][v] -= path_flow
             graph[v][u] += path_flow
             v = parent[v]
     return max_flow
 
-graph = [[0, 16, 13, 0, 0, 0],
-         [0, 0, 10 ,12, 0, 0],
-         [0, 4, 0, 0, 14, 0],
-         [0, 0, 9, 0, 0, 20],
-         [0, 0, 0, 7, 0, 4],
-         [0, 0, 0, 0, 0, 0]]
+
+graph = [
+    [0, 16, 13, 0, 0, 0],
+    [0, 0, 10, 12, 0, 0],
+    [0, 4, 0, 0, 14, 0],
+    [0, 0, 9, 0, 0, 20],
+    [0, 0, 0, 7, 0, 4],
+    [0, 0, 0, 0, 0, 0],
+]
 
 source, sink = 0, 5
-print(FordFulkerson(graph, source, sink))
\ No newline at end of file
+print(FordFulkerson(graph, source, sink))
diff --git a/neural_network/back_propagation_neural_network.py b/neural_network/back_propagation_neural_network.py
index 92deaee19c6e..86797694bb0a 100644
--- a/neural_network/back_propagation_neural_network.py
+++ b/neural_network/back_propagation_neural_network.py
@@ -1,7 +1,7 @@
 #!/usr/bin/python
 # encoding=utf8
 
-'''
+"""
 
 A Framework of Back Propagation Neural Network（BP） model
 
@@ -17,7 +17,7 @@
 Github : https://github.com/RiptideBo
 Date: 2017.11.23
 
-'''
+"""
 
 import numpy as np
 import matplotlib.pyplot as plt
@@ -26,18 +26,22 @@
 def sigmoid(x):
     return 1 / (1 + np.exp(-1 * x))
 
-class DenseLayer():
-    '''
+
+class DenseLayer:
+    """
     Layers of BP neural network
-    '''
-    def __init__(self,units,activation=None,learning_rate=None,is_input_layer=False):
-        '''
+    """
+
+    def __init__(
+        self, units, activation=None, learning_rate=None, is_input_layer=False
+    ):
+        """
         common connected layer of bp network
         :param units: numbers of neural units
         :param activation: activation function
         :param learning_rate: learning rate for paras
         :param is_input_layer: whether it is input layer or not
-        '''
+        """
         self.units = units
         self.weight = None
         self.bias = None
@@ -47,21 +51,21 @@ def __init__(self,units,activation=None,learning_rate=None,is_input_layer=False)
         self.learn_rate = learning_rate
         self.is_input_layer = is_input_layer
 
-    def initializer(self,back_units):
-        self.weight = np.asmatrix(np.random.normal(0,0.5,(self.units,back_units)))
-        self.bias = np.asmatrix(np.random.normal(0,0.5,self.units)).T
+    def initializer(self, back_units):
+        self.weight = np.asmatrix(np.random.normal(0, 0.5, (self.units, back_units)))
+        self.bias = np.asmatrix(np.random.normal(0, 0.5, self.units)).T
         if self.activation is None:
             self.activation = sigmoid
 
     def cal_gradient(self):
         if self.activation == sigmoid:
-            gradient_mat = np.dot(self.output ,(1- self.output).T)
+            gradient_mat = np.dot(self.output, (1 - self.output).T)
             gradient_activation = np.diag(np.diag(gradient_mat))
         else:
             gradient_activation = 1
         return gradient_activation
 
-    def forward_propagation(self,xdata):
+    def forward_propagation(self, xdata):
         self.xdata = xdata
         if self.is_input_layer:
             # input layer
@@ -69,22 +73,22 @@ def forward_propagation(self,xdata):
             self.output = xdata
             return xdata
         else:
-            self.wx_plus_b = np.dot(self.weight,self.xdata) - self.bias
+            self.wx_plus_b = np.dot(self.weight, self.xdata) - self.bias
             self.output = self.activation(self.wx_plus_b)
             return self.output
 
-    def back_propagation(self,gradient):
+    def back_propagation(self, gradient):
 
-        gradient_activation = self.cal_gradient() # i * i 维
-        gradient = np.asmatrix(np.dot(gradient.T,gradient_activation))
+        gradient_activation = self.cal_gradient()  # i * i 维
+        gradient = np.asmatrix(np.dot(gradient.T, gradient_activation))
 
         self._gradient_weight = np.asmatrix(self.xdata)
         self._gradient_bias = -1
         self._gradient_x = self.weight
 
-        self.gradient_weight = np.dot(gradient.T,self._gradient_weight.T)
+        self.gradient_weight = np.dot(gradient.T, self._gradient_weight.T)
         self.gradient_bias = gradient * self._gradient_bias
-        self.gradient = np.dot(gradient,self._gradient_x).T
+        self.gradient = np.dot(gradient, self._gradient_x).T
         # ----------------------upgrade
         # -----------the Negative gradient direction --------
         self.weight = self.weight - self.learn_rate * self.gradient_weight
@@ -93,33 +97,34 @@ def back_propagation(self,gradient):
         return self.gradient
 
 
-class BPNN():
-    '''
+class BPNN:
+    """
     Back Propagation Neural Network model
-    '''
+    """
+
     def __init__(self):
         self.layers = []
         self.train_mse = []
         self.fig_loss = plt.figure()
-        self.ax_loss = self.fig_loss.add_subplot(1,1,1)
+        self.ax_loss = self.fig_loss.add_subplot(1, 1, 1)
 
-    def add_layer(self,layer):
+    def add_layer(self, layer):
         self.layers.append(layer)
 
     def build(self):
-        for i,layer in enumerate(self.layers[:]):
+        for i, layer in enumerate(self.layers[:]):
             if i < 1:
                 layer.is_input_layer = True
             else:
-                layer.initializer(self.layers[i-1].units)
+                layer.initializer(self.layers[i - 1].units)
 
     def summary(self):
-        for i,layer in enumerate(self.layers[:]):
-            print('------- layer %d -------'%i)
-            print('weight.shape ',np.shape(layer.weight))
-            print('bias.shape ',np.shape(layer.bias))
+        for i, layer in enumerate(self.layers[:]):
+            print("------- layer %d -------" % i)
+            print("weight.shape ", np.shape(layer.weight))
+            print("bias.shape ", np.shape(layer.bias))
 
-    def train(self,xdata,ydata,train_round,accuracy):
+    def train(self, xdata, ydata, train_round, accuracy):
         self.train_round = train_round
         self.accuracy = accuracy
 
@@ -129,8 +134,8 @@ def train(self,xdata,ydata,train_round,accuracy):
         for round_i in range(train_round):
             all_loss = 0
             for row in range(x_shape[0]):
-                _xdata = np.asmatrix(xdata[row,:]).T
-                _ydata = np.asmatrix(ydata[row,:]).T
+                _xdata = np.asmatrix(xdata[row, :]).T
+                _ydata = np.asmatrix(ydata[row, :]).T
 
                 # forward propagation
                 for layer in self.layers:
@@ -144,40 +149,49 @@ def train(self,xdata,ydata,train_round,accuracy):
                 for layer in self.layers[:0:-1]:
                     gradient = layer.back_propagation(gradient)
 
-            mse = all_loss/x_shape[0]
+            mse = all_loss / x_shape[0]
             self.train_mse.append(mse)
 
             self.plot_loss()
 
             if mse < self.accuracy:
-                print('----达到精度----')
+                print("----达到精度----")
                 return mse
 
-    def cal_loss(self,ydata,ydata_):
-        self.loss = np.sum(np.power((ydata - ydata_),2))
+    def cal_loss(self, ydata, ydata_):
+        self.loss = np.sum(np.power((ydata - ydata_), 2))
         self.loss_gradient = 2 * (ydata_ - ydata)
         # vector (shape is the same as _ydata.shape)
-        return self.loss,self.loss_gradient
+        return self.loss, self.loss_gradient
 
     def plot_loss(self):
         if self.ax_loss.lines:
             self.ax_loss.lines.remove(self.ax_loss.lines[0])
-        self.ax_loss.plot(self.train_mse, 'r-')
+        self.ax_loss.plot(self.train_mse, "r-")
         plt.ion()
-        plt.xlabel('step')
-        plt.ylabel('loss')
+        plt.xlabel("step")
+        plt.ylabel("loss")
         plt.show()
         plt.pause(0.1)
 
 
-
-
 def example():
 
-    x = np.random.randn(10,10)
-    y = np.asarray([[0.8,0.4],[0.4,0.3],[0.34,0.45],[0.67,0.32],
-                    [0.88,0.67],[0.78,0.77],[0.55,0.66],[0.55,0.43],[0.54,0.1],
-                    [0.1,0.5]])
+    x = np.random.randn(10, 10)
+    y = np.asarray(
+        [
+            [0.8, 0.4],
+            [0.4, 0.3],
+            [0.34, 0.45],
+            [0.67, 0.32],
+            [0.88, 0.67],
+            [0.78, 0.77],
+            [0.55, 0.66],
+            [0.55, 0.43],
+            [0.54, 0.1],
+            [0.1, 0.5],
+        ]
+    )
 
     model = BPNN()
     model.add_layer(DenseLayer(10))
@@ -189,7 +203,8 @@ def example():
 
     model.summary()
 
-    model.train(xdata=x,ydata=y,train_round=100,accuracy=0.01)
+    model.train(xdata=x, ydata=y, train_round=100, accuracy=0.01)
+
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     example()
diff --git a/neural_network/convolution_neural_network.py b/neural_network/convolution_neural_network.py
index 786992c054a0..9448671abace 100644
--- a/neural_network/convolution_neural_network.py
+++ b/neural_network/convolution_neural_network.py
@@ -1,6 +1,6 @@
-#-*- coding: utf-8 -*-
+# -*- coding: utf-8 -*-
 
-'''
+"""
      - - - - - -- - - - - - - - - - - - - - - - - - - - - - -
     Name - - CNN - Convolution Neural Network For Photo Recognizing
     Goal - - Recognize Handing Writting Word Photo
@@ -14,15 +14,17 @@
     Github: 245885195@qq.com
     Date: 2017.9.20
     - - - - - -- - - - - - - - - - - - - - - - - - - - - - -
-'''
+"""
 import pickle
 import numpy as np
 import matplotlib.pyplot as plt
 
-class CNN():
 
-    def __init__(self, conv1_get, size_p1, bp_num1, bp_num2, bp_num3, rate_w=0.2, rate_t=0.2):
-        '''
+class CNN:
+    def __init__(
+        self, conv1_get, size_p1, bp_num1, bp_num2, bp_num3, rate_w=0.2, rate_t=0.2
+    ):
+        """
         :param conv1_get: [a,c,d]，size, number, step of convolution kernel
         :param size_p1: pooling size
         :param bp_num1: units number of flatten layer
@@ -30,7 +32,7 @@ def __init__(self, conv1_get, size_p1, bp_num1, bp_num2, bp_num3, rate_w=0.2, ra
         :param bp_num3: units number of output layer
         :param rate_w: rate of weight learning
         :param rate_t: rate of threshold learning
-        '''
+        """
         self.num_bp1 = bp_num1
         self.num_bp2 = bp_num2
         self.num_bp3 = bp_num3
@@ -39,206 +41,246 @@ def __init__(self, conv1_get, size_p1, bp_num1, bp_num2, bp_num3, rate_w=0.2, ra
         self.size_pooling1 = size_p1
         self.rate_weight = rate_w
         self.rate_thre = rate_t
-        self.w_conv1 = [np.mat(-1*np.random.rand(self.conv1[0],self.conv1[0])+0.5) for i in range(self.conv1[1])]
+        self.w_conv1 = [
+            np.mat(-1 * np.random.rand(self.conv1[0], self.conv1[0]) + 0.5)
+            for i in range(self.conv1[1])
+        ]
         self.wkj = np.mat(-1 * np.random.rand(self.num_bp3, self.num_bp2) + 0.5)
-        self.vji = np.mat(-1*np.random.rand(self.num_bp2, self.num_bp1)+0.5)
-        self.thre_conv1 = -2*np.random.rand(self.conv1[1])+1
-        self.thre_bp2 = -2*np.random.rand(self.num_bp2)+1
-        self.thre_bp3 = -2*np.random.rand(self.num_bp3)+1
-
+        self.vji = np.mat(-1 * np.random.rand(self.num_bp2, self.num_bp1) + 0.5)
+        self.thre_conv1 = -2 * np.random.rand(self.conv1[1]) + 1
+        self.thre_bp2 = -2 * np.random.rand(self.num_bp2) + 1
+        self.thre_bp3 = -2 * np.random.rand(self.num_bp3) + 1
 
     def save_model(self, save_path):
-        #save model dict with pickle
-        model_dic = {'num_bp1':self.num_bp1,
-                'num_bp2':self.num_bp2,
-                'num_bp3':self.num_bp3,
-                'conv1':self.conv1,
-                'step_conv1':self.step_conv1,
-                'size_pooling1':self.size_pooling1,
-                'rate_weight':self.rate_weight,
-                'rate_thre':self.rate_thre,
-                'w_conv1':self.w_conv1,
-                'wkj':self.wkj,
-                'vji':self.vji,
-                'thre_conv1':self.thre_conv1,
-                'thre_bp2':self.thre_bp2,
-                'thre_bp3':self.thre_bp3}
-        with open(save_path, 'wb') as f:
+        # save model dict with pickle
+        model_dic = {
+            "num_bp1": self.num_bp1,
+            "num_bp2": self.num_bp2,
+            "num_bp3": self.num_bp3,
+            "conv1": self.conv1,
+            "step_conv1": self.step_conv1,
+            "size_pooling1": self.size_pooling1,
+            "rate_weight": self.rate_weight,
+            "rate_thre": self.rate_thre,
+            "w_conv1": self.w_conv1,
+            "wkj": self.wkj,
+            "vji": self.vji,
+            "thre_conv1": self.thre_conv1,
+            "thre_bp2": self.thre_bp2,
+            "thre_bp3": self.thre_bp3,
+        }
+        with open(save_path, "wb") as f:
             pickle.dump(model_dic, f)
 
-        print('Model saved： %s'% save_path)
+        print("Model saved： %s" % save_path)
 
     @classmethod
     def ReadModel(cls, model_path):
-        #read saved model
-        with open(model_path, 'rb') as f:
+        # read saved model
+        with open(model_path, "rb") as f:
             model_dic = pickle.load(f)
 
-        conv_get= model_dic.get('conv1')
-        conv_get.append(model_dic.get('step_conv1'))
-        size_p1 = model_dic.get('size_pooling1')
-        bp1 = model_dic.get('num_bp1')
-        bp2 = model_dic.get('num_bp2')
-        bp3 = model_dic.get('num_bp3')
-        r_w = model_dic.get('rate_weight')
-        r_t = model_dic.get('rate_thre')
-        #create model instance
-        conv_ins = CNN(conv_get,size_p1,bp1,bp2,bp3,r_w,r_t)
-        #modify model parameter
-        conv_ins.w_conv1 = model_dic.get('w_conv1')
-        conv_ins.wkj = model_dic.get('wkj')
-        conv_ins.vji = model_dic.get('vji')
-        conv_ins.thre_conv1 = model_dic.get('thre_conv1')
-        conv_ins.thre_bp2 = model_dic.get('thre_bp2')
-        conv_ins.thre_bp3 = model_dic.get('thre_bp3')
+        conv_get = model_dic.get("conv1")
+        conv_get.append(model_dic.get("step_conv1"))
+        size_p1 = model_dic.get("size_pooling1")
+        bp1 = model_dic.get("num_bp1")
+        bp2 = model_dic.get("num_bp2")
+        bp3 = model_dic.get("num_bp3")
+        r_w = model_dic.get("rate_weight")
+        r_t = model_dic.get("rate_thre")
+        # create model instance
+        conv_ins = CNN(conv_get, size_p1, bp1, bp2, bp3, r_w, r_t)
+        # modify model parameter
+        conv_ins.w_conv1 = model_dic.get("w_conv1")
+        conv_ins.wkj = model_dic.get("wkj")
+        conv_ins.vji = model_dic.get("vji")
+        conv_ins.thre_conv1 = model_dic.get("thre_conv1")
+        conv_ins.thre_bp2 = model_dic.get("thre_bp2")
+        conv_ins.thre_bp3 = model_dic.get("thre_bp3")
         return conv_ins
 
-
     def sig(self, x):
-        return 1 / (1 + np.exp(-1*x))
+        return 1 / (1 + np.exp(-1 * x))
 
     def do_round(self, x):
         return round(x, 3)
 
     def convolute(self, data, convs, w_convs, thre_convs, conv_step):
-        #convolution process
+        # convolution process
         size_conv = convs[0]
-        num_conv =convs[1]
+        num_conv = convs[1]
         size_data = np.shape(data)[0]
-        #get the data slice of original image data, data_focus
+        # get the data slice of original image data, data_focus
         data_focus = []
         for i_focus in range(0, size_data - size_conv + 1, conv_step):
             for j_focus in range(0, size_data - size_conv + 1, conv_step):
-                focus = data[i_focus:i_focus + size_conv, j_focus:j_focus + size_conv]
+                focus = data[
+                    i_focus : i_focus + size_conv, j_focus : j_focus + size_conv
+                ]
                 data_focus.append(focus)
-        #caculate the feature map of every single kernel, and saved as list of matrix
+        # caculate the feature map of every single kernel, and saved as list of matrix
         data_featuremap = []
         Size_FeatureMap = int((size_data - size_conv) / conv_step + 1)
         for i_map in range(num_conv):
             featuremap = []
             for i_focus in range(len(data_focus)):
-                net_focus = np.sum(np.multiply(data_focus[i_focus], w_convs[i_map])) - thre_convs[i_map]
+                net_focus = (
+                    np.sum(np.multiply(data_focus[i_focus], w_convs[i_map]))
+                    - thre_convs[i_map]
+                )
                 featuremap.append(self.sig(net_focus))
-            featuremap = np.asmatrix(featuremap).reshape(Size_FeatureMap, Size_FeatureMap)
+            featuremap = np.asmatrix(featuremap).reshape(
+                Size_FeatureMap, Size_FeatureMap
+            )
             data_featuremap.append(featuremap)
 
-        #expanding the data slice to One dimenssion
+        # expanding the data slice to One dimenssion
         focus1_list = []
         for each_focus in data_focus:
             focus1_list.extend(self.Expand_Mat(each_focus))
         focus_list = np.asarray(focus1_list)
-        return focus_list,data_featuremap
+        return focus_list, data_featuremap
 
-    def pooling(self, featuremaps, size_pooling, type='average_pool'):
-        #pooling process
+    def pooling(self, featuremaps, size_pooling, type="average_pool"):
+        # pooling process
         size_map = len(featuremaps[0])
-        size_pooled = int(size_map/size_pooling)
+        size_pooled = int(size_map / size_pooling)
         featuremap_pooled = []
         for i_map in range(len(featuremaps)):
             map = featuremaps[i_map]
             map_pooled = []
-            for i_focus in range(0,size_map,size_pooling):
+            for i_focus in range(0, size_map, size_pooling):
                 for j_focus in range(0, size_map, size_pooling):
-                    focus = map[i_focus:i_focus + size_pooling, j_focus:j_focus + size_pooling]
-                    if type == 'average_pool':
-                        #average pooling
+                    focus = map[
+                        i_focus : i_focus + size_pooling,
+                        j_focus : j_focus + size_pooling,
+                    ]
+                    if type == "average_pool":
+                        # average pooling
                         map_pooled.append(np.average(focus))
-                    elif type == 'max_pooling':
-                        #max pooling
+                    elif type == "max_pooling":
+                        # max pooling
                         map_pooled.append(np.max(focus))
-            map_pooled = np.asmatrix(map_pooled).reshape(size_pooled,size_pooled)
+            map_pooled = np.asmatrix(map_pooled).reshape(size_pooled, size_pooled)
             featuremap_pooled.append(map_pooled)
         return featuremap_pooled
 
     def _expand(self, datas):
-        #expanding three dimension data to one dimension list
+        # expanding three dimension data to one dimension list
         data_expanded = []
         for i in range(len(datas)):
             shapes = np.shape(datas[i])
-            data_listed = datas[i].reshape(1,shapes[0]*shapes[1])
+            data_listed = datas[i].reshape(1, shapes[0] * shapes[1])
             data_listed = data_listed.getA().tolist()[0]
             data_expanded.extend(data_listed)
         data_expanded = np.asarray(data_expanded)
         return data_expanded
 
     def _expand_mat(self, data_mat):
-        #expanding matrix to one dimension list
+        # expanding matrix to one dimension list
         data_mat = np.asarray(data_mat)
         shapes = np.shape(data_mat)
-        data_expanded = data_mat.reshape(1,shapes[0]*shapes[1])
+        data_expanded = data_mat.reshape(1, shapes[0] * shapes[1])
         return data_expanded
 
-    def _calculate_gradient_from_pool(self, out_map, pd_pool,num_map, size_map, size_pooling):
-        '''
+    def _calculate_gradient_from_pool(
+        self, out_map, pd_pool, num_map, size_map, size_pooling
+    ):
+        """
         calcluate the gradient from the data slice of pool layer
         pd_pool: list of matrix
         out_map: the shape of data slice(size_map*size_map)
         return: pd_all: list of matrix, [num, size_map, size_map]
-        '''
+        """
         pd_all = []
         i_pool = 0
         for i_map in range(num_map):
             pd_conv1 = np.ones((size_map, size_map))
             for i in range(0, size_map, size_pooling):
                 for j in range(0, size_map, size_pooling):
-                    pd_conv1[i:i + size_pooling, j:j + size_pooling] = pd_pool[i_pool]
+                    pd_conv1[i : i + size_pooling, j : j + size_pooling] = pd_pool[
+                        i_pool
+                    ]
                     i_pool = i_pool + 1
-            pd_conv2 = np.multiply(pd_conv1,np.multiply(out_map[i_map],(1-out_map[i_map])))
+            pd_conv2 = np.multiply(
+                pd_conv1, np.multiply(out_map[i_map], (1 - out_map[i_map]))
+            )
             pd_all.append(pd_conv2)
         return pd_all
 
-    def train(self, patterns, datas_train, datas_teach, n_repeat, error_accuracy, draw_e = bool):
-        #model traning
-        print('----------------------Start Training-------------------------')
-        print((' - - Shape: Train_Data  ',np.shape(datas_train)))
-        print((' - - Shape: Teach_Data  ',np.shape(datas_teach)))
+    def train(
+        self, patterns, datas_train, datas_teach, n_repeat, error_accuracy, draw_e=bool
+    ):
+        # model traning
+        print("----------------------Start Training-------------------------")
+        print((" - - Shape: Train_Data  ", np.shape(datas_train)))
+        print((" - - Shape: Teach_Data  ", np.shape(datas_teach)))
         rp = 0
         all_mse = []
-        mse  = 10000
+        mse = 10000
         while rp < n_repeat and mse >= error_accuracy:
             alle = 0
-            print('-------------Learning Time %d--------------'%rp)
+            print("-------------Learning Time %d--------------" % rp)
             for p in range(len(datas_train)):
-                #print('------------Learning Image: %d--------------'%p)
+                # print('------------Learning Image: %d--------------'%p)
                 data_train = np.asmatrix(datas_train[p])
                 data_teach = np.asarray(datas_teach[p])
-                data_focus1,data_conved1 = self.convolute(data_train,self.conv1,self.w_conv1,
-                        self.thre_conv1,conv_step=self.step_conv1)
-                data_pooled1 = self.pooling(data_conved1,self.size_pooling1)
+                data_focus1, data_conved1 = self.convolute(
+                    data_train,
+                    self.conv1,
+                    self.w_conv1,
+                    self.thre_conv1,
+                    conv_step=self.step_conv1,
+                )
+                data_pooled1 = self.pooling(data_conved1, self.size_pooling1)
                 shape_featuremap1 = np.shape(data_conved1)
-                '''
+                """
                 print('  -----original shape   ', np.shape(data_train))
                 print('  ---- after convolution  ',np.shape(data_conv1))
                 print('  -----after pooling  ',np.shape(data_pooled1))
-               '''
+               """
                 data_bp_input = self._expand(data_pooled1)
                 bp_out1 = data_bp_input
 
-                bp_net_j = np.dot(bp_out1,self.vji.T) - self.thre_bp2
+                bp_net_j = np.dot(bp_out1, self.vji.T) - self.thre_bp2
                 bp_out2 = self.sig(bp_net_j)
-                bp_net_k = np.dot(bp_out2 ,self.wkj.T) - self.thre_bp3
+                bp_net_k = np.dot(bp_out2, self.wkj.T) - self.thre_bp3
                 bp_out3 = self.sig(bp_net_k)
 
-                #--------------Model Leaning ------------------------
+                # --------------Model Leaning ------------------------
                 # calcluate error and gradient---------------
-                pd_k_all = np.multiply((data_teach - bp_out3), np.multiply(bp_out3, (1 - bp_out3)))
-                pd_j_all = np.multiply(np.dot(pd_k_all,self.wkj), np.multiply(bp_out2, (1 - bp_out2)))
-                pd_i_all = np.dot(pd_j_all,self.vji)
+                pd_k_all = np.multiply(
+                    (data_teach - bp_out3), np.multiply(bp_out3, (1 - bp_out3))
+                )
+                pd_j_all = np.multiply(
+                    np.dot(pd_k_all, self.wkj), np.multiply(bp_out2, (1 - bp_out2))
+                )
+                pd_i_all = np.dot(pd_j_all, self.vji)
 
-                pd_conv1_pooled = pd_i_all / (self.size_pooling1*self.size_pooling1)
+                pd_conv1_pooled = pd_i_all / (self.size_pooling1 * self.size_pooling1)
                 pd_conv1_pooled = pd_conv1_pooled.T.getA().tolist()
-                pd_conv1_all = self._calculate_gradient_from_pool(data_conved1,pd_conv1_pooled,shape_featuremap1[0],
-                        shape_featuremap1[1],self.size_pooling1)
-                #weight and threshold learning process---------
-                #convolution layer
+                pd_conv1_all = self._calculate_gradient_from_pool(
+                    data_conved1,
+                    pd_conv1_pooled,
+                    shape_featuremap1[0],
+                    shape_featuremap1[1],
+                    self.size_pooling1,
+                )
+                # weight and threshold learning process---------
+                # convolution layer
                 for k_conv in range(self.conv1[1]):
                     pd_conv_list = self._expand_mat(pd_conv1_all[k_conv])
-                    delta_w = self.rate_weight * np.dot(pd_conv_list,data_focus1)
+                    delta_w = self.rate_weight * np.dot(pd_conv_list, data_focus1)
 
-                    self.w_conv1[k_conv] = self.w_conv1[k_conv] + delta_w.reshape((self.conv1[0],self.conv1[0]))
+                    self.w_conv1[k_conv] = self.w_conv1[k_conv] + delta_w.reshape(
+                        (self.conv1[0], self.conv1[0])
+                    )
 
-                    self.thre_conv1[k_conv] = self.thre_conv1[k_conv] - np.sum(pd_conv1_all[k_conv]) * self.rate_thre
-                #all connected layer
+                    self.thre_conv1[k_conv] = (
+                        self.thre_conv1[k_conv]
+                        - np.sum(pd_conv1_all[k_conv]) * self.rate_thre
+                    )
+                # all connected layer
                 self.wkj = self.wkj + pd_k_all.T * bp_out2 * self.rate_weight
                 self.vji = self.vji + pd_j_all.T * bp_out1 * self.rate_weight
                 self.thre_bp3 = self.thre_bp3 - pd_k_all * self.rate_thre
@@ -246,34 +288,41 @@ def train(self, patterns, datas_train, datas_teach, n_repeat, error_accuracy, dr
                 # calculate the sum error of all single image
                 errors = np.sum(abs((data_teach - bp_out3)))
                 alle = alle + errors
-                #print('   ----Teach      ',data_teach)
-                #print('   ----BP_output  ',bp_out3)
+                # print('   ----Teach      ',data_teach)
+                # print('   ----BP_output  ',bp_out3)
             rp = rp + 1
-            mse = alle/patterns
+            mse = alle / patterns
             all_mse.append(mse)
+
         def draw_error():
             yplot = [error_accuracy for i in range(int(n_repeat * 1.2))]
-            plt.plot(all_mse, '+-')
-            plt.plot(yplot, 'r--')
-            plt.xlabel('Learning Times')
-            plt.ylabel('All_mse')
+            plt.plot(all_mse, "+-")
+            plt.plot(yplot, "r--")
+            plt.xlabel("Learning Times")
+            plt.ylabel("All_mse")
             plt.grid(True, alpha=0.5)
             plt.show()
-        print('------------------Training Complished---------------------')
-        print((' - - Training epoch: ', rp, '     - - Mse: %.6f' % mse))
+
+        print("------------------Training Complished---------------------")
+        print((" - - Training epoch: ", rp, "     - - Mse: %.6f" % mse))
         if draw_e:
             draw_error()
         return mse
 
     def predict(self, datas_test):
-        #model predict
+        # model predict
         produce_out = []
-        print('-------------------Start Testing-------------------------')
-        print((' - - Shape: Test_Data  ',np.shape(datas_test)))
+        print("-------------------Start Testing-------------------------")
+        print((" - - Shape: Test_Data  ", np.shape(datas_test)))
         for p in range(len(datas_test)):
             data_test = np.asmatrix(datas_test[p])
-            data_focus1, data_conved1 = self.convolute(data_test, self.conv1, self.w_conv1,
-                    self.thre_conv1, conv_step=self.step_conv1)
+            data_focus1, data_conved1 = self.convolute(
+                data_test,
+                self.conv1,
+                self.w_conv1,
+                self.thre_conv1,
+                conv_step=self.step_conv1,
+            )
             data_pooled1 = self.pooling(data_conved1, self.size_pooling1)
             data_bp_input = self._expand(data_pooled1)
 
@@ -283,20 +332,25 @@ def predict(self, datas_test):
             bp_net_k = bp_out2 * self.wkj.T - self.thre_bp3
             bp_out3 = self.sig(bp_net_k)
             produce_out.extend(bp_out3.getA().tolist())
-        res = [list(map(self.do_round,each)) for each in produce_out]
+        res = [list(map(self.do_round, each)) for each in produce_out]
         return np.asarray(res)
 
     def convolution(self, data):
-        #return the data of image after convoluting process so we can check it out
+        # return the data of image after convoluting process so we can check it out
         data_test = np.asmatrix(data)
-        data_focus1, data_conved1 = self.convolute(data_test, self.conv1, self.w_conv1,
-                self.thre_conv1, conv_step=self.step_conv1)
+        data_focus1, data_conved1 = self.convolute(
+            data_test,
+            self.conv1,
+            self.w_conv1,
+            self.thre_conv1,
+            conv_step=self.step_conv1,
+        )
         data_pooled1 = self.pooling(data_conved1, self.size_pooling1)
 
-        return data_conved1,data_pooled1
+        return data_conved1, data_pooled1
 
 
-if __name__ == '__main__':
-    '''
+if __name__ == "__main__":
+    """
     I will put the example on other file
-    '''
+    """
diff --git a/neural_network/perceptron.py b/neural_network/perceptron.py
index fdc710597241..5feb8610a911 100644
--- a/neural_network/perceptron.py
+++ b/neural_network/perceptron.py
@@ -1,4 +1,4 @@
-'''
+"""
 
     Perceptron
     w = w + N * (d(k) - y) * x(k)
@@ -8,7 +8,7 @@
     p1 = -1
     p2 = 1
 
-'''
+"""
 import random
 
 
@@ -28,7 +28,7 @@ def training(self):
             sample.insert(0, self.bias)
 
         for i in range(self.col_sample):
-           self.weight.append(random.random())
+            self.weight.append(random.random())
 
         self.weight.insert(0, self.bias)
 
@@ -45,15 +45,18 @@ def training(self):
 
                     for j in range(self.col_sample + 1):
 
-                        self.weight[j] = self.weight[j] + self.learn_rate * (self.exit[i] - y) * self.sample[i][j]
+                        self.weight[j] = (
+                            self.weight[j]
+                            + self.learn_rate * (self.exit[i] - y) * self.sample[i][j]
+                        )
                     erro = True
-            #print('Epoch: \n',epoch_count)
+            # print('Epoch: \n',epoch_count)
             epoch_count = epoch_count + 1
             # if you want controle the epoch or just by erro
             if erro == False:
-                print(('\nEpoch:\n',epoch_count))
-                print('------------------------\n')
-            #if epoch_count > self.epoch_number or not erro:
+                print(("\nEpoch:\n", epoch_count))
+                print("------------------------\n")
+                # if epoch_count > self.epoch_number or not erro:
                 break
 
     def sort(self, sample):
@@ -64,12 +67,12 @@ def sort(self, sample):
 
         y = self.sign(u)
 
-        if  y == -1:
-            print(('Sample: ', sample))
-            print('classification: P1')
+        if y == -1:
+            print(("Sample: ", sample))
+            print("classification: P1")
         else:
-            print(('Sample: ', sample))
-            print('classification: P2')
+            print(("Sample: ", sample))
+            print("classification: P2")
 
     def sign(self, u):
         return 1 if u >= 0 else -1
@@ -105,19 +108,51 @@ def sign(self, u):
     [-0.1013, 0.5989, 7.1812],
     [2.4482, 0.9455, 11.2095],
     [2.0149, 0.6192, 10.9263],
-    [0.2012, 0.2611, 5.4631]
-
+    [0.2012, 0.2611, 5.4631],
 ]
 
-exit = [-1, -1, -1, 1, 1, -1, 1, -1, 1, 1, -1, 1, -1, -1, -1, -1, 1, 1, 1, 1, -1, 1, 1, 1, 1, -1, -1, 1, -1, 1]
+exit = [
+    -1,
+    -1,
+    -1,
+    1,
+    1,
+    -1,
+    1,
+    -1,
+    1,
+    1,
+    -1,
+    1,
+    -1,
+    -1,
+    -1,
+    -1,
+    1,
+    1,
+    1,
+    1,
+    -1,
+    1,
+    1,
+    1,
+    1,
+    -1,
+    -1,
+    1,
+    -1,
+    1,
+]
 
-network = Perceptron(sample=samples, exit = exit, learn_rate=0.01, epoch_number=1000, bias=-1)
+network = Perceptron(
+    sample=samples, exit=exit, learn_rate=0.01, epoch_number=1000, bias=-1
+)
 
 network.training()
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     while True:
         sample = []
         for i in range(3):
-            sample.insert(i, float(input('value: ')))
+            sample.insert(i, float(input("value: ")))
         network.sort(sample)
diff --git a/other/anagrams.py b/other/anagrams.py
index 1e6e38dee139..9e103296b382 100644
--- a/other/anagrams.py
+++ b/other/anagrams.py
@@ -1,29 +1,32 @@
 import collections, pprint, time, os
 
 start_time = time.time()
-print('creating word list...')
+print("creating word list...")
 path = os.path.split(os.path.realpath(__file__))
-with open(path[0] + '/words') as f:
+with open(path[0] + "/words") as f:
     word_list = sorted(list(set([word.strip().lower() for word in f])))
 
+
 def signature(word):
-    return ''.join(sorted(word))
+    return "".join(sorted(word))
+
 
 word_bysig = collections.defaultdict(list)
 for word in word_list:
     word_bysig[signature(word)].append(word)
 
+
 def anagram(myword):
     return word_bysig[signature(myword)]
 
-print('finding anagrams...')
-all_anagrams = {word: anagram(word)
-                for word in word_list if len(anagram(word)) > 1}
 
-print('writing anagrams to file...')
-with open('anagrams.txt', 'w') as file:
-    file.write('all_anagrams = ')
+print("finding anagrams...")
+all_anagrams = {word: anagram(word) for word in word_list if len(anagram(word)) > 1}
+
+print("writing anagrams to file...")
+with open("anagrams.txt", "w") as file:
+    file.write("all_anagrams = ")
     file.write(pprint.pformat(all_anagrams))
 
 total_time = round(time.time() - start_time, 2)
-print(('Done [', total_time, 'seconds ]'))
+print(("Done [", total_time, "seconds ]"))
diff --git a/other/binary_exponentiation.py b/other/binary_exponentiation.py
index 1a30fb8fd266..dd4e70e74129 100644
--- a/other/binary_exponentiation.py
+++ b/other/binary_exponentiation.py
@@ -14,7 +14,7 @@
 def b_expo(a, b):
     res = 1
     while b > 0:
-        if b&1:
+        if b & 1:
             res *= a
 
         a *= a
@@ -26,14 +26,15 @@ def b_expo(a, b):
 def b_expo_mod(a, b, c):
     res = 1
     while b > 0:
-        if b&1:
-            res = ((res%c) * (a%c)) % c
+        if b & 1:
+            res = ((res % c) * (a % c)) % c
 
         a *= a
         b >>= 1
 
     return res
 
+
 """
 * Wondering how this method works !
 * It's pretty simple.
diff --git a/other/binary_exponentiation_2.py b/other/binary_exponentiation_2.py
index 217a616c99fb..51ec4baf2598 100644
--- a/other/binary_exponentiation_2.py
+++ b/other/binary_exponentiation_2.py
@@ -14,7 +14,7 @@
 def b_expo(a, b):
     res = 0
     while b > 0:
-        if b&1:
+        if b & 1:
             res += a
 
         a += a
@@ -26,8 +26,8 @@ def b_expo(a, b):
 def b_expo_mod(a, b, c):
     res = 0
     while b > 0:
-        if b&1:
-            res = ((res%c) + (a%c)) % c
+        if b & 1:
+            res = ((res % c) + (a % c)) % c
 
         a += a
         b >>= 1
diff --git a/other/detecting_english_programmatically.py b/other/detecting_english_programmatically.py
index 8b73ff6cf0c3..4b0bb37ce520 100644
--- a/other/detecting_english_programmatically.py
+++ b/other/detecting_english_programmatically.py
@@ -1,18 +1,21 @@
 import os
 
-UPPERLETTERS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
-LETTERS_AND_SPACE = UPPERLETTERS + UPPERLETTERS.lower() + ' \t\n'
+UPPERLETTERS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+LETTERS_AND_SPACE = UPPERLETTERS + UPPERLETTERS.lower() + " \t\n"
+
 
 def loadDictionary():
     path = os.path.split(os.path.realpath(__file__))
     englishWords = {}
-    with open(path[0] + '/dictionary.txt') as dictionaryFile:
-        for word in dictionaryFile.read().split('\n'):
+    with open(path[0] + "/dictionary.txt") as dictionaryFile:
+        for word in dictionaryFile.read().split("\n"):
             englishWords[word] = None
     return englishWords
 
+
 ENGLISH_WORDS = loadDictionary()
 
+
 def getEnglishCount(message):
     message = message.upper()
     message = removeNonLetters(message)
@@ -28,14 +31,16 @@ def getEnglishCount(message):
 
     return float(matches) / len(possibleWords)
 
+
 def removeNonLetters(message):
     lettersOnly = []
     for symbol in message:
         if symbol in LETTERS_AND_SPACE:
             lettersOnly.append(symbol)
-    return ''.join(lettersOnly)
+    return "".join(lettersOnly)
+
 
-def isEnglish(message, wordPercentage = 20, letterPercentage = 85):
+def isEnglish(message, wordPercentage=20, letterPercentage=85):
     """
     >>> isEnglish('Hello World')
     True
@@ -51,4 +56,5 @@ def isEnglish(message, wordPercentage = 20, letterPercentage = 85):
 
 
 import doctest
+
 doctest.testmod()
diff --git a/other/euclidean_gcd.py b/other/euclidean_gcd.py
index 13378379f286..c6c11f947a08 100644
--- a/other/euclidean_gcd.py
+++ b/other/euclidean_gcd.py
@@ -1,5 +1,6 @@
 # https://en.wikipedia.org/wiki/Euclidean_algorithm
 
+
 def euclidean_gcd(a, b):
     while b:
         t = b
@@ -7,6 +8,7 @@ def euclidean_gcd(a, b):
         a = t
     return a
 
+
 def main():
     print("GCD(3, 5) = " + str(euclidean_gcd(3, 5)))
     print("GCD(5, 3) = " + str(euclidean_gcd(5, 3)))
@@ -14,5 +16,6 @@ def main():
     print("GCD(3, 6) = " + str(euclidean_gcd(3, 6)))
     print("GCD(6, 3) = " + str(euclidean_gcd(6, 3)))
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
     main()
diff --git a/other/fischer_yates_shuffle.py b/other/fischer_yates_shuffle.py
index bc2b136344c7..977e5f131e4f 100644
--- a/other/fischer_yates_shuffle.py
+++ b/other/fischer_yates_shuffle.py
@@ -7,16 +7,18 @@
 """
 import random
 
+
 def FYshuffle(LIST):
     for i in range(len(LIST)):
-        a = random.randint(0, len(LIST)-1)
-        b = random.randint(0, len(LIST)-1)
+        a = random.randint(0, len(LIST) - 1)
+        b = random.randint(0, len(LIST) - 1)
         LIST[a], LIST[b] = LIST[b], LIST[a]
     return LIST
 
-if __name__ == '__main__':
-    integers = [0,1,2,3,4,5,6,7]
-    strings = ['python', 'says', 'hello', '!']
-    print('Fisher-Yates Shuffle:')
-    print('List',integers, strings)
-    print('FY Shuffle',FYshuffle(integers), FYshuffle(strings))
+
+if __name__ == "__main__":
+    integers = [0, 1, 2, 3, 4, 5, 6, 7]
+    strings = ["python", "says", "hello", "!"]
+    print("Fisher-Yates Shuffle:")
+    print("List", integers, strings)
+    print("FY Shuffle", FYshuffle(integers), FYshuffle(strings))
diff --git a/other/frequency_finder.py b/other/frequency_finder.py
index 6264b25bf303..48760a9deb09 100644
--- a/other/frequency_finder.py
+++ b/other/frequency_finder.py
@@ -1,29 +1,78 @@
 # Frequency Finder
 
 # frequency taken from http://en.wikipedia.org/wiki/Letter_frequency
-englishLetterFreq = {'E': 12.70, 'T': 9.06, 'A': 8.17, 'O': 7.51, 'I': 6.97,
-                     'N': 6.75, 'S': 6.33, 'H': 6.09, 'R': 5.99, 'D': 4.25,
-                     'L': 4.03, 'C': 2.78, 'U': 2.76, 'M': 2.41, 'W': 2.36,
-                     'F': 2.23, 'G': 2.02, 'Y': 1.97, 'P': 1.93, 'B': 1.29,
-                     'V': 0.98, 'K': 0.77, 'J': 0.15, 'X': 0.15, 'Q': 0.10,
-                     'Z': 0.07}
-ETAOIN = 'ETAOINSHRDLCUMWFGYPBVKJXQZ'
-LETTERS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+englishLetterFreq = {
+    "E": 12.70,
+    "T": 9.06,
+    "A": 8.17,
+    "O": 7.51,
+    "I": 6.97,
+    "N": 6.75,
+    "S": 6.33,
+    "H": 6.09,
+    "R": 5.99,
+    "D": 4.25,
+    "L": 4.03,
+    "C": 2.78,
+    "U": 2.76,
+    "M": 2.41,
+    "W": 2.36,
+    "F": 2.23,
+    "G": 2.02,
+    "Y": 1.97,
+    "P": 1.93,
+    "B": 1.29,
+    "V": 0.98,
+    "K": 0.77,
+    "J": 0.15,
+    "X": 0.15,
+    "Q": 0.10,
+    "Z": 0.07,
+}
+ETAOIN = "ETAOINSHRDLCUMWFGYPBVKJXQZ"
+LETTERS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+
 
 def getLetterCount(message):
-    letterCount = {'A': 0, 'B': 0, 'C': 0, 'D': 0, 'E': 0, 'F': 0, 'G': 0, 'H': 0,
-                   'I': 0, 'J': 0, 'K': 0, 'L': 0, 'M': 0, 'N': 0, 'O': 0, 'P': 0,
-                   'Q': 0, 'R': 0, 'S': 0, 'T': 0, 'U': 0, 'V': 0, 'W': 0, 'X': 0,
-                   'Y': 0, 'Z': 0}
+    letterCount = {
+        "A": 0,
+        "B": 0,
+        "C": 0,
+        "D": 0,
+        "E": 0,
+        "F": 0,
+        "G": 0,
+        "H": 0,
+        "I": 0,
+        "J": 0,
+        "K": 0,
+        "L": 0,
+        "M": 0,
+        "N": 0,
+        "O": 0,
+        "P": 0,
+        "Q": 0,
+        "R": 0,
+        "S": 0,
+        "T": 0,
+        "U": 0,
+        "V": 0,
+        "W": 0,
+        "X": 0,
+        "Y": 0,
+        "Z": 0,
+    }
     for letter in message.upper():
         if letter in LETTERS:
             letterCount[letter] += 1
 
     return letterCount
 
+
 def getItemAtIndexZero(x):
     return x[0]
 
+
 def getFrequencyOrder(message):
     letterToFreq = getLetterCount(message)
     freqToLetter = {}
@@ -34,23 +83,24 @@ def getFrequencyOrder(message):
             freqToLetter[letterToFreq[letter]].append(letter)
 
     for freq in freqToLetter:
-        freqToLetter[freq].sort(key = ETAOIN.find, reverse = True)
-        freqToLetter[freq] = ''.join(freqToLetter[freq])
+        freqToLetter[freq].sort(key=ETAOIN.find, reverse=True)
+        freqToLetter[freq] = "".join(freqToLetter[freq])
 
     freqPairs = list(freqToLetter.items())
-    freqPairs.sort(key = getItemAtIndexZero, reverse = True)
+    freqPairs.sort(key=getItemAtIndexZero, reverse=True)
 
     freqOrder = []
     for freqPair in freqPairs:
         freqOrder.append(freqPair[1])
 
-    return ''.join(freqOrder)
+    return "".join(freqOrder)
+
 
 def englishFreqMatchScore(message):
-    '''
+    """
     >>> englishFreqMatchScore('Hello World')
     1
-    '''
+    """
     freqOrder = getFrequencyOrder(message)
     matchScore = 0
     for commonLetter in ETAOIN[:6]:
@@ -63,6 +113,8 @@ def englishFreqMatchScore(message):
 
     return matchScore
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
     import doctest
+
     doctest.testmod()
diff --git a/other/game_of_life.py b/other/game_of_life.py
index 1fdaa21b4a7b..2b4d1116fa8c 100644
--- a/other/game_of_life.py
+++ b/other/game_of_life.py
@@ -1,4 +1,4 @@
-'''Conway's Game Of Life, Author Anurag Kumar(mailto:anuragkumarak95@gmail.com) 
+"""Conway's Game Of Life, Author Anurag Kumar(mailto:anuragkumarak95@gmail.com) 
 
 Requirements:
   - numpy
@@ -26,28 +26,31 @@
  4.
  Any dead cell with exactly three live neighbours be-
  comes a live cell, as if by reproduction.
- '''
+ """
 import numpy as np
 import random, sys
 from matplotlib import pyplot as plt
 from matplotlib.colors import ListedColormap
 
-usage_doc='Usage of script: script_nama <size_of_canvas:int>'
+usage_doc = "Usage of script: script_nama <size_of_canvas:int>"
 
-choice = [0]*100 + [1]*10
+choice = [0] * 100 + [1] * 10
 random.shuffle(choice)
 
+
 def create_canvas(size):
-    canvas = [ [False for i in range(size)] for j in range(size)]
+    canvas = [[False for i in range(size)] for j in range(size)]
     return canvas
 
+
 def seed(canvas):
-    for i,row in enumerate(canvas):
-        for j,_ in enumerate(row):
-            canvas[i][j]=bool(random.getrandbits(1))
+    for i, row in enumerate(canvas):
+        for j, _ in enumerate(row):
+            canvas[i][j] = bool(random.getrandbits(1))
+
 
 def run(canvas):
-    ''' This  function runs the rules of game through all points, and changes their status accordingly.(in the same canvas)
+    """ This  function runs the rules of game through all points, and changes their status accordingly.(in the same canvas)
     @Args:
     --
     canvas : canvas of population to run the rules on.
@@ -55,63 +58,71 @@ def run(canvas):
     @returns:
     --
     None
-    '''
+    """
     canvas = np.array(canvas)
     next_gen_canvas = np.array(create_canvas(canvas.shape[0]))
     for r, row in enumerate(canvas):
         for c, pt in enumerate(row):
             # print(r-1,r+2,c-1,c+2)
-            next_gen_canvas[r][c] = __judge_point(pt,canvas[r-1:r+2,c-1:c+2])
-    
+            next_gen_canvas[r][c] = __judge_point(
+                pt, canvas[r - 1 : r + 2, c - 1 : c + 2]
+            )
+
     canvas = next_gen_canvas
-    del next_gen_canvas # cleaning memory as we move on.
-    return canvas.tolist()   
+    del next_gen_canvas  # cleaning memory as we move on.
+    return canvas.tolist()
+
 
-def __judge_point(pt,neighbours):
-    dead  = 0
+def __judge_point(pt, neighbours):
+    dead = 0
     alive = 0
     # finding dead or alive neighbours count.
     for i in neighbours:
         for status in i:
-            if status: alive+=1
-            else: dead+=1
+            if status:
+                alive += 1
+            else:
+                dead += 1
 
     # handling duplicate entry for focus pt.
-    if pt : alive-=1
-    else : dead-=1
-    
+    if pt:
+        alive -= 1
+    else:
+        dead -= 1
+
     # running the rules of game here.
     state = pt
     if pt:
-        if alive<2:
-            state=False
-        elif alive==2 or alive==3:
-            state=True
-        elif alive>3:
-            state=False
+        if alive < 2:
+            state = False
+        elif alive == 2 or alive == 3:
+            state = True
+        elif alive > 3:
+            state = False
     else:
-        if alive==3:
-            state=True
+        if alive == 3:
+            state = True
 
     return state
 
 
-if __name__=='__main__':
-    if len(sys.argv) != 2: raise Exception(usage_doc)
-   
+if __name__ == "__main__":
+    if len(sys.argv) != 2:
+        raise Exception(usage_doc)
+
     canvas_size = int(sys.argv[1])
     # main working structure of this module.
-    c=create_canvas(canvas_size)
+    c = create_canvas(canvas_size)
     seed(c)
     fig, ax = plt.subplots()
-    fig.show() 
-    cmap = ListedColormap(['w','k'])
+    fig.show()
+    cmap = ListedColormap(["w", "k"])
     try:
         while True:
-            c = run(c)            
-            ax.matshow(c,cmap=cmap)
+            c = run(c)
+            ax.matshow(c, cmap=cmap)
             fig.canvas.draw()
-            ax.cla() 
+            ax.cla()
     except KeyboardInterrupt:
         # do nothing.
         pass
diff --git a/other/linear_congruential_generator.py b/other/linear_congruential_generator.py
index 7c592a6400b5..3b150f422e4f 100644
--- a/other/linear_congruential_generator.py
+++ b/other/linear_congruential_generator.py
@@ -2,12 +2,13 @@
 
 from time import time
 
+
 class LinearCongruentialGenerator(object):
     """
     A pseudorandom number generator.
     """
 
-    def __init__( self, multiplier, increment, modulo, seed=int(time()) ):
+    def __init__(self, multiplier, increment, modulo, seed=int(time())):
         """
         These parameters are saved and used when nextNumber() is called.
 
@@ -19,7 +20,7 @@ def __init__( self, multiplier, increment, modulo, seed=int(time()) ):
         self.modulo = modulo
         self.seed = seed
 
-    def next_number( self ):
+    def next_number(self):
         """
         The smallest number that can be generated is zero.
         The largest number that can be generated is modulo-1. modulo is set in the constructor.
@@ -27,8 +28,9 @@ def next_number( self ):
         self.seed = (self.multiplier * self.seed + self.increment) % self.modulo
         return self.seed
 
+
 if __name__ == "__main__":
     # Show the LCG in action.
-    lcg = LinearCongruentialGenerator(1664525, 1013904223, 2<<31)
-    while True :
-        print(lcg.next_number())
\ No newline at end of file
+    lcg = LinearCongruentialGenerator(1664525, 1013904223, 2 << 31)
+    while True:
+        print(lcg.next_number())
diff --git a/other/nested_brackets.py b/other/nested_brackets.py
index 14147eaa6456..011e94b92928 100644
--- a/other/nested_brackets.py
+++ b/other/nested_brackets.py
@@ -1,4 +1,4 @@
-'''
+"""
 The nested brackets problem is a problem that determines if a sequence of
 brackets are properly nested.  A sequence of brackets s is considered properly nested
 if any of the following conditions are true:
@@ -12,13 +12,15 @@
 The function called is_balanced takes as input a string S which is a sequence of brackets and
 returns true if S is nested and false otherwise.
 
-'''
+"""
+
+
 def is_balanced(S):
 
     stack = []
-    open_brackets = set({'(', '[', '{'})
-    closed_brackets = set({')', ']', '}'})
-    open_to_closed = dict({'{':'}', '[':']', '(':')'})
+    open_brackets = set({"(", "[", "{"})
+    closed_brackets = set({")", "]", "}"})
+    open_to_closed = dict({"{": "}", "[": "]", "(": ")"})
 
     for i in range(len(S)):
 
@@ -26,7 +28,9 @@ def is_balanced(S):
             stack.append(S[i])
 
         elif S[i] in closed_brackets:
-            if len(stack) == 0 or (len(stack) > 0 and open_to_closed[stack.pop()] != S[i]):
+            if len(stack) == 0 or (
+                len(stack) > 0 and open_to_closed[stack.pop()] != S[i]
+            ):
                 return False
 
     return len(stack) == 0
diff --git a/other/palindrome.py b/other/palindrome.py
index 990ec844f9fb..2ca453b64702 100644
--- a/other/palindrome.py
+++ b/other/palindrome.py
@@ -22,10 +22,10 @@ def recursive_palindrome(str):
 
 
 def main():
-    str = 'ama'
+    str = "ama"
     print(recursive_palindrome(str.lower()))
     print(is_palindrome(str.lower()))
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
diff --git a/other/password_generator.py b/other/password_generator.py
index 16b7e16b22a1..f72686bfb1c0 100644
--- a/other/password_generator.py
+++ b/other/password_generator.py
@@ -17,7 +17,7 @@ def password_generator(length=8):
     0
     """
     chars = tuple(ascii_letters) + tuple(digits) + tuple(punctuation)
-    return ''.join(choice(chars) for x in range(length))
+    return "".join(choice(chars) for x in range(length))
 
 
 # ALTERNATIVE METHODS
@@ -42,11 +42,10 @@ def random_characters(ctbi, i):
 
 
 def main():
-    length = int(
-        input('Please indicate the max length of your password: ').strip())
-    print('Password generated:', password_generator(length))
-    print('[If you are thinking of using this passsword, You better save it.]')
+    length = int(input("Please indicate the max length of your password: ").strip())
+    print("Password generated:", password_generator(length))
+    print("[If you are thinking of using this passsword, You better save it.]")
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
diff --git a/other/primelib.py b/other/primelib.py
index c000213a7a42..6fc5eddeb257 100644
--- a/other/primelib.py
+++ b/other/primelib.py
@@ -49,8 +49,9 @@ def isPrime(number):
     """
 
     # precondition
-    assert isinstance(number,int) and (number >= 0) , \
-    "'number' must been an int and positive"
+    assert isinstance(number, int) and (
+        number >= 0
+    ), "'number' must been an int and positive"
 
     status = True
 
@@ -58,7 +59,7 @@ def isPrime(number):
     if number <= 1:
         status = False
 
-    for divisor in range(2,int(round(sqrt(number)))+1):
+    for divisor in range(2, int(round(sqrt(number))) + 1):
 
         # if 'number' divisible by 'divisor' then sets 'status'
         # of false and break up the loop.
@@ -67,12 +68,14 @@ def isPrime(number):
             break
 
     # precondition
-    assert isinstance(status,bool), "'status' must been from type bool"
+    assert isinstance(status, bool), "'status' must been from type bool"
 
     return status
 
+
 # ------------------------------------------
 
+
 def sieveEr(N):
     """
         input: positive integer 'N' > 2
@@ -84,33 +87,33 @@ def sieveEr(N):
     """
 
     # precondition
-    assert isinstance(N,int) and (N > 2), "'N' must been an int and > 2"
+    assert isinstance(N, int) and (N > 2), "'N' must been an int and > 2"
 
     # beginList: conatins all natural numbers from 2 upt to N
-    beginList = [x for x in range(2,N+1)]
+    beginList = [x for x in range(2, N + 1)]
 
-    ans = [] # this list will be returns.
+    ans = []  # this list will be returns.
 
     # actual sieve of erathostenes
     for i in range(len(beginList)):
 
-        for j in range(i+1,len(beginList)):
+        for j in range(i + 1, len(beginList)):
 
-            if (beginList[i] != 0) and \
-            (beginList[j] % beginList[i] == 0):
+            if (beginList[i] != 0) and (beginList[j] % beginList[i] == 0):
                 beginList[j] = 0
 
     # filters actual prime numbers.
     ans = [x for x in beginList if x != 0]
 
     # precondition
-    assert isinstance(ans,list), "'ans' must been from type list"
+    assert isinstance(ans, list), "'ans' must been from type list"
 
     return ans
 
 
 # --------------------------------
 
+
 def getPrimeNumbers(N):
     """
         input: positive integer 'N' > 2
@@ -119,26 +122,27 @@ def getPrimeNumbers(N):
     """
 
     # precondition
-    assert isinstance(N,int) and (N > 2), "'N' must been an int and > 2"
+    assert isinstance(N, int) and (N > 2), "'N' must been an int and > 2"
 
     ans = []
 
     # iterates over all numbers between 2 up to N+1
     # if a number is prime then appends to list 'ans'
-    for number in range(2,N+1):
+    for number in range(2, N + 1):
 
         if isPrime(number):
 
             ans.append(number)
 
     # precondition
-    assert isinstance(ans,list), "'ans' must been from type list"
+    assert isinstance(ans, list), "'ans' must been from type list"
 
     return ans
 
 
 # -----------------------------------------
 
+
 def primeFactorization(number):
     """
         input: positive integer 'number'
@@ -146,10 +150,9 @@ def primeFactorization(number):
     """
 
     # precondition
-    assert isinstance(number,int) and number >= 0, \
-    "'number' must been an int and >= 0"
+    assert isinstance(number, int) and number >= 0, "'number' must been an int and >= 0"
 
-    ans = [] # this list will be returns of the function.
+    ans = []  # this list will be returns of the function.
 
     # potential prime number factors.
 
@@ -157,7 +160,6 @@ def primeFactorization(number):
 
     quotient = number
 
-
     if number == 0 or number == 1:
 
         ans.append(number)
@@ -165,25 +167,26 @@ def primeFactorization(number):
     # if 'number' not prime then builds the prime factorization of 'number'
     elif not isPrime(number):
 
-        while (quotient != 1):
+        while quotient != 1:
 
             if isPrime(factor) and (quotient % factor == 0):
-                    ans.append(factor)
-                    quotient /= factor
+                ans.append(factor)
+                quotient /= factor
             else:
-                    factor += 1
+                factor += 1
 
     else:
         ans.append(number)
 
     # precondition
-    assert isinstance(ans,list), "'ans' must been from type list"
+    assert isinstance(ans, list), "'ans' must been from type list"
 
     return ans
 
 
 # -----------------------------------------
 
+
 def greatestPrimeFactor(number):
     """
         input: positive integer 'number' >= 0
@@ -191,8 +194,9 @@ def greatestPrimeFactor(number):
     """
 
     # precondition
-    assert isinstance(number,int) and (number >= 0), \
-    "'number' bust been an int and >= 0"
+    assert isinstance(number, int) and (
+        number >= 0
+    ), "'number' bust been an int and >= 0"
 
     ans = 0
 
@@ -202,7 +206,7 @@ def greatestPrimeFactor(number):
     ans = max(primeFactors)
 
     # precondition
-    assert isinstance(ans,int), "'ans' must been from type int"
+    assert isinstance(ans, int), "'ans' must been from type int"
 
     return ans
 
@@ -217,8 +221,9 @@ def smallestPrimeFactor(number):
     """
 
     # precondition
-    assert isinstance(number,int) and (number >= 0), \
-    "'number' bust been an int and >= 0"
+    assert isinstance(number, int) and (
+        number >= 0
+    ), "'number' bust been an int and >= 0"
 
     ans = 0
 
@@ -228,13 +233,14 @@ def smallestPrimeFactor(number):
     ans = min(primeFactors)
 
     # precondition
-    assert isinstance(ans,int), "'ans' must been from type int"
+    assert isinstance(ans, int), "'ans' must been from type int"
 
     return ans
 
 
 # ----------------------
 
+
 def isEven(number):
     """
         input: integer 'number'
@@ -247,8 +253,10 @@ def isEven(number):
 
     return number % 2 == 0
 
+
 # ------------------------
 
+
 def isOdd(number):
     """
         input: integer 'number'
@@ -261,6 +269,7 @@ def isOdd(number):
 
     return number % 2 != 0
 
+
 # ------------------------
 
 
@@ -272,10 +281,11 @@ def goldbach(number):
     """
 
     # precondition
-    assert isinstance(number,int) and (number > 2) and isEven(number), \
-    "'number' must been an int, even and > 2"
+    assert (
+        isinstance(number, int) and (number > 2) and isEven(number)
+    ), "'number' must been an int, even and > 2"
 
-    ans = [] # this list will returned
+    ans = []  # this list will returned
 
     # creates a list of prime numbers between 2 up to 'number'
     primeNumbers = getPrimeNumbers(number)
@@ -288,12 +298,11 @@ def goldbach(number):
     # exit variable. for break up the loops
     loop = True
 
-    while (i < lenPN and loop):
+    while i < lenPN and loop:
 
-        j = i+1
+        j = i + 1
 
-
-        while (j < lenPN and loop):
+        while j < lenPN and loop:
 
             if primeNumbers[i] + primeNumbers[j] == number:
                 loop = False
@@ -305,15 +314,21 @@ def goldbach(number):
         i += 1
 
     # precondition
-    assert isinstance(ans,list) and (len(ans) == 2) and \
-    (ans[0] + ans[1] == number) and isPrime(ans[0]) and isPrime(ans[1]), \
-    "'ans' must contains two primes. And sum of elements must been eq 'number'"
+    assert (
+        isinstance(ans, list)
+        and (len(ans) == 2)
+        and (ans[0] + ans[1] == number)
+        and isPrime(ans[0])
+        and isPrime(ans[1])
+    ), "'ans' must contains two primes. And sum of elements must been eq 'number'"
 
     return ans
 
+
 # ----------------------------------------------
 
-def gcd(number1,number2):
+
+def gcd(number1, number2):
     """
         Greatest common divisor
         input: two positive integer 'number1' and 'number2'
@@ -321,9 +336,12 @@ def gcd(number1,number2):
     """
 
     # precondition
-    assert isinstance(number1,int) and isinstance(number2,int) \
-    and (number1 >= 0) and (number2 >= 0), \
-    "'number1' and 'number2' must been positive integer."
+    assert (
+        isinstance(number1, int)
+        and isinstance(number2, int)
+        and (number1 >= 0)
+        and (number2 >= 0)
+    ), "'number1' and 'number2' must been positive integer."
 
     rest = 0
 
@@ -334,13 +352,16 @@ def gcd(number1,number2):
         number2 = rest
 
     # precondition
-    assert isinstance(number1,int) and (number1 >= 0), \
-    "'number' must been from type int and positive"
+    assert isinstance(number1, int) and (
+        number1 >= 0
+    ), "'number' must been from type int and positive"
 
     return number1
 
+
 # ----------------------------------------------------
 
+
 def kgV(number1, number2):
     """
         Least common multiple
@@ -349,11 +370,14 @@ def kgV(number1, number2):
     """
 
     # precondition
-    assert isinstance(number1,int) and isinstance(number2,int) \
-    and (number1 >= 1) and (number2 >= 1), \
-    "'number1' and 'number2' must been positive integer."
+    assert (
+        isinstance(number1, int)
+        and isinstance(number2, int)
+        and (number1 >= 1)
+        and (number2 >= 1)
+    ), "'number1' and 'number2' must been positive integer."
 
-    ans = 1 # actual answer that will be return.
+    ans = 1  # actual answer that will be return.
 
     # for kgV (x,1)
     if number1 > 1 and number2 > 1:
@@ -366,12 +390,12 @@ def kgV(number1, number2):
 
         primeFac1 = []
         primeFac2 = []
-        ans = max(number1,number2)
+        ans = max(number1, number2)
 
     count1 = 0
     count2 = 0
 
-    done = [] # captured numbers int both 'primeFac1' and 'primeFac2'
+    done = []  # captured numbers int both 'primeFac1' and 'primeFac2'
 
     # iterates through primeFac1
     for n in primeFac1:
@@ -383,7 +407,7 @@ def kgV(number1, number2):
                 count1 = primeFac1.count(n)
                 count2 = primeFac2.count(n)
 
-                for i in range(max(count1,count2)):
+                for i in range(max(count1, count2)):
                     ans *= n
 
             else:
@@ -408,13 +432,16 @@ def kgV(number1, number2):
             done.append(n)
 
     # precondition
-    assert isinstance(ans,int) and (ans >= 0), \
-    "'ans' must been from type int and positive"
+    assert isinstance(ans, int) and (
+        ans >= 0
+    ), "'ans' must been from type int and positive"
 
     return ans
 
+
 # ----------------------------------
 
+
 def getPrime(n):
     """
         Gets the n-th prime number.
@@ -423,16 +450,16 @@ def getPrime(n):
     """
 
     # precondition
-    assert isinstance(n,int) and (n >= 0), "'number' must been a positive int"
+    assert isinstance(n, int) and (n >= 0), "'number' must been a positive int"
 
     index = 0
-    ans = 2 # this variable holds the answer
+    ans = 2  # this variable holds the answer
 
     while index < n:
 
         index += 1
 
-        ans += 1   # counts to the next number
+        ans += 1  # counts to the next number
 
         # if ans not prime then
         # runs to the next prime number.
@@ -440,13 +467,16 @@ def getPrime(n):
             ans += 1
 
     # precondition
-    assert isinstance(ans,int) and isPrime(ans), \
-    "'ans' must been a prime number and from type int"
+    assert isinstance(ans, int) and isPrime(
+        ans
+    ), "'ans' must been a prime number and from type int"
 
     return ans
 
+
 # ---------------------------------------------------
 
+
 def getPrimesBetween(pNumber1, pNumber2):
     """
         input: prime numbers 'pNumber1' and 'pNumber2'
@@ -456,12 +486,13 @@ def getPrimesBetween(pNumber1, pNumber2):
     """
 
     # precondition
-    assert isPrime(pNumber1) and isPrime(pNumber2) and (pNumber1 < pNumber2), \
-    "The arguments must been prime numbers and 'pNumber1' < 'pNumber2'"
+    assert (
+        isPrime(pNumber1) and isPrime(pNumber2) and (pNumber1 < pNumber2)
+    ), "The arguments must been prime numbers and 'pNumber1' < 'pNumber2'"
 
-    number = pNumber1 + 1 # jump to the next number
+    number = pNumber1 + 1  # jump to the next number
 
-    ans = [] # this list will be returns.
+    ans = []  # this list will be returns.
 
     # if number is not prime then
     # fetch the next prime number.
@@ -479,15 +510,17 @@ def getPrimesBetween(pNumber1, pNumber2):
             number += 1
 
     # precondition
-    assert isinstance(ans,list) and ans[0] != pNumber1 \
-    and ans[len(ans)-1] != pNumber2, \
-    "'ans' must been a list without the arguments"
+    assert (
+        isinstance(ans, list) and ans[0] != pNumber1 and ans[len(ans) - 1] != pNumber2
+    ), "'ans' must been a list without the arguments"
 
     # 'ans' contains not 'pNumber1' and 'pNumber2' !
     return ans
 
+
 # ----------------------------------------------------
 
+
 def getDivisors(n):
     """
         input: positive integer 'n' >= 1
@@ -495,20 +528,17 @@ def getDivisors(n):
     """
 
     # precondition
-    assert isinstance(n,int) and (n >= 1), "'n' must been int and >= 1"
+    assert isinstance(n, int) and (n >= 1), "'n' must been int and >= 1"
 
-    ans = [] # will be returned.
+    ans = []  # will be returned.
 
-    for divisor in range(1,n+1):
+    for divisor in range(1, n + 1):
 
         if n % divisor == 0:
             ans.append(divisor)
 
-
-    #precondition
-    assert ans[0] == 1 and ans[len(ans)-1] == n, \
-    "Error in function getDivisiors(...)"
-
+    # precondition
+    assert ans[0] == 1 and ans[len(ans) - 1] == n, "Error in function getDivisiors(...)"
 
     return ans
 
@@ -523,21 +553,26 @@ def isPerfectNumber(number):
     """
 
     # precondition
-    assert isinstance(number,int) and (number > 1), \
-    "'number' must been an int and >= 1"
+    assert isinstance(number, int) and (
+        number > 1
+    ), "'number' must been an int and >= 1"
 
     divisors = getDivisors(number)
 
     # precondition
-    assert isinstance(divisors,list) and(divisors[0] == 1) and  \
-    (divisors[len(divisors)-1] == number), \
-    "Error in help-function getDivisiors(...)"
+    assert (
+        isinstance(divisors, list)
+        and (divisors[0] == 1)
+        and (divisors[len(divisors) - 1] == number)
+    ), "Error in help-function getDivisiors(...)"
 
     # summed all divisors up to 'number' (exclusive), hence [:-1]
     return sum(divisors[:-1]) == number
 
+
 # ------------------------------------------------------------
 
+
 def simplifyFraction(numerator, denominator):
     """
         input: two integer 'numerator' and 'denominator'
@@ -546,22 +581,28 @@ def simplifyFraction(numerator, denominator):
     """
 
     # precondition
-    assert isinstance(numerator, int) and isinstance(denominator,int) \
-    and (denominator != 0), \
-    "The arguments must been from type int and 'denominator' != 0"
+    assert (
+        isinstance(numerator, int)
+        and isinstance(denominator, int)
+        and (denominator != 0)
+    ), "The arguments must been from type int and 'denominator' != 0"
 
     # build the greatest common divisor of numerator and denominator.
     gcdOfFraction = gcd(abs(numerator), abs(denominator))
 
     # precondition
-    assert isinstance(gcdOfFraction, int) and (numerator % gcdOfFraction == 0) \
-    and (denominator % gcdOfFraction == 0), \
-    "Error in function gcd(...,...)"
+    assert (
+        isinstance(gcdOfFraction, int)
+        and (numerator % gcdOfFraction == 0)
+        and (denominator % gcdOfFraction == 0)
+    ), "Error in function gcd(...,...)"
 
     return (numerator // gcdOfFraction, denominator // gcdOfFraction)
 
+
 # -----------------------------------------------------------------
 
+
 def factorial(n):
     """
         input: positive integer 'n'
@@ -569,17 +610,19 @@ def factorial(n):
     """
 
     # precondition
-    assert isinstance(n,int) and (n >= 0), "'n' must been a int and >= 0"
+    assert isinstance(n, int) and (n >= 0), "'n' must been a int and >= 0"
 
-    ans = 1 # this will be return.
+    ans = 1  # this will be return.
 
-    for factor in range(1,n+1):
+    for factor in range(1, n + 1):
         ans *= factor
 
     return ans
 
+
 # -------------------------------------------------------------------
 
+
 def fib(n):
     """
         input: positive integer 'n'
@@ -591,9 +634,9 @@ def fib(n):
 
     tmp = 0
     fib1 = 1
-    ans = 1 # this will be return
+    ans = 1  # this will be return
 
-    for i in range(n-1):
+    for i in range(n - 1):
 
         tmp = ans
         ans += fib1
diff --git a/other/sierpinski_triangle.py b/other/sierpinski_triangle.py
index fc22aad96059..0e6ce43e35d3 100644
--- a/other/sierpinski_triangle.py
+++ b/other/sierpinski_triangle.py
@@ -1,7 +1,7 @@
 #!/usr/bin/python
 # encoding=utf8
 
-'''Author Anurag Kumar | anuragkumarak95@gmail.com | git/anuragkumarak95
+"""Author Anurag Kumar | anuragkumarak95@gmail.com | git/anuragkumarak95
 
 Simple example of Fractal generation using recursive function.
 
@@ -23,46 +23,51 @@
 
 Credits: This code was written by editing the code from http://www.riannetrujillo.com/blog/python-fractal/
 
-'''
+"""
 import turtle
 import sys
-PROGNAME = 'Sierpinski Triangle'
 
-points = [[-175,-125],[0,175],[175,-125]] #size of triangle
+PROGNAME = "Sierpinski Triangle"
 
-def getMid(p1,p2):
-    return ( (p1[0]+p2[0]) / 2, (p1[1] + p2[1]) / 2) #find midpoint
+points = [[-175, -125], [0, 175], [175, -125]]  # size of triangle
 
-def triangle(points,depth):
+
+def getMid(p1, p2):
+    return ((p1[0] + p2[0]) / 2, (p1[1] + p2[1]) / 2)  # find midpoint
+
+
+def triangle(points, depth):
 
     myPen.up()
-    myPen.goto(points[0][0],points[0][1])
+    myPen.goto(points[0][0], points[0][1])
     myPen.down()
-    myPen.goto(points[1][0],points[1][1])
-    myPen.goto(points[2][0],points[2][1])
-    myPen.goto(points[0][0],points[0][1])
-
-    if depth>0:
-        triangle([points[0],
-                        getMid(points[0], points[1]),
-                        getMid(points[0], points[2])],
-                   depth-1)
-        triangle([points[1],
-                        getMid(points[0], points[1]),
-                        getMid(points[1], points[2])],
-                   depth-1)
-        triangle([points[2],
-                         getMid(points[2], points[1]),
-                         getMid(points[0], points[2])],
-                   depth-1)
-
-
-if __name__ == '__main__':
-    if len(sys.argv) !=2: 
-        raise ValueError('right format for using this script: '
-                         '$python fractals.py <int:depth_for_fractal>')
+    myPen.goto(points[1][0], points[1][1])
+    myPen.goto(points[2][0], points[2][1])
+    myPen.goto(points[0][0], points[0][1])
+
+    if depth > 0:
+        triangle(
+            [points[0], getMid(points[0], points[1]), getMid(points[0], points[2])],
+            depth - 1,
+        )
+        triangle(
+            [points[1], getMid(points[0], points[1]), getMid(points[1], points[2])],
+            depth - 1,
+        )
+        triangle(
+            [points[2], getMid(points[2], points[1]), getMid(points[0], points[2])],
+            depth - 1,
+        )
+
+
+if __name__ == "__main__":
+    if len(sys.argv) != 2:
+        raise ValueError(
+            "right format for using this script: "
+            "$python fractals.py <int:depth_for_fractal>"
+        )
     myPen = turtle.Turtle()
     myPen.ht()
     myPen.speed(5)
-    myPen.pencolor('red')
-    triangle(points,int(sys.argv[1]))
+    myPen.pencolor("red")
+    triangle(points, int(sys.argv[1]))
diff --git a/other/tower_of_hanoi.py b/other/tower_of_hanoi.py
index cd6fbf4d88ac..3cc0e40b369f 100644
--- a/other/tower_of_hanoi.py
+++ b/other/tower_of_hanoi.py
@@ -1,5 +1,5 @@
 def moveTower(height, fromPole, toPole, withPole):
-    '''
+    """
     >>> moveTower(3, 'A', 'B', 'C')
     moving disk from A to B
     moving disk from A to C
@@ -8,18 +8,21 @@ def moveTower(height, fromPole, toPole, withPole):
     moving disk from C to A
     moving disk from C to B
     moving disk from A to B
-    '''
+    """
     if height >= 1:
-        moveTower(height-1, fromPole, withPole, toPole)
+        moveTower(height - 1, fromPole, withPole, toPole)
         moveDisk(fromPole, toPole)
-        moveTower(height-1, withPole, toPole, fromPole)
+        moveTower(height - 1, withPole, toPole, fromPole)
+
+
+def moveDisk(fp, tp):
+    print("moving disk from", fp, "to", tp)
 
-def moveDisk(fp,tp):
-    print('moving disk from', fp, 'to', tp)
 
 def main():
-    height = int(input('Height of hanoi: ').strip())
-    moveTower(height, 'A', 'B', 'C')
+    height = int(input("Height of hanoi: ").strip())
+    moveTower(height, "A", "B", "C")
+
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
diff --git a/other/two_sum.py b/other/two_sum.py
index b784da82767a..70d5c5375026 100644
--- a/other/two_sum.py
+++ b/other/two_sum.py
@@ -9,6 +9,8 @@
 Because nums[0] + nums[1] = 2 + 7 = 9,
 return [0, 1].
 """
+
+
 def twoSum(nums, target):
     """
     :type nums: List[int]
@@ -17,11 +19,11 @@ def twoSum(nums, target):
     """
     chk_map = {}
     for index, val in enumerate(nums):
-      compl = target - val
-      if compl in chk_map:
-        indices = [chk_map[compl], index]
-        print(indices)
-        return [indices]
-      else:
-        chk_map[val] = index
+        compl = target - val
+        if compl in chk_map:
+            indices = [chk_map[compl], index]
+            print(indices)
+            return [indices]
+        else:
+            chk_map[val] = index
     return False
diff --git a/other/word_patterns.py b/other/word_patterns.py
index 1364d1277255..16089019704b 100644
--- a/other/word_patterns.py
+++ b/other/word_patterns.py
@@ -1,5 +1,6 @@
 import pprint, time
 
+
 def getWordPattern(word):
     word = word.upper()
     nextNum = 0
@@ -11,14 +12,15 @@ def getWordPattern(word):
             letterNums[letter] = str(nextNum)
             nextNum += 1
         wordPattern.append(letterNums[letter])
-    return '.'.join(wordPattern)
+    return ".".join(wordPattern)
+
 
 def main():
     startTime = time.time()
     allPatterns = {}
 
-    with open('Dictionary.txt') as fo:
-        wordList = fo.read().split('\n')
+    with open("Dictionary.txt") as fo:
+        wordList = fo.read().split("\n")
 
     for word in wordList:
         pattern = getWordPattern(word)
@@ -28,11 +30,12 @@ def main():
         else:
             allPatterns[pattern].append(word)
 
-    with open('Word Patterns.txt', 'w') as fo:
+    with open("Word Patterns.txt", "w") as fo:
         fo.write(pprint.pformat(allPatterns))
 
     totalTime = round(time.time() - startTime, 2)
-    print(('Done! [', totalTime, 'seconds ]'))
+    print(("Done! [", totalTime, "seconds ]"))
+
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
diff --git a/project_euler/problem_01/sol1.py b/project_euler/problem_01/sol1.py
index 76b13b852c87..e81156edaee4 100644
--- a/project_euler/problem_01/sol1.py
+++ b/project_euler/problem_01/sol1.py
@@ -4,6 +4,8 @@
 we get 3,5,6 and 9. The sum of these multiples is 23.
 Find the sum of all the multiples of 3 or 5 below N.
 """
+
+
 def solution(n):
     """Returns the sum of all the multiples of 3 or 5 below n.
 
diff --git a/project_euler/problem_01/sol3.py b/project_euler/problem_01/sol3.py
index 532203ddd95d..c0bcbc06ec83 100644
--- a/project_euler/problem_01/sol3.py
+++ b/project_euler/problem_01/sol3.py
@@ -4,6 +4,8 @@
 we get 3,5,6 and 9. The sum of these multiples is 23.
 Find the sum of all the multiples of 3 or 5 below N.
 """
+
+
 def solution(n):
     """
     This solution is based on the pattern that the successive numbers in the
diff --git a/project_euler/problem_01/sol4.py b/project_euler/problem_01/sol4.py
index 3e6712618870..e01dc977d8cf 100644
--- a/project_euler/problem_01/sol4.py
+++ b/project_euler/problem_01/sol4.py
@@ -4,6 +4,8 @@
 we get 3,5,6 and 9. The sum of these multiples is 23.
 Find the sum of all the multiples of 3 or 5 below N.
 """
+
+
 def solution(n):
     """Returns the sum of all the multiples of 3 or 5 below n.
 
diff --git a/project_euler/problem_01/sol6.py b/project_euler/problem_01/sol6.py
index b9c3db4f8550..c9f94b9f77c8 100644
--- a/project_euler/problem_01/sol6.py
+++ b/project_euler/problem_01/sol6.py
@@ -4,6 +4,8 @@
 we get 3,5,6 and 9. The sum of these multiples is 23.
 Find the sum of all the multiples of 3 or 5 below N.
 """
+
+
 def solution(n):
     """Returns the sum of all the multiples of 3 or 5 below n.
 
diff --git a/project_euler/problem_02/sol1.py b/project_euler/problem_02/sol1.py
index d2ad67e2f424..ec89ddaeb2b5 100644
--- a/project_euler/problem_02/sol1.py
+++ b/project_euler/problem_02/sol1.py
@@ -9,6 +9,8 @@
 n, find the sum of the even-valued terms. e.g. for n=10, we have {2,8}, sum is
 10.
 """
+
+
 def solution(n):
     """Returns the sum of all fibonacci sequence even elements that are lower
     or equals to n.
diff --git a/project_euler/problem_02/sol2.py b/project_euler/problem_02/sol2.py
index 71f51b695e84..bc5040cc6b3b 100644
--- a/project_euler/problem_02/sol2.py
+++ b/project_euler/problem_02/sol2.py
@@ -9,6 +9,8 @@
 n, find the sum of the even-valued terms. e.g. for n=10, we have {2,8}, sum is
 10.
 """
+
+
 def solution(n):
     """Returns the sum of all fibonacci sequence even elements that are lower
     or equals to n.
diff --git a/project_euler/problem_02/sol3.py b/project_euler/problem_02/sol3.py
index c698b8e38ab2..f29f21c287e5 100644
--- a/project_euler/problem_02/sol3.py
+++ b/project_euler/problem_02/sol3.py
@@ -9,6 +9,8 @@
 n, find the sum of the even-valued terms. e.g. for n=10, we have {2,8}, sum is
 10.
 """
+
+
 def solution(n):
     """Returns the sum of all fibonacci sequence even elements that are lower
     or equals to n.
diff --git a/project_euler/problem_04/sol1.py b/project_euler/problem_04/sol1.py
index 51417b146bbf..53fff8bed4d4 100644
--- a/project_euler/problem_04/sol1.py
+++ b/project_euler/problem_04/sol1.py
@@ -6,6 +6,8 @@
 Find the largest palindrome made from the product of two 3-digit numbers which
 is less than N.
 """
+
+
 def solution(n):
     """Returns the largest palindrome made from the product of two 3-digit
     numbers which is less than n.
@@ -31,9 +33,7 @@ def solution(n):
             # if 'number' is a product of two 3-digit numbers
             # then number is the answer otherwise fetch next number.
             while divisor != 99:
-                if (number % divisor == 0) and (
-                    len(str(int(number / divisor))) == 3
-                ):
+                if (number % divisor == 0) and (len(str(int(number / divisor))) == 3):
                     return number
                 divisor -= 1
 
diff --git a/project_euler/problem_04/sol2.py b/project_euler/problem_04/sol2.py
index 8740ee44a4b4..ecc503912c34 100644
--- a/project_euler/problem_04/sol2.py
+++ b/project_euler/problem_04/sol2.py
@@ -6,6 +6,8 @@
 Find the largest palindrome made from the product of two 3-digit numbers which
 is less than N.
 """
+
+
 def solution(n):
     """Returns the largest palindrome made from the product of two 3-digit
     numbers which is less than n.
diff --git a/project_euler/problem_05/sol1.py b/project_euler/problem_05/sol1.py
index 83c387e4ae6e..b3a231f4dcf5 100644
--- a/project_euler/problem_05/sol1.py
+++ b/project_euler/problem_05/sol1.py
@@ -6,6 +6,8 @@
 What is the smallest positive number that is evenly divisible(divisible with no
 remainder) by all of the numbers from 1 to N?
 """
+
+
 def solution(n):
     """Returns the smallest positive number that is evenly divisible(divisible
     with no remainder) by all of the numbers from 1 to n.
diff --git a/project_euler/problem_06/sol1.py b/project_euler/problem_06/sol1.py
index 0a964272e7e8..c69b6c89e35a 100644
--- a/project_euler/problem_06/sol1.py
+++ b/project_euler/problem_06/sol1.py
@@ -14,6 +14,8 @@
 Find the difference between the sum of the squares of the first N natural
 numbers and the square of the sum.
 """
+
+
 def solution(n):
     """Returns the difference between the sum of the squares of the first n
     natural numbers and the square of the sum.
diff --git a/project_euler/problem_06/sol2.py b/project_euler/problem_06/sol2.py
index 45d08d244647..1698a3fb61fd 100644
--- a/project_euler/problem_06/sol2.py
+++ b/project_euler/problem_06/sol2.py
@@ -14,6 +14,8 @@
 Find the difference between the sum of the squares of the first N natural
 numbers and the square of the sum.
 """
+
+
 def solution(n):
     """Returns the difference between the sum of the squares of the first n
     natural numbers and the square of the sum.
diff --git a/project_euler/problem_07/sol2.py b/project_euler/problem_07/sol2.py
index 7d078af32176..5d30e540b3e7 100644
--- a/project_euler/problem_07/sol2.py
+++ b/project_euler/problem_07/sol2.py
@@ -6,6 +6,8 @@
 
 We can see that the 6th prime is 13. What is the Nth prime number?
 """
+
+
 def isprime(number):
     for i in range(2, int(number ** 0.5) + 1):
         if number % i == 0:
diff --git a/project_euler/problem_09/sol2.py b/project_euler/problem_09/sol2.py
index 502f334417c8..de7b12d40c09 100644
--- a/project_euler/problem_09/sol2.py
+++ b/project_euler/problem_09/sol2.py
@@ -7,6 +7,8 @@
 There exists exactly one Pythagorean triplet for which a + b + c = 1000.
 Find the product abc.
 """
+
+
 def solution(n):
     """
      Return the product of a,b,c which are Pythagorean Triplet that satisfies
diff --git a/project_euler/problem_09/sol3.py b/project_euler/problem_09/sol3.py
index bbe7dcf743e7..a6df46a3a66b 100644
--- a/project_euler/problem_09/sol3.py
+++ b/project_euler/problem_09/sol3.py
@@ -10,6 +10,8 @@
 There exists exactly one Pythagorean triplet for which a + b + c = 1000.
 Find the product abc.
 """
+
+
 def solution():
     """
      Returns the product of a,b,c which are Pythagorean Triplet that satisfies
diff --git a/project_euler/problem_11/sol1.py b/project_euler/problem_11/sol1.py
index 1473439ae00d..4e49013c8210 100644
--- a/project_euler/problem_11/sol1.py
+++ b/project_euler/problem_11/sol1.py
@@ -39,12 +39,8 @@ def largest_product(grid):
     # for nxn grid)
     for i in range(nColumns):
         for j in range(nRows - 3):
-            vertProduct = (
-                grid[j][i] * grid[j + 1][i] * grid[j + 2][i] * grid[j + 3][i]
-            )
-            horzProduct = (
-                grid[i][j] * grid[i][j + 1] * grid[i][j + 2] * grid[i][j + 3]
-            )
+            vertProduct = grid[j][i] * grid[j + 1][i] * grid[j + 2][i] * grid[j + 3][i]
+            horzProduct = grid[i][j] * grid[i][j + 1] * grid[i][j + 2] * grid[i][j + 3]
 
             # Left-to-right diagonal (\) product
             if i < nColumns - 3:
@@ -64,9 +60,7 @@ def largest_product(grid):
                     * grid[i - 3][j + 3]
                 )
 
-            maxProduct = max(
-                vertProduct, horzProduct, lrDiagProduct, rlDiagProduct
-            )
+            maxProduct = max(vertProduct, horzProduct, lrDiagProduct, rlDiagProduct)
             if maxProduct > largest:
                 largest = maxProduct
 
diff --git a/project_euler/problem_11/sol2.py b/project_euler/problem_11/sol2.py
index be6c11a378ad..64702e852b0f 100644
--- a/project_euler/problem_11/sol2.py
+++ b/project_euler/problem_11/sol2.py
@@ -57,24 +57,14 @@ def solution():
         # diagonal 1
         for i in range(17):
             for j in range(17):
-                temp = (
-                    l[i][j]
-                    * l[i + 1][j + 1]
-                    * l[i + 2][j + 2]
-                    * l[i + 3][j + 3]
-                )
+                temp = l[i][j] * l[i + 1][j + 1] * l[i + 2][j + 2] * l[i + 3][j + 3]
                 if temp > maximum:
                     maximum = temp
 
         # diagonal 2
         for i in range(17):
             for j in range(3, 20):
-                temp = (
-                    l[i][j]
-                    * l[i + 1][j - 1]
-                    * l[i + 2][j - 2]
-                    * l[i + 3][j - 3]
-                )
+                temp = l[i][j] * l[i + 1][j - 1] * l[i + 2][j - 2] * l[i + 3][j - 3]
                 if temp > maximum:
                     maximum = temp
         return maximum
diff --git a/project_euler/problem_12/sol2.py b/project_euler/problem_12/sol2.py
index 97a4910723ac..5ff0d8349b90 100644
--- a/project_euler/problem_12/sol2.py
+++ b/project_euler/problem_12/sol2.py
@@ -21,15 +21,15 @@
 What is the value of the first triangle number to have over five hundred
 divisors?
 """
+
+
 def triangle_number_generator():
     for n in range(1, 1000000):
         yield n * (n + 1) // 2
 
 
 def count_divisors(n):
-    return sum(
-        [2 for i in range(1, int(n ** 0.5) + 1) if n % i == 0 and i * i != n]
-    )
+    return sum([2 for i in range(1, int(n ** 0.5) + 1) if n % i == 0 and i * i != n])
 
 
 def solution():
@@ -40,9 +40,7 @@ def solution():
     # >>> solution()
     # 76576500
     """
-    return next(
-        i for i in triangle_number_generator() if count_divisors(i) > 500
-    )
+    return next(i for i in triangle_number_generator() if count_divisors(i) > 500)
 
 
 if __name__ == "__main__":
diff --git a/project_euler/problem_14/sol1.py b/project_euler/problem_14/sol1.py
index 156322b7d507..ab09937fb315 100644
--- a/project_euler/problem_14/sol1.py
+++ b/project_euler/problem_14/sol1.py
@@ -16,6 +16,8 @@
 
 Which starting number, under one million, produces the longest chain?
 """
+
+
 def solution(n):
     """Returns the number under n that generates the longest sequence using the
     formula:
@@ -56,11 +58,5 @@ def solution(n):
 if __name__ == "__main__":
     result = solution(int(input().strip()))
     print(
-        (
-            "Largest Number:",
-            result["largest_number"],
-            "->",
-            result["counter"],
-            "digits",
-        )
+        ("Largest Number:", result["largest_number"], "->", result["counter"], "digits")
     )
diff --git a/project_euler/problem_14/sol2.py b/project_euler/problem_14/sol2.py
index 25ebd41571c2..9b8857e710b4 100644
--- a/project_euler/problem_14/sol2.py
+++ b/project_euler/problem_14/sol2.py
@@ -24,6 +24,8 @@
 
 Which starting number, under one million, produces the longest chain?
 """
+
+
 def collatz_sequence(n):
     """Returns the Collatz sequence for n."""
     sequence = [n]
diff --git a/project_euler/problem_15/sol1.py b/project_euler/problem_15/sol1.py
index de58bb436d68..1be7d10ed674 100644
--- a/project_euler/problem_15/sol1.py
+++ b/project_euler/problem_15/sol1.py
@@ -35,9 +35,7 @@ def lattice_paths(n):
     2
 
     """
-    n = (
-        2 * n
-    )  # middle entry of odd rows starting at row 3 is the solution for n = 1,
+    n = 2 * n  # middle entry of odd rows starting at row 3 is the solution for n = 1,
     # 2, 3,...
     k = n / 2
 
diff --git a/project_euler/problem_18/solution.py b/project_euler/problem_18/solution.py
index f9762e8b0176..38593813901e 100644
--- a/project_euler/problem_18/solution.py
+++ b/project_euler/problem_18/solution.py
@@ -39,12 +39,12 @@ def solution():
     1074
     """
     script_dir = os.path.dirname(os.path.realpath(__file__))
-    triangle = os.path.join(script_dir, 'triangle.txt')
+    triangle = os.path.join(script_dir, "triangle.txt")
 
-    with open(triangle, 'r') as f:
+    with open(triangle, "r") as f:
         triangle = f.readlines()
 
-    a = [[int(y) for y in x.rstrip('\r\n').split(' ')] for x in triangle]
+    a = [[int(y) for y in x.rstrip("\r\n").split(" ")] for x in triangle]
 
     for i in range(1, len(a)):
         for j in range(len(a[i])):
diff --git a/project_euler/problem_21/sol1.py b/project_euler/problem_21/sol1.py
index a890e6a98611..49c2db964316 100644
--- a/project_euler/problem_21/sol1.py
+++ b/project_euler/problem_21/sol1.py
@@ -16,6 +16,8 @@
 
 Evaluate the sum of all the amicable numbers under 10000.
 """
+
+
 def sum_of_divisors(n):
     total = 0
     for i in range(1, int(sqrt(n) + 1)):
@@ -44,8 +46,7 @@ def solution(n):
         [
             i
             for i in range(1, n)
-            if sum_of_divisors(sum_of_divisors(i)) == i
-            and sum_of_divisors(i) != i
+            if sum_of_divisors(sum_of_divisors(i)) == i and sum_of_divisors(i) != i
         ]
     )
     return total
diff --git a/project_euler/problem_23/sol1.py b/project_euler/problem_23/sol1.py
index e76be053040f..a72b6123e3ee 100644
--- a/project_euler/problem_23/sol1.py
+++ b/project_euler/problem_23/sol1.py
@@ -18,7 +18,8 @@
 of two abundant numbers.
 """
 
-def solution(limit = 28123):
+
+def solution(limit=28123):
     """
     Finds the sum of all the positive integers which cannot be written as
     the sum of two abundant numbers
@@ -42,7 +43,7 @@ def solution(limit = 28123):
             abundants.add(n)
 
         if not any((n - a in abundants) for a in abundants):
-            res+=n
+            res += n
 
     return res
 
diff --git a/project_euler/problem_234/sol1.py b/project_euler/problem_234/sol1.py
index c0d2949285e9..28d82b550c85 100644
--- a/project_euler/problem_234/sol1.py
+++ b/project_euler/problem_234/sol1.py
@@ -17,18 +17,19 @@
 What is the sum of all semidivisible numbers not exceeding 999966663333 ?
 """
 
+
 def fib(a, b, n):
-    
-    if n==1:
+
+    if n == 1:
         return a
-    elif n==2:
+    elif n == 2:
         return b
-    elif n==3:
-        return str(a)+str(b)
-    
+    elif n == 3:
+        return str(a) + str(b)
+
     temp = 0
-    for x in range(2,n):
-        c=str(a) + str(b)
+    for x in range(2, n):
+        c = str(a) + str(b)
         temp = b
         b = c
         a = temp
@@ -39,14 +40,14 @@ def solution(n):
     """Returns the sum of all semidivisible numbers not exceeding n."""
     semidivisible = []
     for x in range(n):
-        l=[i for i in input().split()]
-        c2=1
-        while(1):
-            if len(fib(l[0],l[1],c2))<int(l[2]):
-                c2+=1
+        l = [i for i in input().split()]
+        c2 = 1
+        while 1:
+            if len(fib(l[0], l[1], c2)) < int(l[2]):
+                c2 += 1
             else:
                 break
-        semidivisible.append(fib(l[0],l[1],c2+1)[int(l[2])-1])
+        semidivisible.append(fib(l[0], l[1], c2 + 1)[int(l[2]) - 1])
     return semidivisible
 
 
diff --git a/project_euler/problem_25/sol1.py b/project_euler/problem_25/sol1.py
index 4371c533ce16..8fce32285976 100644
--- a/project_euler/problem_25/sol1.py
+++ b/project_euler/problem_25/sol1.py
@@ -25,6 +25,7 @@
 digits?
 """
 
+
 def fibonacci(n):
     if n == 1 or type(n) is not int:
         return 0
diff --git a/project_euler/problem_29/solution.py b/project_euler/problem_29/solution.py
index 24d3e20d94fe..4313a7b06392 100644
--- a/project_euler/problem_29/solution.py
+++ b/project_euler/problem_29/solution.py
@@ -14,6 +14,8 @@
 How many distinct terms are in the sequence generated by ab
 for 2 <= a <= 100 and 2 <= b <= 100?
 """
+
+
 def solution(n):
     """Returns the number of distinct terms in the sequence generated by a^b
     for 2 <= a <= 100 and 2 <= b <= 100.
diff --git a/project_euler/problem_31/sol1.py b/project_euler/problem_31/sol1.py
index f7439d346130..187fb9167a13 100644
--- a/project_euler/problem_31/sol1.py
+++ b/project_euler/problem_31/sol1.py
@@ -11,6 +11,8 @@
 1×£1 + 1×50p + 2×20p + 1×5p + 1×2p + 3×1p
 How many different ways can £2 be made using any number of coins?
 """
+
+
 def one_pence():
     return 1
 
diff --git a/project_euler/problem_32/sol32.py b/project_euler/problem_32/sol32.py
index fd5178303de3..0abc04829a9a 100644
--- a/project_euler/problem_32/sol32.py
+++ b/project_euler/problem_32/sol32.py
@@ -28,13 +28,11 @@ def isCombinationValid(combination):
 
     """
     return (
-        int(''.join(combination[0:2])) *
-        int(''.join(combination[2:5])) ==
-        int(''.join(combination[5:9]))
+        int("".join(combination[0:2])) * int("".join(combination[2:5]))
+        == int("".join(combination[5:9]))
     ) or (
-        int(''.join(combination[0])) *
-        int(''.join(combination[1:5])) ==
-        int(''.join(combination[5:9]))
+        int("".join(combination[0])) * int("".join(combination[1:5]))
+        == int("".join(combination[5:9]))
     )
 
 
@@ -50,13 +48,13 @@ def solution():
     return sum(
         set(
             [
-                int(''.join(pandigital[5:9]))
-                for pandigital
-                in itertools.permutations('123456789')
+                int("".join(pandigital[5:9]))
+                for pandigital in itertools.permutations("123456789")
                 if isCombinationValid(pandigital)
             ]
         )
     )
 
+
 if __name__ == "__main__":
     print(solution())
diff --git a/project_euler/problem_36/sol1.py b/project_euler/problem_36/sol1.py
index 7ed74af8fd63..39088cf25dd4 100644
--- a/project_euler/problem_36/sol1.py
+++ b/project_euler/problem_36/sol1.py
@@ -9,6 +9,8 @@
 (Please note that the palindromic number, in either base, may not include
 leading zeros.)
 """
+
+
 def is_palindrome(n):
     n = str(n)
 
diff --git a/project_euler/problem_40/sol1.py b/project_euler/problem_40/sol1.py
index d15376b739db..786725e274b1 100644
--- a/project_euler/problem_40/sol1.py
+++ b/project_euler/problem_40/sol1.py
@@ -14,6 +14,8 @@
 
 d1 × d10 × d100 × d1000 × d10000 × d100000 × d1000000
 """
+
+
 def solution():
     """Returns
 
diff --git a/project_euler/problem_42/solution42.py b/project_euler/problem_42/solution42.py
index ff976545055d..2380472153c6 100644
--- a/project_euler/problem_42/solution42.py
+++ b/project_euler/problem_42/solution42.py
@@ -28,23 +28,21 @@ def solution():
     162
     """
     script_dir = os.path.dirname(os.path.realpath(__file__))
-    wordsFilePath = os.path.join(script_dir, 'words.txt')
+    wordsFilePath = os.path.join(script_dir, "words.txt")
 
-    words = ''
-    with open(wordsFilePath, 'r') as f:
+    words = ""
+    with open(wordsFilePath, "r") as f:
         words = f.readline()
 
-    words = list(map(lambda word: word.strip('"'), words.strip('\r\n').split(',')))
+    words = list(map(lambda word: word.strip('"'), words.strip("\r\n").split(",")))
     words = list(
         filter(
             lambda word: word in TRIANGULAR_NUMBERS,
-            map(
-                lambda word: sum(map(lambda x: ord(x) - 64, word)),
-                words
-            )
+            map(lambda word: sum(map(lambda x: ord(x) - 64, word)), words),
         )
     )
     return len(words)
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
     print(solution())
diff --git a/project_euler/problem_551/sol1.py b/project_euler/problem_551/sol1.py
index 238d7b772190..307d644fbfc9 100644
--- a/project_euler/problem_551/sol1.py
+++ b/project_euler/problem_551/sol1.py
@@ -12,7 +12,7 @@
 Find a(10^15)
 """
 
-ks = [k for k in range(2, 20+1)]
+ks = [k for k in range(2, 20 + 1)]
 base = [10 ** k for k in range(ks[-1] + 1)]
 memo = {}
 
diff --git a/project_euler/problem_56/sol1.py b/project_euler/problem_56/sol1.py
index 194a7a37af43..d5225efcb9e5 100644
--- a/project_euler/problem_56/sol1.py
+++ b/project_euler/problem_56/sol1.py
@@ -1,5 +1,3 @@
-
-
 def maximum_digital_sum(a: int, b: int) -> int:
     """
         Considering natural numbers of the form, a**b, where a, b < 100,
@@ -18,9 +16,17 @@ def maximum_digital_sum(a: int, b: int) -> int:
     """
 
     # RETURN the MAXIMUM from the list of SUMs of the list of INT converted from STR of BASE raised to the POWER
-    return max([sum([int(x) for x in str(base**power)]) for base in range(a) for power in range(b)])
+    return max(
+        [
+            sum([int(x) for x in str(base ** power)])
+            for base in range(a)
+            for power in range(b)
+        ]
+    )
 
-#Tests
+
+# Tests
 if __name__ == "__main__":
     import doctest
+
     doctest.testmod()
diff --git a/project_euler/problem_67/sol1.py b/project_euler/problem_67/sol1.py
index 2da757e303aa..9494ff7bbabd 100644
--- a/project_euler/problem_67/sol1.py
+++ b/project_euler/problem_67/sol1.py
@@ -23,12 +23,12 @@ def solution():
     7273
     """
     script_dir = os.path.dirname(os.path.realpath(__file__))
-    triangle = os.path.join(script_dir, 'triangle.txt')
+    triangle = os.path.join(script_dir, "triangle.txt")
 
-    with open(triangle, 'r') as f:
+    with open(triangle, "r") as f:
         triangle = f.readlines()
 
-    a = map(lambda x: x.rstrip('\r\n').split(' '), triangle)
+    a = map(lambda x: x.rstrip("\r\n").split(" "), triangle)
     a = list(map(lambda x: list(map(lambda y: int(y), x)), a))
 
     for i in range(1, len(a)):
diff --git a/scripts/build_directory_md.py b/scripts/build_directory_md.py
index b39edca6c933..cae38c13dbf4 100755
--- a/scripts/build_directory_md.py
+++ b/scripts/build_directory_md.py
@@ -14,7 +14,7 @@ def good_filepaths(top_dir: str = ".") -> Iterator[str]:
                 continue
             if os.path.splitext(filename)[1] in (".py", ".ipynb"):
                 yield os.path.join(dirpath, filename).lstrip("./")
-                
+
 
 def md_prefix(i):
     return f"{i * '  '}*" if i else "##"
@@ -36,7 +36,9 @@ def print_directory_md(top_dir: str = ".") -> None:
         if filepath != old_path:
             old_path = print_path(old_path, filepath)
         indent = (filepath.count(os.sep) + 1) if filepath else 0
-        url = "/".join((URL_BASE, filepath.split(os.sep)[1], filename)).replace(" ", "%20")
+        url = "/".join((URL_BASE, filepath.split(os.sep)[1], filename)).replace(
+            " ", "%20"
+        )
         filename = os.path.splitext(filename.replace("_", " "))[0]
         print(f"{md_prefix(indent)} [{filename}]({url})")
 
diff --git a/scripts/validate_filenames.py b/scripts/validate_filenames.py
index 9e1f1503321b..51dd6a40cb41 100755
--- a/scripts/validate_filenames.py
+++ b/scripts/validate_filenames.py
@@ -25,4 +25,5 @@
 bad_files = len(upper_files + space_files + nodir_files)
 if bad_files:
     import sys
+
     sys.exit(bad_files)
diff --git a/searches/binary_search.py b/searches/binary_search.py
index 77abf90239ab..9237c0e1f6f5 100644
--- a/searches/binary_search.py
+++ b/searches/binary_search.py
@@ -79,6 +79,7 @@ def binary_search_std_lib(sorted_collection, item):
         return index
     return None
 
+
 def binary_search_by_recursion(sorted_collection, item, left, right):
 
     """Pure implementation of binary search algorithm in Python by recursion
@@ -104,7 +105,7 @@ def binary_search_by_recursion(sorted_collection, item, left, right):
     >>> binary_search_std_lib([0, 5, 7, 10, 15], 6)
 
     """
-    if (right < left):
+    if right < left:
         return None
 
     midpoint = left + (right - left) // 2
@@ -112,9 +113,10 @@ def binary_search_by_recursion(sorted_collection, item, left, right):
     if sorted_collection[midpoint] == item:
         return midpoint
     elif sorted_collection[midpoint] > item:
-        return binary_search_by_recursion(sorted_collection, item, left, midpoint-1)
+        return binary_search_by_recursion(sorted_collection, item, left, midpoint - 1)
     else:
-        return binary_search_by_recursion(sorted_collection, item, midpoint+1, right)
+        return binary_search_by_recursion(sorted_collection, item, midpoint + 1, right)
+
 
 def __assert_sorted(collection):
     """Check if collection is ascending sorted, if not - raises :py:class:`ValueError`
@@ -133,23 +135,24 @@ def __assert_sorted(collection):
     ValueError: Collection must be ascending sorted
     """
     if collection != sorted(collection):
-        raise ValueError('Collection must be ascending sorted')
+        raise ValueError("Collection must be ascending sorted")
     return True
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     import sys
-    user_input = input('Enter numbers separated by comma:\n').strip()
-    collection = [int(item) for item in user_input.split(',')]
+
+    user_input = input("Enter numbers separated by comma:\n").strip()
+    collection = [int(item) for item in user_input.split(",")]
     try:
         __assert_sorted(collection)
     except ValueError:
-        sys.exit('Sequence must be ascending sorted to apply binary search')
+        sys.exit("Sequence must be ascending sorted to apply binary search")
 
-    target_input = input('Enter a single number to be found in the list:\n')
+    target_input = input("Enter a single number to be found in the list:\n")
     target = int(target_input)
     result = binary_search(collection, target)
     if result is not None:
-        print('{} found at positions: {}'.format(target, result))
+        print("{} found at positions: {}".format(target, result))
     else:
-        print('Not found')
+        print("Not found")
diff --git a/searches/interpolation_search.py b/searches/interpolation_search.py
index 27ee979bb649..d1873083bf8a 100644
--- a/searches/interpolation_search.py
+++ b/searches/interpolation_search.py
@@ -15,27 +15,29 @@ def interpolation_search(sorted_collection, item):
     right = len(sorted_collection) - 1
 
     while left <= right:
-        #avoid devided by 0 during interpolation
-        if sorted_collection[left]==sorted_collection[right]:
-            if sorted_collection[left]==item:
+        # avoid devided by 0 during interpolation
+        if sorted_collection[left] == sorted_collection[right]:
+            if sorted_collection[left] == item:
                 return left
             else:
                 return None
 
-        point = left + ((item - sorted_collection[left]) * (right - left)) // (sorted_collection[right] - sorted_collection[left])
+        point = left + ((item - sorted_collection[left]) * (right - left)) // (
+            sorted_collection[right] - sorted_collection[left]
+        )
 
-        #out of range check
-        if point<0 or point>=len(sorted_collection):
+        # out of range check
+        if point < 0 or point >= len(sorted_collection):
             return None
 
         current_item = sorted_collection[point]
         if current_item == item:
             return point
         else:
-            if point<left:
+            if point < left:
                 right = left
                 left = point
-            elif point>right:
+            elif point > right:
                 left = right
                 right = point
             else:
@@ -45,6 +47,7 @@ def interpolation_search(sorted_collection, item):
                     left = point + 1
     return None
 
+
 def interpolation_search_by_recursion(sorted_collection, item, left, right):
 
     """Pure implementation of interpolation search algorithm in Python by recursion
@@ -56,30 +59,37 @@ def interpolation_search_by_recursion(sorted_collection, item, left, right):
     :return: index of found item or None if item is not found
     """
 
-    #avoid devided by 0 during interpolation
-    if sorted_collection[left]==sorted_collection[right]:
-        if sorted_collection[left]==item:
+    # avoid devided by 0 during interpolation
+    if sorted_collection[left] == sorted_collection[right]:
+        if sorted_collection[left] == item:
             return left
         else:
             return None
 
-    point = left + ((item - sorted_collection[left]) * (right - left)) // (sorted_collection[right] - sorted_collection[left])
+    point = left + ((item - sorted_collection[left]) * (right - left)) // (
+        sorted_collection[right] - sorted_collection[left]
+    )
 
-    #out of range check
-    if point<0 or point>=len(sorted_collection):
+    # out of range check
+    if point < 0 or point >= len(sorted_collection):
         return None
 
     if sorted_collection[point] == item:
         return point
-    elif point<left:
+    elif point < left:
         return interpolation_search_by_recursion(sorted_collection, item, point, left)
-    elif point>right:
+    elif point > right:
         return interpolation_search_by_recursion(sorted_collection, item, right, left)
     else:
         if sorted_collection[point] > item:
-            return interpolation_search_by_recursion(sorted_collection, item, left, point-1)
+            return interpolation_search_by_recursion(
+                sorted_collection, item, left, point - 1
+            )
         else:
-            return interpolation_search_by_recursion(sorted_collection, item, point+1, right)
+            return interpolation_search_by_recursion(
+                sorted_collection, item, point + 1, right
+            )
+
 
 def __assert_sorted(collection):
     """Check if collection is ascending sorted, if not - raises :py:class:`ValueError`
@@ -95,11 +105,11 @@ def __assert_sorted(collection):
     ValueError: Collection must be ascending sorted
     """
     if collection != sorted(collection):
-        raise ValueError('Collection must be ascending sorted')
+        raise ValueError("Collection must be ascending sorted")
     return True
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     import sys
 
     """
@@ -116,15 +126,15 @@ def __assert_sorted(collection):
 
     debug = 0
     if debug == 1:
-        collection = [10,30,40,45,50,66,77,93]
+        collection = [10, 30, 40, 45, 50, 66, 77, 93]
         try:
             __assert_sorted(collection)
         except ValueError:
-            sys.exit('Sequence must be ascending sorted to apply interpolation search')
+            sys.exit("Sequence must be ascending sorted to apply interpolation search")
         target = 67
 
     result = interpolation_search(collection, target)
     if result is not None:
-        print('{} found at positions: {}'.format(target, result))
+        print("{} found at positions: {}".format(target, result))
     else:
-        print('Not found')
+        print("Not found")
diff --git a/searches/jump_search.py b/searches/jump_search.py
index 78d9f79dc6a8..e191cf2d4b27 100644
--- a/searches/jump_search.py
+++ b/searches/jump_search.py
@@ -1,9 +1,11 @@
 import math
+
+
 def jump_search(arr, x):
     n = len(arr)
     step = int(math.floor(math.sqrt(n)))
     prev = 0
-    while arr[min(step, n)-1] < x:
+    while arr[min(step, n) - 1] < x:
         prev = step
         step += int(math.floor(math.sqrt(n)))
         if prev >= n:
@@ -18,8 +20,7 @@ def jump_search(arr, x):
     return -1
 
 
-
-arr = [ 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610]
+arr = [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610]
 x = 55
 index = jump_search(arr, x)
-print("\nNumber " + str(x) +" is at index " + str(index));
+print("\nNumber " + str(x) + " is at index " + str(index))
diff --git a/searches/linear_search.py b/searches/linear_search.py
index fb784924132e..ab20f3527bb3 100644
--- a/searches/linear_search.py
+++ b/searches/linear_search.py
@@ -37,14 +37,14 @@ def linear_search(sequence, target):
     return None
 
 
-if __name__ == '__main__':
-    user_input = input('Enter numbers separated by comma:\n').strip()
-    sequence = [int(item) for item in user_input.split(',')]
+if __name__ == "__main__":
+    user_input = input("Enter numbers separated by comma:\n").strip()
+    sequence = [int(item) for item in user_input.split(",")]
 
-    target_input = input('Enter a single number to be found in the list:\n')
+    target_input = input("Enter a single number to be found in the list:\n")
     target = int(target_input)
     result = linear_search(sequence, target)
     if result is not None:
-        print('{} found at positions: {}'.format(target, result))
+        print("{} found at positions: {}".format(target, result))
     else:
-        print('Not found')
+        print("Not found")
diff --git a/searches/quick_select.py b/searches/quick_select.py
index 76d09cb97f97..6b70562bd78f 100644
--- a/searches/quick_select.py
+++ b/searches/quick_select.py
@@ -4,6 +4,8 @@
 A python implementation of the quick select algorithm, which is efficient for calculating the value that would appear in the index of a list if it would be sorted, even if it is not already sorted
 https://en.wikipedia.org/wiki/Quickselect
 """
+
+
 def _partition(data, pivot):
     """
     Three way partition the data into smaller, equal and greater lists,
@@ -21,29 +23,30 @@ def _partition(data, pivot):
         else:
             equal.append(element)
     return less, equal, greater
-    
+
+
 def quickSelect(list, k):
-    #k = len(list) // 2 when trying to find the median (index that value would be when list is sorted)
-    
-    #invalid input
-    if k>=len(list) or k<0:
+    # k = len(list) // 2 when trying to find the median (index that value would be when list is sorted)
+
+    # invalid input
+    if k >= len(list) or k < 0:
         return None
-    
+
     smaller = []
     larger = []
     pivot = random.randint(0, len(list) - 1)
     pivot = list[pivot]
     count = 0
-    smaller, equal, larger =_partition(list, pivot)
+    smaller, equal, larger = _partition(list, pivot)
     count = len(equal)
     m = len(smaller)
 
-    #k is the pivot
+    # k is the pivot
     if m <= k < m + count:
         return pivot
     # must be in smaller
     elif m > k:
         return quickSelect(smaller, k)
-    #must be in larger
+    # must be in larger
     else:
-        return quickSelect(larger, k - (m + count))
\ No newline at end of file
+        return quickSelect(larger, k - (m + count))
diff --git a/searches/sentinel_linear_search.py b/searches/sentinel_linear_search.py
index eb9d32e5f503..6c4da9b21189 100644
--- a/searches/sentinel_linear_search.py
+++ b/searches/sentinel_linear_search.py
@@ -10,6 +10,7 @@
 python sentinel_linear_search.py
 """
 
+
 def sentinel_linear_search(sequence, target):
     """Pure implementation of sentinel linear search algorithm in Python
 
@@ -44,14 +45,14 @@ def sentinel_linear_search(sequence, target):
     return index
 
 
-if __name__ == '__main__':
-    user_input = input('Enter numbers separated by comma:\n').strip()
-    sequence = [int(item) for item in user_input.split(',')]
+if __name__ == "__main__":
+    user_input = input("Enter numbers separated by comma:\n").strip()
+    sequence = [int(item) for item in user_input.split(",")]
 
-    target_input = input('Enter a single number to be found in the list:\n')
+    target_input = input("Enter a single number to be found in the list:\n")
     target = int(target_input)
     result = sentinel_linear_search(sequence, target)
     if result is not None:
-        print('{} found at positions: {}'.format(target, result))
+        print("{} found at positions: {}".format(target, result))
     else:
-        print('Not found')
\ No newline at end of file
+        print("Not found")
diff --git a/searches/tabu_search.py b/searches/tabu_search.py
index ffd84f8ac031..9a1478244503 100644
--- a/searches/tabu_search.py
+++ b/searches/tabu_search.py
@@ -55,13 +55,17 @@ def generate_neighbours(path):
                 _list.append([line.split()[1], line.split()[2]])
                 dict_of_neighbours[line.split()[0]] = _list
             else:
-                dict_of_neighbours[line.split()[0]].append([line.split()[1], line.split()[2]])
+                dict_of_neighbours[line.split()[0]].append(
+                    [line.split()[1], line.split()[2]]
+                )
             if line.split()[1] not in dict_of_neighbours:
                 _list = list()
                 _list.append([line.split()[0], line.split()[2]])
                 dict_of_neighbours[line.split()[1]] = _list
             else:
-                dict_of_neighbours[line.split()[1]].append([line.split()[0], line.split()[2]])
+                dict_of_neighbours[line.split()[1]].append(
+                    [line.split()[0], line.split()[2]]
+                )
 
     return dict_of_neighbours
 
@@ -111,8 +115,11 @@ def generate_first_solution(path, dict_of_neighbours):
             break
         position += 1
 
-    distance_of_first_solution = distance_of_first_solution + int(
-        dict_of_neighbours[first_solution[-2]][position][1]) - 10000
+    distance_of_first_solution = (
+        distance_of_first_solution
+        + int(dict_of_neighbours[first_solution[-2]][position][1])
+        - 10000
+    )
     return first_solution, distance_of_first_solution
 
 
@@ -167,7 +174,9 @@ def find_neighborhood(solution, dict_of_neighbours):
     return neighborhood_of_solution
 
 
-def tabu_search(first_solution, distance_of_first_solution, dict_of_neighbours, iters, size):
+def tabu_search(
+    first_solution, distance_of_first_solution, dict_of_neighbours, iters, size
+):
     """
     Pure implementation of Tabu search algorithm for a Travelling Salesman Problem in Python.
 
@@ -207,8 +216,10 @@ def tabu_search(first_solution, distance_of_first_solution, dict_of_neighbours,
                     break
                 i = i + 1
 
-            if [first_exchange_node, second_exchange_node] not in tabu_list and [second_exchange_node,
-                                                                                 first_exchange_node] not in tabu_list:
+            if [first_exchange_node, second_exchange_node] not in tabu_list and [
+                second_exchange_node,
+                first_exchange_node,
+            ] not in tabu_list:
                 tabu_list.append([first_exchange_node, second_exchange_node])
                 found = True
                 solution = best_solution[:-1]
@@ -231,10 +242,17 @@ def tabu_search(first_solution, distance_of_first_solution, dict_of_neighbours,
 def main(args=None):
     dict_of_neighbours = generate_neighbours(args.File)
 
-    first_solution, distance_of_first_solution = generate_first_solution(args.File, dict_of_neighbours)
+    first_solution, distance_of_first_solution = generate_first_solution(
+        args.File, dict_of_neighbours
+    )
 
-    best_sol, best_cost = tabu_search(first_solution, distance_of_first_solution, dict_of_neighbours, args.Iterations,
-                                      args.Size)
+    best_sol, best_cost = tabu_search(
+        first_solution,
+        distance_of_first_solution,
+        dict_of_neighbours,
+        args.Iterations,
+        args.Size,
+    )
 
     print("Best solution: {0}, with total distance: {1}.".format(best_sol, best_cost))
 
@@ -242,11 +260,22 @@ def main(args=None):
 if __name__ == "__main__":
     parser = argparse.ArgumentParser(description="Tabu Search")
     parser.add_argument(
-        "-f", "--File", type=str, help="Path to the file containing the data", required=True)
+        "-f",
+        "--File",
+        type=str,
+        help="Path to the file containing the data",
+        required=True,
+    )
     parser.add_argument(
-        "-i", "--Iterations", type=int, help="How many iterations the algorithm should perform", required=True)
+        "-i",
+        "--Iterations",
+        type=int,
+        help="How many iterations the algorithm should perform",
+        required=True,
+    )
     parser.add_argument(
-        "-s", "--Size", type=int, help="Size of the tabu list", required=True)
+        "-s", "--Size", type=int, help="Size of the tabu list", required=True
+    )
 
     # Pass the arguments to main method
     sys.exit(main(parser.parse_args()))
diff --git a/searches/ternary_search.py b/searches/ternary_search.py
index 41033f33cec6..43407b7e5538 100644
--- a/searches/ternary_search.py
+++ b/searches/ternary_search.py
@@ -1,11 +1,11 @@
-'''
+"""
 This is a type of divide and conquer algorithm which divides the search space into
 3 parts and finds the target value based on the property of the array or list
 (usually monotonic property).
 
 Time Complexity  : O(log3 N)
 Space Complexity : O(1)
-'''
+"""
 import sys
 
 # This is the precision for this function which can be altered.
@@ -14,87 +14,90 @@
 
 # This is the linear search that will occur after the search space has become smaller.
 def lin_search(left, right, A, target):
-    for i in range(left, right+1):
-        if(A[i] == target):
+    for i in range(left, right + 1):
+        if A[i] == target:
             return i
 
+
 # This is the iterative method of the ternary search algorithm.
 def ite_ternary_search(A, target):
     left = 0
-    right = len(A) - 1;
-    while(True):
-        if(left<right):
+    right = len(A) - 1
+    while True:
+        if left < right:
 
-            if(right-left < precision):
-                return lin_search(left,right,A,target)
+            if right - left < precision:
+                return lin_search(left, right, A, target)
 
-            oneThird = (left+right)/3+1;
-            twoThird = 2*(left+right)/3+1;
+            oneThird = (left + right) / 3 + 1
+            twoThird = 2 * (left + right) / 3 + 1
 
-            if(A[oneThird] == target):
+            if A[oneThird] == target:
                 return oneThird
-            elif(A[twoThird] == target):
+            elif A[twoThird] == target:
                 return twoThird
 
-            elif(target < A[oneThird]):
-                right = oneThird-1
-            elif(A[twoThird] < target):
-                left = twoThird+1
+            elif target < A[oneThird]:
+                right = oneThird - 1
+            elif A[twoThird] < target:
+                left = twoThird + 1
 
             else:
-                left = oneThird+1
-                right = twoThird-1
+                left = oneThird + 1
+                right = twoThird - 1
         else:
             return None
 
+
 # This is the recursive method of the ternary search algorithm.
 def rec_ternary_search(left, right, A, target):
-    if(left<right):
+    if left < right:
 
-        if(right-left < precision):
-            return lin_search(left,right,A,target)
+        if right - left < precision:
+            return lin_search(left, right, A, target)
 
-        oneThird = (left+right)/3+1;
-        twoThird = 2*(left+right)/3+1;
+        oneThird = (left + right) / 3 + 1
+        twoThird = 2 * (left + right) / 3 + 1
 
-        if(A[oneThird] == target):
+        if A[oneThird] == target:
             return oneThird
-        elif(A[twoThird] == target):
+        elif A[twoThird] == target:
             return twoThird
 
-        elif(target < A[oneThird]):
-            return rec_ternary_search(left, oneThird-1, A, target)
-        elif(A[twoThird] < target):
-            return rec_ternary_search(twoThird+1, right, A, target)
+        elif target < A[oneThird]:
+            return rec_ternary_search(left, oneThird - 1, A, target)
+        elif A[twoThird] < target:
+            return rec_ternary_search(twoThird + 1, right, A, target)
 
         else:
-            return rec_ternary_search(oneThird+1, twoThird-1, A, target)
+            return rec_ternary_search(oneThird + 1, twoThird - 1, A, target)
     else:
         return None
 
+
 # This function is to check if the array is sorted.
 def __assert_sorted(collection):
     if collection != sorted(collection):
-        raise ValueError('Collection must be sorted')
+        raise ValueError("Collection must be sorted")
     return True
 
 
-if __name__ == '__main__':
-    user_input = input('Enter numbers separated by coma:\n').strip()
-    collection = [int(item) for item in user_input.split(',')]
+if __name__ == "__main__":
+    user_input = input("Enter numbers separated by coma:\n").strip()
+    collection = [int(item) for item in user_input.split(",")]
 
     try:
         __assert_sorted(collection)
     except ValueError:
-        sys.exit('Sequence must be sorted to apply the ternary search')
+        sys.exit("Sequence must be sorted to apply the ternary search")
 
-    target_input = input('Enter a single number to be found in the list:\n')
+    target_input = input("Enter a single number to be found in the list:\n")
     target = int(target_input)
     result1 = ite_ternary_search(collection, target)
-    result2 = rec_ternary_search(0, len(collection)-1, collection, target)
+    result2 = rec_ternary_search(0, len(collection) - 1, collection, target)
 
     if result2 is not None:
-        print('Iterative search: {} found at positions: {}'.format(target, result1))
-        print('Recursive search: {} found at positions: {}'.format(target, result2))
+        print("Iterative search: {} found at positions: {}".format(target, result1))
+        print("Recursive search: {} found at positions: {}".format(target, result2))
     else:
-        print('Not found')
+        print("Not found")
diff --git a/sorts/bitonic_sort.py b/sorts/bitonic_sort.py
index ba40a1f698ee..8780bb3259c5 100644
--- a/sorts/bitonic_sort.py
+++ b/sorts/bitonic_sort.py
@@ -1,9 +1,9 @@
-# Python program for Bitonic Sort. Note that this program 
-# works only when size of input is a power of 2. 
+# Python program for Bitonic Sort. Note that this program
+# works only when size of input is a power of 2.
 
-# The parameter dir indicates the sorting direction, ASCENDING 
-# or DESCENDING; if (a[i] > a[j]) agrees with the direction, 
-# then a[i] and a[j] are interchanged.*/ 
+# The parameter dir indicates the sorting direction, ASCENDING
+# or DESCENDING; if (a[i] > a[j]) agrees with the direction,
+# then a[i] and a[j] are interchanged.*/
 def compAndSwap(a, i, j, dire):
     if (dire == 1 and a[i] > a[j]) or (dire == 0 and a[i] < a[j]):
         a[i], a[j] = a[j], a[i]
@@ -12,8 +12,8 @@ def compAndSwap(a, i, j, dire):
 
 
 # if dir = 1, and in descending order otherwise (means dir=0).
-# The sequence to be sorted starts at index position low, 
-# the parameter cnt is the number of elements to be sorted. 
+# The sequence to be sorted starts at index position low,
+# the parameter cnt is the number of elements to be sorted.
 def bitonicMerge(a, low, cnt, dire):
     if cnt > 1:
         k = int(cnt / 2)
@@ -26,7 +26,7 @@ def bitonicMerge(a, low, cnt, dire):
 
 
 # sorting its two halves in opposite sorting orders, and then
-# calls bitonicMerge to make them in the same order 
+# calls bitonicMerge to make them in the same order
 def bitonicSort(a, low, cnt, dire):
     if cnt > 1:
         k = int(cnt / 2)
diff --git a/sorts/bogo_sort.py b/sorts/bogo_sort.py
index a3b2cbc1aa29..0afa444e5b8e 100644
--- a/sorts/bogo_sort.py
+++ b/sorts/bogo_sort.py
@@ -37,7 +37,8 @@ def isSorted(collection):
         random.shuffle(collection)
     return collection
 
-if __name__ == '__main__':
-    user_input = input('Enter numbers separated by a comma:\n').strip()
-    unsorted = [int(item) for item in user_input.split(',')]
+
+if __name__ == "__main__":
+    user_input = input("Enter numbers separated by a comma:\n").strip()
+    unsorted = [int(item) for item in user_input.split(",")]
     print(bogo_sort(unsorted))
diff --git a/sorts/bubble_sort.py b/sorts/bubble_sort.py
index c41a51ea3cbf..ccd8a2e11ee1 100644
--- a/sorts/bubble_sort.py
+++ b/sorts/bubble_sort.py
@@ -22,18 +22,18 @@ def bubble_sort(collection):
     True
     """
     length = len(collection)
-    for i in range(length-1):
+    for i in range(length - 1):
         swapped = False
-        for j in range(length-1-i):
-            if collection[j] > collection[j+1]:
+        for j in range(length - 1 - i):
+            if collection[j] > collection[j + 1]:
                 swapped = True
-                collection[j], collection[j+1] = collection[j+1], collection[j]
+                collection[j], collection[j + 1] = collection[j + 1], collection[j]
         if not swapped:
             break  # Stop iteration if the collection is sorted.
     return collection
 
 
-if __name__ == '__main__':
-    user_input = input('Enter numbers separated by a comma:').strip()
-    unsorted = [int(item) for item in user_input.split(',')]
-    print(*bubble_sort(unsorted), sep=',')
+if __name__ == "__main__":
+    user_input = input("Enter numbers separated by a comma:").strip()
+    unsorted = [int(item) for item in user_input.split(",")]
+    print(*bubble_sort(unsorted), sep=",")
diff --git a/sorts/bucket_sort.py b/sorts/bucket_sort.py
index 0678b1194657..217ee5893c4b 100644
--- a/sorts/bucket_sort.py
+++ b/sorts/bucket_sort.py
@@ -17,8 +17,8 @@
 # number of buckets.
 
 #  Time Complexity of Solution:
-#  Worst case scenario occurs when all the elements are placed in a single bucket. The overall performance 
-#  would then be dominated by the algorithm used to sort each bucket. In this case, O(n log n), because of TimSort 
+#  Worst case scenario occurs when all the elements are placed in a single bucket. The overall performance
+#  would then be dominated by the algorithm used to sort each bucket. In this case, O(n log n), because of TimSort
 #
 #  Average Case O(n + (n^2)/k + k), where k is the number of buckets
 #
@@ -32,18 +32,18 @@ def bucket_sort(my_list, bucket_size=DEFAULT_BUCKET_SIZE):
         raise Exception("Please add some elements in the array.")
 
     min_value, max_value = (min(my_list), max(my_list))
-    bucket_count = ((max_value - min_value) // bucket_size + 1)
+    bucket_count = (max_value - min_value) // bucket_size + 1
     buckets = [[] for _ in range(int(bucket_count))]
 
     for i in range(len(my_list)):
-        buckets[int((my_list[i] - min_value) // bucket_size)
-                ].append(my_list[i])
+        buckets[int((my_list[i] - min_value) // bucket_size)].append(my_list[i])
 
-    return sorted([buckets[i][j] for i in range(len(buckets))
-                   for j in range(len(buckets[i]))])
+    return sorted(
+        [buckets[i][j] for i in range(len(buckets)) for j in range(len(buckets[i]))]
+    )
 
 
 if __name__ == "__main__":
-    user_input = input('Enter numbers separated by a comma:').strip()
-    unsorted = [float(n) for n in user_input.split(',') if len(user_input) > 0]
+    user_input = input("Enter numbers separated by a comma:").strip()
+    unsorted = [float(n) for n in user_input.split(",") if len(user_input) > 0]
     print(bucket_sort(unsorted))
diff --git a/sorts/cocktail_shaker_sort.py b/sorts/cocktail_shaker_sort.py
index d486e6a11dfa..ab624421a3d6 100644
--- a/sorts/cocktail_shaker_sort.py
+++ b/sorts/cocktail_shaker_sort.py
@@ -2,24 +2,25 @@ def cocktail_shaker_sort(unsorted):
     """
     Pure implementation of the cocktail shaker sort algorithm in Python.
     """
-    for i in range(len(unsorted)-1, 0, -1):
+    for i in range(len(unsorted) - 1, 0, -1):
         swapped = False
 
         for j in range(i, 0, -1):
-            if unsorted[j] < unsorted[j-1]:
-                unsorted[j], unsorted[j-1] = unsorted[j-1], unsorted[j]
+            if unsorted[j] < unsorted[j - 1]:
+                unsorted[j], unsorted[j - 1] = unsorted[j - 1], unsorted[j]
                 swapped = True
 
         for j in range(i):
-            if unsorted[j] > unsorted[j+1]:
-                unsorted[j], unsorted[j+1] = unsorted[j+1], unsorted[j]
+            if unsorted[j] > unsorted[j + 1]:
+                unsorted[j], unsorted[j + 1] = unsorted[j + 1], unsorted[j]
                 swapped = True
 
         if not swapped:
             return unsorted
 
-if __name__ == '__main__':
-    user_input = input('Enter numbers separated by a comma:\n').strip()
-    unsorted = [int(item) for item in user_input.split(',')]
+
+if __name__ == "__main__":
+    user_input = input("Enter numbers separated by a comma:\n").strip()
+    unsorted = [int(item) for item in user_input.split(",")]
     cocktail_shaker_sort(unsorted)
     print(unsorted)
diff --git a/sorts/comb_sort.py b/sorts/comb_sort.py
index 6ce6c1c094f9..3c4c57483e3f 100644
--- a/sorts/comb_sort.py
+++ b/sorts/comb_sort.py
@@ -12,6 +12,7 @@
 python comb_sort.py
 """
 
+
 def comb_sort(data):
     """Pure implementation of comb sort algorithm in Python
     :param collection: some mutable ordered collection with heterogeneous
@@ -38,16 +39,16 @@ def comb_sort(data):
         i = 0
 
         while gap + i < len(data):
-            if data[i] > data[i+gap]:
+            if data[i] > data[i + gap]:
                 # Swap values
-                data[i], data[i+gap] = data[i+gap], data[i]
+                data[i], data[i + gap] = data[i + gap], data[i]
                 swapped = True
             i += 1
 
     return data
 
 
-if __name__ == '__main__':
-    user_input = input('Enter numbers separated by a comma:\n').strip()
-    unsorted = [int(item) for item in user_input.split(',')]
+if __name__ == "__main__":
+    user_input = input("Enter numbers separated by a comma:\n").strip()
+    unsorted = [int(item) for item in user_input.split(",")]
     print(comb_sort(unsorted))
diff --git a/sorts/counting_sort.py b/sorts/counting_sort.py
index a3de1811849e..b672d4af47cb 100644
--- a/sorts/counting_sort.py
+++ b/sorts/counting_sort.py
@@ -42,7 +42,7 @@ def counting_sort(collection):
     # sum each position with it's predecessors. now, counting_arr[i] tells
     # us how many elements <= i has in the collection
     for i in range(1, counting_arr_length):
-        counting_arr[i] = counting_arr[i] + counting_arr[i-1]
+        counting_arr[i] = counting_arr[i] + counting_arr[i - 1]
 
     # create the output collection
     ordered = [0] * coll_len
@@ -50,23 +50,24 @@ def counting_sort(collection):
     # place the elements in the output, respecting the original order (stable
     # sort) from end to begin, updating counting_arr
     for i in reversed(range(0, coll_len)):
-        ordered[counting_arr[collection[i] - coll_min]-1] = collection[i]
+        ordered[counting_arr[collection[i] - coll_min] - 1] = collection[i]
         counting_arr[collection[i] - coll_min] -= 1
 
     return ordered
 
+
 def counting_sort_string(string):
     """
     >>> counting_sort_string("thisisthestring")
     'eghhiiinrsssttt'
     """
-    return ''.join([chr(i) for i in counting_sort([ord(c) for c in string])])
+    return "".join([chr(i) for i in counting_sort([ord(c) for c in string])])
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     # Test string sort
     assert "eghhiiinrsssttt" == counting_sort_string("thisisthestring")
 
-    user_input = input('Enter numbers separated by a comma:\n').strip()
-    unsorted = [int(item) for item in user_input.split(',')]
+    user_input = input("Enter numbers separated by a comma:\n").strip()
+    unsorted = [int(item) for item in user_input.split(",")]
     print(counting_sort(unsorted))
diff --git a/sorts/cycle_sort.py b/sorts/cycle_sort.py
index 06a377cbd906..4ce6a2a0e757 100644
--- a/sorts/cycle_sort.py
+++ b/sorts/cycle_sort.py
@@ -41,12 +41,12 @@ def cycle_sort(array):
 
 
 #  Main Code starts here
-if __name__ == '__main__':
-    user_input = input('Enter numbers separated by a comma:\n')
-    unsorted = [int(item) for item in user_input.split(',')]
+if __name__ == "__main__":
+    user_input = input("Enter numbers separated by a comma:\n")
+    unsorted = [int(item) for item in user_input.split(",")]
     n = len(unsorted)
     cycle_sort(unsorted)
 
     print("After sort : ")
     for i in range(0, n):
-        print(unsorted[i], end=' ')
+        print(unsorted[i], end=" ")
diff --git a/sorts/external_sort.py b/sorts/external_sort.py
index 1638e9efafee..abdcb29f95b2 100644
--- a/sorts/external_sort.py
+++ b/sorts/external_sort.py
@@ -6,8 +6,9 @@
 import os
 import argparse
 
+
 class FileSplitter(object):
-    BLOCK_FILENAME_FORMAT = 'block_{0}.dat'
+    BLOCK_FILENAME_FORMAT = "block_{0}.dat"
 
     def __init__(self, filename):
         self.filename = filename
@@ -15,7 +16,7 @@ def __init__(self, filename):
 
     def write_block(self, data, block_number):
         filename = self.BLOCK_FILENAME_FORMAT.format(block_number)
-        with open(filename, 'w') as file:
+        with open(filename, "w") as file:
             file.write(data)
         self.block_filenames.append(filename)
 
@@ -36,7 +37,7 @@ def split(self, block_size, sort_key=None):
                 else:
                     lines.sort(key=sort_key)
 
-                self.write_block(''.join(lines), i)
+                self.write_block("".join(lines), i)
                 i += 1
 
     def cleanup(self):
@@ -63,14 +64,16 @@ def __init__(self, files):
         self.buffers = {i: None for i in range(self.num_buffers)}
 
     def get_dict(self):
-        return {i: self.buffers[i] for i in range(self.num_buffers) if i not in self.empty}
+        return {
+            i: self.buffers[i] for i in range(self.num_buffers) if i not in self.empty
+        }
 
     def refresh(self):
         for i in range(self.num_buffers):
             if self.buffers[i] is None and i not in self.empty:
                 self.buffers[i] = self.files[i].readline()
 
-                if self.buffers[i] == '':
+                if self.buffers[i] == "":
                     self.empty.add(i)
                     self.files[i].close()
 
@@ -92,7 +95,7 @@ def __init__(self, merge_strategy):
 
     def merge(self, filenames, outfilename, buffer_size):
         buffers = FilesArray(self.get_file_handles(filenames, buffer_size))
-        with open(outfilename, 'w', buffer_size) as outfile:
+        with open(outfilename, "w", buffer_size) as outfile:
             while buffers.refresh():
                 min_index = self.merge_strategy.select(buffers.get_dict())
                 outfile.write(buffers.unshift(min_index))
@@ -101,12 +104,11 @@ def get_file_handles(self, filenames, buffer_size):
         files = {}
 
         for i in range(len(filenames)):
-            files[i] = open(filenames[i], 'r', buffer_size)
+            files[i] = open(filenames[i], "r", buffer_size)
 
         return files
 
 
-
 class ExternalSort(object):
     def __init__(self, block_size):
         self.block_size = block_size
@@ -118,7 +120,7 @@ def sort(self, filename, sort_key=None):
 
         merger = FileMerger(NWayMerge())
         buffer_size = self.block_size / (num_blocks + 1)
-        merger.merge(splitter.get_block_filenames(), filename + '.out', buffer_size)
+        merger.merge(splitter.get_block_filenames(), filename + ".out", buffer_size)
 
         splitter.cleanup()
 
@@ -127,32 +129,29 @@ def get_number_blocks(self, filename, block_size):
 
 
 def parse_memory(string):
-    if string[-1].lower() == 'k':
+    if string[-1].lower() == "k":
         return int(string[:-1]) * 1024
-    elif string[-1].lower() == 'm':
+    elif string[-1].lower() == "m":
         return int(string[:-1]) * 1024 * 1024
-    elif string[-1].lower() == 'g':
+    elif string[-1].lower() == "g":
         return int(string[:-1]) * 1024 * 1024 * 1024
     else:
         return int(string)
 
 
-
 def main():
     parser = argparse.ArgumentParser()
-    parser.add_argument('-m',
-                        '--mem',
-                        help='amount of memory to use for sorting',
-                        default='100M')
-    parser.add_argument('filename',
-                        metavar='<filename>',
-                        nargs=1,
-                        help='name of file to sort')
+    parser.add_argument(
+        "-m", "--mem", help="amount of memory to use for sorting", default="100M"
+    )
+    parser.add_argument(
+        "filename", metavar="<filename>", nargs=1, help="name of file to sort"
+    )
     args = parser.parse_args()
 
     sorter = ExternalSort(parse_memory(args.mem))
     sorter.sort(args.filename[0])
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
diff --git a/sorts/gnome_sort.py b/sorts/gnome_sort.py
index fed70eb6bc1b..58a44c94da43 100644
--- a/sorts/gnome_sort.py
+++ b/sorts/gnome_sort.py
@@ -14,12 +14,12 @@ def gnome_sort(unsorted):
         else:
             unsorted[i - 1], unsorted[i] = unsorted[i], unsorted[i - 1]
             i -= 1
-            if (i == 0):
+            if i == 0:
                 i = 1
 
 
-if __name__ == '__main__':
-    user_input = input('Enter numbers separated by a comma:\n').strip()
-    unsorted = [int(item) for item in user_input.split(',')]
+if __name__ == "__main__":
+    user_input = input("Enter numbers separated by a comma:\n").strip()
+    unsorted = [int(item) for item in user_input.split(",")]
     gnome_sort(unsorted)
     print(unsorted)
diff --git a/sorts/heap_sort.py b/sorts/heap_sort.py
index ca4a061afbb7..a39ae2b88da2 100644
--- a/sorts/heap_sort.py
+++ b/sorts/heap_sort.py
@@ -1,4 +1,4 @@
-'''
+"""
 This is a pure python implementation of the heap sort algorithm.
 
 For doctests run following command:
@@ -8,7 +8,8 @@
 
 For manual testing run:
 python heap_sort.py
-'''
+"""
+
 
 def heapify(unsorted, index, heap_size):
     largest = index
@@ -26,7 +27,7 @@ def heapify(unsorted, index, heap_size):
 
 
 def heap_sort(unsorted):
-    '''
+    """
     Pure implementation of the heap sort algorithm in Python
     :param collection: some mutable ordered collection with heterogeneous
     comparable items inside
@@ -41,7 +42,7 @@ def heap_sort(unsorted):
 
     >>> heap_sort([-2, -5, -45])
     [-45, -5, -2]
-    '''
+    """
     n = len(unsorted)
     for i in range(n // 2 - 1, -1, -1):
         heapify(unsorted, i, n)
@@ -50,7 +51,8 @@ def heap_sort(unsorted):
         heapify(unsorted, 0, i)
     return unsorted
 
-if __name__ == '__main__':
-    user_input = input('Enter numbers separated by a comma:\n').strip()
-    unsorted = [int(item) for item in user_input.split(',')]
+
+if __name__ == "__main__":
+    user_input = input("Enter numbers separated by a comma:\n").strip()
+    unsorted = [int(item) for item in user_input.split(",")]
     print(heap_sort(unsorted))
diff --git a/sorts/insertion_sort.py b/sorts/insertion_sort.py
index e10497b0e282..b767018c3d57 100644
--- a/sorts/insertion_sort.py
+++ b/sorts/insertion_sort.py
@@ -9,6 +9,8 @@
 For manual testing run:
 python insertion_sort.py
 """
+
+
 def insertion_sort(collection):
     """Pure implementation of the insertion sort algorithm in Python
 
@@ -29,14 +31,20 @@ def insertion_sort(collection):
 
     for loop_index in range(1, len(collection)):
         insertion_index = loop_index
-        while insertion_index > 0 and collection[insertion_index - 1] > collection[insertion_index]:
-            collection[insertion_index], collection[insertion_index - 1] = collection[insertion_index - 1], collection[insertion_index]
+        while (
+            insertion_index > 0
+            and collection[insertion_index - 1] > collection[insertion_index]
+        ):
+            collection[insertion_index], collection[insertion_index - 1] = (
+                collection[insertion_index - 1],
+                collection[insertion_index],
+            )
             insertion_index -= 1
 
     return collection
 
 
-if __name__ == '__main__':
-    user_input = input('Enter numbers separated by a comma:\n').strip()
-    unsorted = [int(item) for item in user_input.split(',')]
+if __name__ == "__main__":
+    user_input = input("Enter numbers separated by a comma:\n").strip()
+    unsorted = [int(item) for item in user_input.split(",")]
     print(insertion_sort(unsorted))
diff --git a/sorts/merge_sort.py b/sorts/merge_sort.py
index e64e90785a32..13f1144d4ad3 100644
--- a/sorts/merge_sort.py
+++ b/sorts/merge_sort.py
@@ -9,6 +9,8 @@
 For manual testing run:
 python merge_sort.py
 """
+
+
 def merge_sort(collection):
     """Pure implementation of the merge sort algorithm in Python
 
@@ -26,23 +28,25 @@ def merge_sort(collection):
     >>> merge_sort([-2, -5, -45])
     [-45, -5, -2]
     """
+
     def merge(left, right):
-        '''merge left and right
+        """merge left and right
         :param left: left collection
         :param right: right collection
         :return: merge result
-        '''
+        """
         result = []
         while left and right:
             result.append((left if left[0] <= right[0] else right).pop(0))
         return result + left + right
+
     if len(collection) <= 1:
         return collection
     mid = len(collection) // 2
     return merge(merge_sort(collection[:mid]), merge_sort(collection[mid:]))
 
 
-if __name__ == '__main__':
-    user_input = input('Enter numbers separated by a comma:\n').strip()
-    unsorted = [int(item) for item in user_input.split(',')]
-    print(*merge_sort(unsorted), sep=',')
+if __name__ == "__main__":
+    user_input = input("Enter numbers separated by a comma:\n").strip()
+    unsorted = [int(item) for item in user_input.split(",")]
+    print(*merge_sort(unsorted), sep=",")
diff --git a/sorts/merge_sort_fastest.py b/sorts/merge_sort_fastest.py
index 3c9ed3e9e8ee..f3c067795dd5 100644
--- a/sorts/merge_sort_fastest.py
+++ b/sorts/merge_sort_fastest.py
@@ -1,9 +1,11 @@
-'''
+"""
 Python implementation of the fastest merge sort algorithm.
 Takes an average of 0.6 microseconds to sort a list of length 1000 items.
 Best Case Scenario : O(n)
 Worst Case Scenario : O(n^2) because native python functions:min, max and remove are already O(n)
-'''
+"""
+
+
 def merge_sort(collection):
     """Pure implementation of the fastest merge sort algorithm in Python
 
@@ -32,7 +34,7 @@ def merge_sort(collection):
     return start + collection + end
 
 
-if __name__ == '__main__':
-    user_input = input('Enter numbers separated by a comma:\n').strip()
-    unsorted = [int(item) for item in user_input.split(',')]
-    print(*merge_sort(unsorted), sep=',')
+if __name__ == "__main__":
+    user_input = input("Enter numbers separated by a comma:\n").strip()
+    unsorted = [int(item) for item in user_input.split(",")]
+    print(*merge_sort(unsorted), sep=",")
diff --git a/sorts/odd_even_transposition_parallel.py b/sorts/odd_even_transposition_parallel.py
index 9bf81a39e27a..4d2f377024d2 100644
--- a/sorts/odd_even_transposition_parallel.py
+++ b/sorts/odd_even_transposition_parallel.py
@@ -12,7 +12,7 @@
 """
 from multiprocessing import Process, Pipe, Lock
 
-#lock used to ensure that two processes do not access a pipe at the same time
+# lock used to ensure that two processes do not access a pipe at the same time
 processLock = Lock()
 
 """
@@ -25,89 +25,117 @@
 LRcv, RRcv = the pipes we use to receive from our left and right neighbors
 resultPipe = the pipe used to send results back to main
 """
+
+
 def oeProcess(position, value, LSend, RSend, LRcv, RRcv, resultPipe):
     global processLock
 
-    #we perform n swaps since after n swaps we know we are sorted
-    #we *could* stop early if we are sorted already, but it takes as long to
-    #find out we are sorted as it does to sort the list with this algorithm
+    # we perform n swaps since after n swaps we know we are sorted
+    # we *could* stop early if we are sorted already, but it takes as long to
+    # find out we are sorted as it does to sort the list with this algorithm
     for i in range(0, 10):
 
-        if( (i + position) % 2 == 0 and RSend != None):
-            #send your value to your right neighbor
+        if (i + position) % 2 == 0 and RSend != None:
+            # send your value to your right neighbor
             processLock.acquire()
             RSend[1].send(value)
             processLock.release()
 
-            #receive your right neighbor's value
+            # receive your right neighbor's value
             processLock.acquire()
             temp = RRcv[0].recv()
             processLock.release()
 
-            #take the lower value since you are on the left
+            # take the lower value since you are on the left
             value = min(value, temp)
-        elif( (i + position) % 2 != 0 and LSend != None):
-            #send your value to your left neighbor
+        elif (i + position) % 2 != 0 and LSend != None:
+            # send your value to your left neighbor
             processLock.acquire()
             LSend[1].send(value)
             processLock.release()
 
-            #receive your left neighbor's value
+            # receive your left neighbor's value
             processLock.acquire()
             temp = LRcv[0].recv()
             processLock.release()
 
-            #take the higher value since you are on the right
+            # take the higher value since you are on the right
             value = max(value, temp)
-    #after all swaps are performed, send the values back to main
+    # after all swaps are performed, send the values back to main
     resultPipe[1].send(value)
 
+
 """
 the function which creates the processes that perform the parallel swaps
 
 arr = the list to be sorted
 """
+
+
 def OddEvenTransposition(arr):
 
     processArray = []
 
     resultPipe = []
 
-    #initialize the list of pipes where the values will be retrieved
+    # initialize the list of pipes where the values will be retrieved
     for _ in arr:
         resultPipe.append(Pipe())
 
-    #creates the processes
-    #the first and last process only have one neighbor so they are made outside
-    #of the loop
+    # creates the processes
+    # the first and last process only have one neighbor so they are made outside
+    # of the loop
     tempRs = Pipe()
     tempRr = Pipe()
-    processArray.append(Process(target = oeProcess, args = (0, arr[0], None, tempRs, None, tempRr, resultPipe[0])))
+    processArray.append(
+        Process(
+            target=oeProcess,
+            args=(0, arr[0], None, tempRs, None, tempRr, resultPipe[0]),
+        )
+    )
     tempLr = tempRs
     tempLs = tempRr
 
     for i in range(1, len(arr) - 1):
         tempRs = Pipe()
         tempRr = Pipe()
-        processArray.append(Process(target = oeProcess, args = (i, arr[i], tempLs, tempRs, tempLr, tempRr, resultPipe[i])))
+        processArray.append(
+            Process(
+                target=oeProcess,
+                args=(i, arr[i], tempLs, tempRs, tempLr, tempRr, resultPipe[i]),
+            )
+        )
         tempLr = tempRs
         tempLs = tempRr
 
-    processArray.append(Process(target = oeProcess, args = (len(arr) - 1, arr[len(arr) - 1], tempLs, None, tempLr, None, resultPipe[len(arr) - 1])))
-
-    #start the processes
+    processArray.append(
+        Process(
+            target=oeProcess,
+            args=(
+                len(arr) - 1,
+                arr[len(arr) - 1],
+                tempLs,
+                None,
+                tempLr,
+                None,
+                resultPipe[len(arr) - 1],
+            ),
+        )
+    )
+
+    # start the processes
     for p in processArray:
         p.start()
 
-    #wait for the processes to end and write their values to the list
+    # wait for the processes to end and write their values to the list
     for p in range(0, len(resultPipe)):
         arr[p] = resultPipe[p][0].recv()
         processArray[p].join()
 
-    return(arr)
+    return arr
 
 
-#creates a reverse sorted list and sorts it
+# creates a reverse sorted list and sorts it
 def main():
     arr = []
 
@@ -121,5 +149,6 @@ def main():
     print("Sorted List\n")
     print(*arr)
 
+
 if __name__ == "__main__":
     main()
diff --git a/sorts/odd_even_transposition_single_threaded.py b/sorts/odd_even_transposition_single_threaded.py
index ec5f3cf14e55..ec045d9dd08d 100644
--- a/sorts/odd_even_transposition_single_threaded.py
+++ b/sorts/odd_even_transposition_single_threaded.py
@@ -5,6 +5,7 @@
 is no better than bubble sort.
 """
 
+
 def OddEvenTransposition(arr):
     for i in range(0, len(arr)):
         for i in range(i % 2, len(arr) - 1, 2):
@@ -14,7 +15,8 @@ def OddEvenTransposition(arr):
 
     return arr
 
-#creates a list and sorts it
+
+# creates a list and sorts it
 def main():
     list = []
 
@@ -28,5 +30,6 @@ def main():
     print("Sorted List\n")
     print(*list)
 
+
 if __name__ == "__main__":
     main()
diff --git a/sorts/pancake_sort.py b/sorts/pancake_sort.py
index 873c14a0a174..ee54e57f9e0f 100644
--- a/sorts/pancake_sort.py
+++ b/sorts/pancake_sort.py
@@ -8,6 +8,7 @@
 python pancake_sort.py
 """
 
+
 def pancake_sort(arr):
     """Sort Array with Pancake Sort.
     :param arr: Collection containing comparable items
@@ -25,14 +26,14 @@ def pancake_sort(arr):
         # Find the maximum number in arr
         mi = arr.index(max(arr[0:cur]))
         # Reverse from 0 to mi
-        arr = arr[mi::-1] + arr[mi + 1:len(arr)]
+        arr = arr[mi::-1] + arr[mi + 1 : len(arr)]
         # Reverse whole list
-        arr = arr[cur - 1::-1] + arr[cur:len(arr)]
+        arr = arr[cur - 1 :: -1] + arr[cur : len(arr)]
         cur -= 1
     return arr
 
 
-if __name__ == '__main__':
-    user_input = input('Enter numbers separated by a comma:\n').strip()
-    unsorted = [int(item) for item in user_input.split(',')]
+if __name__ == "__main__":
+    user_input = input("Enter numbers separated by a comma:\n").strip()
+    unsorted = [int(item) for item in user_input.split(",")]
     print(pancake_sort(unsorted))
diff --git a/sorts/pigeon_sort.py b/sorts/pigeon_sort.py
index 5417234d331b..cf900699bc8d 100644
--- a/sorts/pigeon_sort.py
+++ b/sorts/pigeon_sort.py
@@ -1,4 +1,4 @@
-'''
+"""
     This is an implementation of Pigeon Hole Sort.
     For doctests run following command:
     
@@ -8,7 +8,9 @@
     
     For manual testing run:
     python pigeon_sort.py
-'''
+"""
+
+
 def pigeon_sort(array):
     """
     Implementation of pigeon hole sort algorithm
@@ -21,7 +23,7 @@ def pigeon_sort(array):
     >>> pigeon_sort([-2, -5, -45])
     [-45, -5, -2]
     """
-    if(len(array) == 0):
+    if len(array) == 0:
         return array
 
     # Manually finds the minimum and maximum of the array.
@@ -29,26 +31,29 @@ def pigeon_sort(array):
     max = array[0]
 
     for i in range(len(array)):
-        if(array[i] < min): min = array[i]
-        elif(array[i] > max): max = array[i]
+        if array[i] < min:
+            min = array[i]
+        elif array[i] > max:
+            max = array[i]
 
     # Compute the variables
-    holes_range = max-min + 1
+    holes_range = max - min + 1
     holes = [0 for _ in range(holes_range)]
     holes_repeat = [0 for _ in range(holes_range)]
 
     # Make the sorting.
     for i in range(len(array)):
         index = array[i] - min
-        if(holes[index] != array[i]):
+        if holes[index] != array[i]:
             holes[index] = array[i]
             holes_repeat[index] += 1
-        else: holes_repeat[index] += 1
+        else:
+            holes_repeat[index] += 1
 
     # Makes the array back by replacing the numbers.
     index = 0
     for i in range(holes_range):
-        while(holes_repeat[i] > 0):
+        while holes_repeat[i] > 0:
             array[index] = holes[i]
             index += 1
             holes_repeat[i] -= 1
@@ -56,7 +61,8 @@ def pigeon_sort(array):
     # Returns the sorted array.
     return array
 
-if __name__ == '__main__':
-    user_input = input('Enter numbers separated by comma:\n')
-    unsorted = [int(x) for x in user_input.split(',')]
+
+if __name__ == "__main__":
+    user_input = input("Enter numbers separated by comma:\n")
+    unsorted = [int(x) for x in user_input.split(",")]
     print(pigeon_sort(unsorted))
diff --git a/sorts/quick_sort.py b/sorts/quick_sort.py
index 60f8803cb79c..29e10206f720 100644
--- a/sorts/quick_sort.py
+++ b/sorts/quick_sort.py
@@ -9,6 +9,8 @@
 For manual testing run:
 python quick_sort.py
 """
+
+
 def quick_sort(collection):
     """Pure implementation of quick sort algorithm in Python
 
@@ -43,7 +45,7 @@ def quick_sort(collection):
         return quick_sort(lesser) + [pivot] + quick_sort(greater)
 
 
-if __name__ == '__main__':
-    user_input = input('Enter numbers separated by a comma:\n').strip()
-    unsorted = [ int(item) for item in user_input.split(',') ]
-    print( quick_sort(unsorted) )
+if __name__ == "__main__":
+    user_input = input("Enter numbers separated by a comma:\n").strip()
+    unsorted = [int(item) for item in user_input.split(",")]
+    print(quick_sort(unsorted))
diff --git a/sorts/quick_sort_3_partition.py b/sorts/quick_sort_3_partition.py
index 9056b204740a..a25ac7def802 100644
--- a/sorts/quick_sort_3_partition.py
+++ b/sorts/quick_sort_3_partition.py
@@ -17,8 +17,9 @@ def quick_sort_3partition(sorting, left, right):
     quick_sort_3partition(sorting, left, a - 1)
     quick_sort_3partition(sorting, b + 1, right)
 
-if __name__ == '__main__':
-    user_input = input('Enter numbers separated by a comma:\n').strip()
-    unsorted = [ int(item) for item in user_input.split(',') ]
-    quick_sort_3partition(unsorted,0,len(unsorted)-1)
+
+if __name__ == "__main__":
+    user_input = input("Enter numbers separated by a comma:\n").strip()
+    unsorted = [int(item) for item in user_input.split(",")]
+    quick_sort_3partition(unsorted, 0, len(unsorted) - 1)
     print(unsorted)
diff --git a/sorts/radix_sort.py b/sorts/radix_sort.py
index 8dfc66b17b23..2990247a0ac0 100644
--- a/sorts/radix_sort.py
+++ b/sorts/radix_sort.py
@@ -6,21 +6,21 @@ def radix_sort(lst):
     max_digit = max(lst)
 
     while placement < max_digit:
-      # declare and initialize buckets
-      buckets = [list() for _ in range( RADIX )]
+        # declare and initialize buckets
+        buckets = [list() for _ in range(RADIX)]
 
-      # split lst between lists
-      for i in lst:
-        tmp = int((i / placement) % RADIX)
-        buckets[tmp].append(i)
+        # split lst between lists
+        for i in lst:
+            tmp = int((i / placement) % RADIX)
+            buckets[tmp].append(i)
 
-      # empty lists into lst array
-      a = 0
-      for b in range( RADIX ):
-        buck = buckets[b]
-        for i in buck:
-          lst[a] = i
-          a += 1
+        # empty lists into lst array
+        a = 0
+        for b in range(RADIX):
+            buck = buckets[b]
+            for i in buck:
+                lst[a] = i
+                a += 1
 
-      # move to next
-      placement *= RADIX
+        # move to next
+        placement *= RADIX
diff --git a/sorts/random_normal_distribution_quicksort.py b/sorts/random_normal_distribution_quicksort.py
index 39c54c46e263..be3b90190407 100644
--- a/sorts/random_normal_distribution_quicksort.py
+++ b/sorts/random_normal_distribution_quicksort.py
@@ -3,62 +3,60 @@
 import numpy as np
 
 
-def _inPlaceQuickSort(A,start,end):
+def _inPlaceQuickSort(A, start, end):
     count = 0
-    if start<end:
-        pivot=randint(start,end)
-        temp=A[end]
-        A[end]=A[pivot]
-        A[pivot]=temp
-
-        p,count= _inPlacePartition(A,start,end)
-        count += _inPlaceQuickSort(A,start,p-1)
-        count += _inPlaceQuickSort(A,p+1,end)
+    if start < end:
+        pivot = randint(start, end)
+        temp = A[end]
+        A[end] = A[pivot]
+        A[pivot] = temp
+
+        p, count = _inPlacePartition(A, start, end)
+        count += _inPlaceQuickSort(A, start, p - 1)
+        count += _inPlaceQuickSort(A, p + 1, end)
     return count
 
-def _inPlacePartition(A,start,end):
+
+def _inPlacePartition(A, start, end):
 
     count = 0
-    pivot= randint(start,end)
-    temp=A[end]
-    A[end]=A[pivot]
-    A[pivot]=temp
-    newPivotIndex=start-1
-    for index in range(start,end):
+    pivot = randint(start, end)
+    temp = A[end]
+    A[end] = A[pivot]
+    A[pivot] = temp
+    newPivotIndex = start - 1
+    for index in range(start, end):
 
         count += 1
-        if A[index]<A[end]:#check if current val is less than pivot value
-            newPivotIndex=newPivotIndex+1
-            temp=A[newPivotIndex]
-            A[newPivotIndex]=A[index]
-            A[index]=temp
+        if A[index] < A[end]:  # check if current val is less than pivot value
+            newPivotIndex = newPivotIndex + 1
+            temp = A[newPivotIndex]
+            A[newPivotIndex] = A[index]
+            A[index] = temp
 
-    temp=A[newPivotIndex+1]
-    A[newPivotIndex+1]=A[end]
-    A[end]=temp
-    return newPivotIndex+1,count
-
-outfile = TemporaryFile()
-p = 100 # 1000 elements are to be sorted
+    temp = A[newPivotIndex + 1]
+    A[newPivotIndex + 1] = A[end]
+    A[end] = temp
+    return newPivotIndex + 1, count
 
 
+outfile = TemporaryFile()
+p = 100  # 1000 elements are to be sorted
 
 
-mu, sigma = 0, 1 # mean and standard deviation
+mu, sigma = 0, 1  # mean and standard deviation
 X = np.random.normal(mu, sigma, p)
 np.save(outfile, X)
-print('The array is')
+print("The array is")
 print(X)
 
 
-
-
-
-
 outfile.seek(0)  # using the same array
 M = np.load(outfile)
-r = (len(M)-1)
-z = _inPlaceQuickSort(M,0,r)
+r = len(M) - 1
+z = _inPlaceQuickSort(M, 0, r)
 
-print("No of Comparisons for 100 elements selected from a standard normal distribution is :")
+print(
+    "No of Comparisons for 100 elements selected from a standard normal distribution is :"
+)
 print(z)
diff --git a/sorts/random_pivot_quick_sort.py b/sorts/random_pivot_quick_sort.py
index fc8f90486ee6..d9cf4e981c2f 100644
--- a/sorts/random_pivot_quick_sort.py
+++ b/sorts/random_pivot_quick_sort.py
@@ -3,6 +3,7 @@
 """
 import random
 
+
 def partition(A, left_index, right_index):
     pivot = A[left_index]
     i = left_index + 1
@@ -13,21 +14,31 @@ def partition(A, left_index, right_index):
     A[left_index], A[i - 1] = A[i - 1], A[left_index]
     return i - 1
 
+
 def quick_sort_random(A, left, right):
     if left < right:
         pivot = random.randint(left, right - 1)
-        A[pivot], A[left] = A[left], A[pivot] #switches the pivot with the left most bound
+        A[pivot], A[left] = (
+            A[left],
+            A[pivot],
+        )  # switches the pivot with the left most bound
         pivot_index = partition(A, left, right)
-        quick_sort_random(A, left, pivot_index) #recursive quicksort to the left of the pivot point
-        quick_sort_random(A, pivot_index + 1, right) #recursive quicksort to the right of the pivot point
+        quick_sort_random(
+            A, left, pivot_index
+        )  # recursive quicksort to the left of the pivot point
+        quick_sort_random(
+            A, pivot_index + 1, right
+        )  # recursive quicksort to the right of the pivot point
+
 
 def main():
-    user_input = input('Enter numbers separated by a comma:\n').strip()
-    arr = [int(item) for item in user_input.split(',')]
+    user_input = input("Enter numbers separated by a comma:\n").strip()
+    arr = [int(item) for item in user_input.split(",")]
 
     quick_sort_random(arr, 0, len(arr))
 
     print(arr)
 
+
 if __name__ == "__main__":
-    main()
\ No newline at end of file
+    main()
diff --git a/sorts/selection_sort.py b/sorts/selection_sort.py
index 28eaa4fabd95..43ad26a7bf27 100644
--- a/sorts/selection_sort.py
+++ b/sorts/selection_sort.py
@@ -9,6 +9,8 @@
 For manual testing run:
 python selection_sort.py
 """
+
+
 def selection_sort(collection):
     """Pure implementation of the selection sort algorithm in Python
     :param collection: some mutable ordered collection with heterogeneous
@@ -33,13 +35,11 @@ def selection_sort(collection):
         for k in range(i + 1, length):
             if collection[k] < collection[least]:
                 least = k
-        collection[least], collection[i] = (
-            collection[i], collection[least]
-        )
+        collection[least], collection[i] = (collection[i], collection[least])
     return collection
 
 
-if __name__ == '__main__':
-    user_input = input('Enter numbers separated by a comma:\n').strip()
-    unsorted = [int(item) for item in user_input.split(',')]
+if __name__ == "__main__":
+    user_input = input("Enter numbers separated by a comma:\n").strip()
+    unsorted = [int(item) for item in user_input.split(",")]
     print(selection_sort(unsorted))
diff --git a/sorts/shell_sort.py b/sorts/shell_sort.py
index 9427394485bc..ff9c2785b218 100644
--- a/sorts/shell_sort.py
+++ b/sorts/shell_sort.py
@@ -9,6 +9,8 @@
 For manual testing run:
 python shell_sort.py
 """
+
+
 def shell_sort(collection):
     """Pure implementation of shell sort algorithm in Python
     :param collection:  Some mutable ordered collection with heterogeneous
@@ -40,7 +42,8 @@ def shell_sort(collection):
 
     return collection
 
-if __name__ == '__main__':
-    user_input = input('Enter numbers separated by a comma:\n').strip()
-    unsorted = [int(item) for item in user_input.split(',')]
+
+if __name__ == "__main__":
+    user_input = input("Enter numbers separated by a comma:\n").strip()
+    unsorted = [int(item) for item in user_input.split(",")]
     print(shell_sort(unsorted))
diff --git a/sorts/stooge_sort.py b/sorts/stooge_sort.py
index d2325abc9b38..8cccd1e8c657 100644
--- a/sorts/stooge_sort.py
+++ b/sorts/stooge_sort.py
@@ -5,30 +5,27 @@ def stooge_sort(arr):
     >>> print(arr)
     [1, 2, 3, 4, 5]
     """
-    stooge(arr,0,len(arr)-1)
+    stooge(arr, 0, len(arr) - 1)
 
-    
-def stooge(arr, i, h):
 
+def stooge(arr, i, h):
 
     if i >= h:
         return
-  
+
     # If first element is smaller than the last then swap them
-    if arr[i]>arr[h]:
+    if arr[i] > arr[h]:
         arr[i], arr[h] = arr[h], arr[i]
-  
+
     # If there are more than 2 elements in the array
-    if h-i+1 > 2: 
-        t = (int)((h-i+1)/3)
-  
+    if h - i + 1 > 2:
+        t = (int)((h - i + 1) / 3)
+
         # Recursively sort first 2/3 elements
-        stooge(arr, i, (h-t))
-  
+        stooge(arr, i, (h - t))
+
         # Recursively sort last 2/3 elements
-        stooge(arr, i+t, (h))
-  
-        # Recursively sort first 2/3 elements
-        stooge(arr, i, (h-t))
+        stooge(arr, i + t, (h))
 
-        
+        # Recursively sort first 2/3 elements
+        stooge(arr, i, (h - t))
diff --git a/sorts/topological_sort.py b/sorts/topological_sort.py
index 74e58899a9a0..e7a52f7c7714 100644
--- a/sorts/topological_sort.py
+++ b/sorts/topological_sort.py
@@ -5,8 +5,8 @@
 #   b  c
 #  / \
 # d  e
-edges = {'a': ['c', 'b'], 'b': ['d', 'e'], 'c': [], 'd': [], 'e': []}
-vertices = ['a', 'b', 'c', 'd', 'e']
+edges = {"a": ["c", "b"], "b": ["d", "e"], "c": [], "d": [], "e": []}
+vertices = ["a", "b", "c", "d", "e"]
 
 
 def topological_sort(start, visited, sort):
@@ -30,6 +30,6 @@ def topological_sort(start, visited, sort):
     return sort
 
 
-if __name__ == '__main__':
-    sort = topological_sort('a', [], [])
+if __name__ == "__main__":
+    sort = topological_sort("a", [], [])
     print(sort)
diff --git a/sorts/tree_sort.py b/sorts/tree_sort.py
index baa4fc1acc20..716170a94fd1 100644
--- a/sorts/tree_sort.py
+++ b/sorts/tree_sort.py
@@ -5,7 +5,7 @@
 """
 
 
-class node():
+class node:
     # BST data structure
     def __init__(self, val):
         self.val = val
@@ -49,5 +49,5 @@ def tree_sort(arr):
     return res
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     print(tree_sort([10, 1, 3, 2, 9, 14, 13]))
diff --git a/sorts/wiggle_sort.py b/sorts/wiggle_sort.py
index 606feb4d3dd1..5e5220ffbf05 100644
--- a/sorts/wiggle_sort.py
+++ b/sorts/wiggle_sort.py
@@ -16,7 +16,7 @@ def wiggle_sort(nums):
             nums[i - 1], nums[i] = nums[i], nums[i - 1]
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     print("Enter the array elements:\n")
     array = list(map(int, input().split()))
     print("The unsorted array is:\n")
diff --git a/strings/boyer_moore_search.py b/strings/boyer_moore_search.py
index 2d67043dc028..59ee76b860d3 100644
--- a/strings/boyer_moore_search.py
+++ b/strings/boyer_moore_search.py
@@ -20,12 +20,9 @@
 
 
 class BoyerMooreSearch:
-
-
     def __init__(self, text, pattern):
         self.text, self.pattern = text, pattern
         self.textLen, self.patLen = len(text), len(pattern)
-    
 
     def match_in_pattern(self, char):
         """ finds the index of char in pattern in reverse order
@@ -36,14 +33,13 @@ def match_in_pattern(self, char):
         Returns :
             i (int): index of char from last in pattern
             -1 (int): if char is not found in pattern 
-        """ 
+        """
 
-        for i in range(self.patLen-1, -1, -1):
+        for i in range(self.patLen - 1, -1, -1):
             if char == self.pattern[i]:
                 return i
         return -1
 
-
     def mismatch_in_text(self, currentPos):
         """ finds the index of mis-matched character in text when compared with pattern from last
 
@@ -55,14 +51,13 @@ def mismatch_in_text(self, currentPos):
             -1 (int): if there is no mis-match between pattern and text block
         """
 
-        for i in range(self.patLen-1, -1, -1):
+        for i in range(self.patLen - 1, -1, -1):
             if self.pattern[i] != self.text[currentPos + i]:
                 return currentPos + i
         return -1
 
-        
     def bad_character_heuristic(self):
-        # searches pattern in text and returns index positions 
+        # searches pattern in text and returns index positions
         positions = []
         for i in range(self.textLen - self.patLen + 1):
             mismatch_index = self.mismatch_in_text(i)
@@ -70,12 +65,14 @@ def bad_character_heuristic(self):
                 positions.append(i)
             else:
                 match_index = self.match_in_pattern(self.text[mismatch_index])
-                i = mismatch_index - match_index   #shifting index lgtm [py/multiple-definition]
+                i = (
+                    mismatch_index - match_index
+                )  # shifting index lgtm [py/multiple-definition]
         return positions
 
- 
+
 text = "ABAABA"
-pattern = "AB" 
+pattern = "AB"
 bms = BoyerMooreSearch(text, pattern)
 positions = bms.bad_character_heuristic()
 
@@ -84,5 +81,3 @@ def bad_character_heuristic(self):
 else:
     print("Pattern found in following positions: ")
     print(positions)
-    
-
diff --git a/strings/knuth_morris_pratt.py b/strings/knuth_morris_pratt.py
index 4553944284be..c7e96887c387 100644
--- a/strings/knuth_morris_pratt.py
+++ b/strings/knuth_morris_pratt.py
@@ -46,14 +46,14 @@ def get_failure_array(pattern):
         if pattern[i] == pattern[j]:
             i += 1
         elif i > 0:
-            i = failure[i-1]
+            i = failure[i - 1]
             continue
         j += 1
         failure.append(i)
     return failure
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     # Test 1)
     pattern = "abc1abc12"
     text1 = "alskfjaldsabc1abc1abc12k23adsfabcabc"
diff --git a/strings/levenshtein_distance.py b/strings/levenshtein_distance.py
index 78175576194b..9b8793544a99 100644
--- a/strings/levenshtein_distance.py
+++ b/strings/levenshtein_distance.py
@@ -64,10 +64,13 @@ def levenshtein_distance(first_word, second_word):
     return previous_row[-1]
 
 
-if __name__ == '__main__':
-    first_word = input('Enter the first word:\n').strip()
-    second_word = input('Enter the second word:\n').strip()
+if __name__ == "__main__":
+    first_word = input("Enter the first word:\n").strip()
+    second_word = input("Enter the second word:\n").strip()
 
     result = levenshtein_distance(first_word, second_word)
-    print('Levenshtein distance between {} and {} is {}'.format(
-        first_word, second_word, result))
+    print(
+        "Levenshtein distance between {} and {} is {}".format(
+            first_word, second_word, result
+        )
+    )
diff --git a/strings/manacher.py b/strings/manacher.py
index e73e173b43e0..ef8a724d027d 100644
--- a/strings/manacher.py
+++ b/strings/manacher.py
@@ -1,10 +1,15 @@
 # calculate palindromic length from center with incrementing difference
-def palindromic_length( center, diff, string):
-    if center-diff == -1 or center+diff == len(string) or string[center-diff] != string[center+diff] :
+def palindromic_length(center, diff, string):
+    if (
+        center - diff == -1
+        or center + diff == len(string)
+        or string[center - diff] != string[center + diff]
+    ):
         return 0
-    return 1 + palindromic_length(center, diff+1, string)
+    return 1 + palindromic_length(center, diff + 1, string)
 
-def palindromic_string( input_string ):
+
+def palindromic_string(input_string):
     """
     Manacher’s algorithm which finds Longest Palindromic Substring in linear time.
 
@@ -16,37 +21,36 @@ def palindromic_string( input_string ):
     3. return output_string from center - max_length to center + max_length and remove all "|"   
     """
     max_length = 0
-    
+
     # if input_string is "aba" than new_input_string become "a|b|a"
     new_input_string = ""
     output_string = ""
 
     # append each character + "|" in new_string for range(0, length-1)
-    for i in input_string[:len(input_string)-1] :
+    for i in input_string[: len(input_string) - 1]:
         new_input_string += i + "|"
-    #append last character
+    # append last character
     new_input_string += input_string[-1]
 
-
     # for each character in new_string find corresponding palindromic string
-    for i in range(len(new_input_string)) :
+    for i in range(len(new_input_string)):
 
         # get palindromic length from ith position
         length = palindromic_length(i, 1, new_input_string)
 
         # update max_length and start position
-        if max_length < length :
+        if max_length < length:
             max_length = length
             start = i
-    
-    #create that string
-    for i in new_input_string[start-max_length:start+max_length+1] :
+
+    # create that string
+    for i in new_input_string[start - max_length : start + max_length + 1]:
         if i != "|":
             output_string += i
-    
+
     return output_string
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     n = input()
     print(palindromic_string(n))
diff --git a/strings/min_cost_string_conversion.py b/strings/min_cost_string_conversion.py
index 95840c484ba7..abc9d2c65158 100644
--- a/strings/min_cost_string_conversion.py
+++ b/strings/min_cost_string_conversion.py
@@ -1,114 +1,118 @@
-'''
+"""
 Algorithm for calculating the most cost-efficient sequence for converting one string into another.
 The only allowed operations are
 ---Copy character with cost cC
 ---Replace character with cost cR
 ---Delete character with cost cD
 ---Insert character with cost cI
-'''
+"""
+
+
 def compute_transform_tables(X, Y, cC, cR, cD, cI):
-	X = list(X)
-	Y = list(Y)
-	m = len(X)
-	n = len(Y)
+    X = list(X)
+    Y = list(Y)
+    m = len(X)
+    n = len(Y)
+
+    costs = [[0 for _ in range(n + 1)] for _ in range(m + 1)]
+    ops = [[0 for _ in range(n + 1)] for _ in range(m + 1)]
 
-	costs = [[0 for _ in range(n+1)] for _ in range(m+1)]
-	ops = [[0 for _ in range(n+1)] for _ in range(m+1)]
+    for i in range(1, m + 1):
+        costs[i][0] = i * cD
+        ops[i][0] = "D%c" % X[i - 1]
 
-	for i in range(1, m+1):
-		costs[i][0] = i*cD
-		ops[i][0] = 'D%c' % X[i-1]
+    for i in range(1, n + 1):
+        costs[0][i] = i * cI
+        ops[0][i] = "I%c" % Y[i - 1]
 
-	for i in range(1, n+1):
-		costs[0][i] = i*cI
-		ops[0][i] = 'I%c' % Y[i-1]
+    for i in range(1, m + 1):
+        for j in range(1, n + 1):
+            if X[i - 1] == Y[j - 1]:
+                costs[i][j] = costs[i - 1][j - 1] + cC
+                ops[i][j] = "C%c" % X[i - 1]
+            else:
+                costs[i][j] = costs[i - 1][j - 1] + cR
+                ops[i][j] = "R%c" % X[i - 1] + str(Y[j - 1])
 
-	for i in range(1, m+1):
-		for j in range(1, n+1):
-			if X[i-1] == Y[j-1]:
-				costs[i][j] = costs[i-1][j-1] + cC
-				ops[i][j] = 'C%c' % X[i-1]
-			else:
-				costs[i][j] = costs[i-1][j-1] + cR
-				ops[i][j] = 'R%c' % X[i-1] + str(Y[j-1])
+            if costs[i - 1][j] + cD < costs[i][j]:
+                costs[i][j] = costs[i - 1][j] + cD
+                ops[i][j] = "D%c" % X[i - 1]
 
-			if costs[i-1][j] + cD < costs[i][j]:
-				costs[i][j] = costs[i-1][j] + cD
-				ops[i][j] = 'D%c' % X[i-1]
+            if costs[i][j - 1] + cI < costs[i][j]:
+                costs[i][j] = costs[i][j - 1] + cI
+                ops[i][j] = "I%c" % Y[j - 1]
 
-			if costs[i][j-1] + cI < costs[i][j]:
-				costs[i][j] = costs[i][j-1] + cI
-				ops[i][j] = 'I%c' % Y[j-1]
+    return costs, ops
 
-	return costs, ops
 
 def assemble_transformation(ops, i, j):
-	if i == 0 and j == 0:
-		seq = []
-		return seq
-	else:
-		if ops[i][j][0] == 'C' or ops[i][j][0] == 'R':
-			seq = assemble_transformation(ops, i-1, j-1)
-			seq.append(ops[i][j])
-			return seq
-		elif ops[i][j][0] == 'D':
-			seq = assemble_transformation(ops, i-1, j)
-			seq.append(ops[i][j])
-			return seq
-		else:
-			seq = assemble_transformation(ops, i, j-1)
-			seq.append(ops[i][j])
-			return seq
-
-if __name__ == '__main__':
-	_, operations = compute_transform_tables('Python', 'Algorithms', -1, 1, 2, 2)
-
-	m = len(operations)
-	n = len(operations[0])
-	sequence = assemble_transformation(operations, m-1, n-1)
-
-	string = list('Python')
-	i = 0
-	cost = 0
-
-	with open('min_cost.txt', 'w') as file:
-		for op in sequence:
-			print(''.join(string))
-
-			if op[0] == 'C':
-				file.write('%-16s' % 'Copy %c' % op[1])
-				file.write('\t\t\t' + ''.join(string))
-				file.write('\r\n')
-
-				cost -= 1
-			elif op[0] == 'R':
-				string[i] = op[2]
-
-				file.write('%-16s' % ('Replace %c' % op[1] + ' with ' + str(op[2])))
-				file.write('\t\t' + ''.join(string))
-				file.write('\r\n')
-
-				cost += 1
-			elif op[0] == 'D':
-				string.pop(i)
-
-				file.write('%-16s' % 'Delete %c' % op[1])
-				file.write('\t\t\t' + ''.join(string))
-				file.write('\r\n')
-
-				cost += 2
-			else:
-				string.insert(i, op[1])
-
-				file.write('%-16s' % 'Insert %c' % op[1])
-				file.write('\t\t\t' + ''.join(string))
-				file.write('\r\n')
-
-				cost += 2
-
-			i += 1
-
-		print(''.join(string))
-		print('Cost: ', cost)
-
-		file.write('\r\nMinimum cost: ' + str(cost))
+    if i == 0 and j == 0:
+        seq = []
+        return seq
+    else:
+        if ops[i][j][0] == "C" or ops[i][j][0] == "R":
+            seq = assemble_transformation(ops, i - 1, j - 1)
+            seq.append(ops[i][j])
+            return seq
+        elif ops[i][j][0] == "D":
+            seq = assemble_transformation(ops, i - 1, j)
+            seq.append(ops[i][j])
+            return seq
+        else:
+            seq = assemble_transformation(ops, i, j - 1)
+            seq.append(ops[i][j])
+            return seq
+
+
+if __name__ == "__main__":
+    _, operations = compute_transform_tables("Python", "Algorithms", -1, 1, 2, 2)
+
+    m = len(operations)
+    n = len(operations[0])
+    sequence = assemble_transformation(operations, m - 1, n - 1)
+
+    string = list("Python")
+    i = 0
+    cost = 0
+
+    with open("min_cost.txt", "w") as file:
+        for op in sequence:
+            print("".join(string))
+
+            if op[0] == "C":
+                file.write("%-16s" % "Copy %c" % op[1])
+                file.write("\t\t\t" + "".join(string))
+                file.write("\r\n")
+
+                cost -= 1
+            elif op[0] == "R":
+                string[i] = op[2]
+
+                file.write("%-16s" % ("Replace %c" % op[1] + " with " + str(op[2])))
+                file.write("\t\t" + "".join(string))
+                file.write("\r\n")
+
+                cost += 1
+            elif op[0] == "D":
+                string.pop(i)
+
+                file.write("%-16s" % "Delete %c" % op[1])
+                file.write("\t\t\t" + "".join(string))
+                file.write("\r\n")
+
+                cost += 2
+            else:
+                string.insert(i, op[1])
+
+                file.write("%-16s" % "Insert %c" % op[1])
+                file.write("\t\t\t" + "".join(string))
+                file.write("\r\n")
+
+                cost += 2
+
+            i += 1
+
+        print("".join(string))
+        print("Cost: ", cost)
+
+        file.write("\r\nMinimum cost: " + str(cost))
diff --git a/strings/naive_string_search.py b/strings/naive_string_search.py
index 04c0d8157b24..a8c2ea584399 100644
--- a/strings/naive_string_search.py
+++ b/strings/naive_string_search.py
@@ -7,23 +7,26 @@
     n=length of main string
     m=length of pattern string
 """
-def naivePatternSearch(mainString,pattern):
-    patLen=len(pattern)
-    strLen=len(mainString)
-    position=[]
-    for i in range(strLen-patLen+1):
-        match_found=True
+
+
+def naivePatternSearch(mainString, pattern):
+    patLen = len(pattern)
+    strLen = len(mainString)
+    position = []
+    for i in range(strLen - patLen + 1):
+        match_found = True
         for j in range(patLen):
-            if mainString[i+j]!=pattern[j]:
-                match_found=False
+            if mainString[i + j] != pattern[j]:
+                match_found = False
                 break
         if match_found:
             position.append(i)
     return position
 
-mainString="ABAAABCDBBABCDDEBCABC"
-pattern="ABC"
-position=naivePatternSearch(mainString,pattern)
+
+mainString = "ABAAABCDBBABCDDEBCABC"
+pattern = "ABC"
+position = naivePatternSearch(mainString, pattern)
 print("Pattern found in position ")
 for x in position:
-    print(x)
\ No newline at end of file
+    print(x)
diff --git a/traversals/binary_tree_traversals.py b/traversals/binary_tree_traversals.py
index 389311a7cfde..31a73ae0c6a4 100644
--- a/traversals/binary_tree_traversals.py
+++ b/traversals/binary_tree_traversals.py
@@ -266,6 +266,7 @@ def prompt(s: str = "", width=50, char="*") -> str:
 
 if __name__ == "__main__":
     import doctest
+
     doctest.testmod()
     print(prompt("Binary Tree Traversals"))
 

From 6ebd899c0145e8a4655c9a0d476f19f5f4d7ba2f Mon Sep 17 00:00:00 2001
From: Christian Clauss <cclauss@me.com>
Date: Sat, 5 Oct 2019 20:32:58 +0500
Subject: [PATCH 237/348] CONTRIBUTING.md: Fix mistake in doctest ;-) (#1266)

* CONTRIBUTING.md: Fix mistake in doctest ;-)

* Update CONTRIBUTING.md
---
 CONTRIBUTING.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 8cd03217d51f..6dd2f6c6ff78 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -82,11 +82,11 @@ We want your work to be readable by others; therefore, we encourage you to note
       """
       This function returns the sum of two integers a and b
   	  Return: a + b
-      >>> sum(2, 2)
+      >>> sumab(2, 2)
       4
-      >>> sum(-2, 3)
+      >>> sumab(-2, 3)
       1
-      >>> sum(4.9, 6.1)
+      >>> sumab(4.9, 5.1)
       10.0
       """
       return a + b

From c4a97677a57ab5ed5bf1d8238983c8899eb88a6c Mon Sep 17 00:00:00 2001
From: Nikhil Nayak <nikhil.nixel@gmail.com>
Date: Mon, 7 Oct 2019 00:05:56 +0530
Subject: [PATCH 238/348] Update fibonacci_sequence_recursion.py (#1287)

- Fixed minor bugs.
 - Minimized Codes
---
 maths/fibonacci_sequence_recursion.py | 17 +++++++----------
 1 file changed, 7 insertions(+), 10 deletions(-)

diff --git a/maths/fibonacci_sequence_recursion.py b/maths/fibonacci_sequence_recursion.py
index 3a565a458631..2e0d835cf15e 100644
--- a/maths/fibonacci_sequence_recursion.py
+++ b/maths/fibonacci_sequence_recursion.py
@@ -2,20 +2,17 @@
 
 
 def recur_fibo(n):
-    if n <= 1:
-        return n
-    else:
-        (recur_fibo(n - 1) + recur_fibo(n - 2))
-
-
-def isPositiveInteger(limit):
-    return limit >= 0
+    """
+    >>> [recur_fibo(i) for i in range(12)]
+    [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
+    """
+    return n if n <= 1 else recur_fibo(n-1) + recur_fibo(n-2)
 
 
 def main():
     limit = int(input("How many terms to include in fibonacci series: "))
-    if isPositiveInteger(limit):
-        print("The first {limit} terms of the fibonacci series are as follows:")
+    if limit > 0:
+        print(f"The first {limit} terms of the fibonacci series are as follows:")
         print([recur_fibo(n) for n in range(limit)])
     else:
         print("Please enter a positive integer: ")

From 0a7d387acbde85cda981ebc4cc4266270f77cf0a Mon Sep 17 00:00:00 2001
From: TheRealDarkCoder <zuhayr2003@gmail.com>
Date: Mon, 7 Oct 2019 00:47:32 +0600
Subject: [PATCH 239/348] Added a python script for finding sum of arithmetic
 series (#1279)

* Added a python script for finding sum of arithmetic series

* Added some linting

* Resolved comments

* Fixed flake8 test
---
 maths/sum_of_arithmetic_series.py | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100755 maths/sum_of_arithmetic_series.py

diff --git a/maths/sum_of_arithmetic_series.py b/maths/sum_of_arithmetic_series.py
new file mode 100755
index 000000000000..f7ea5dc84cb8
--- /dev/null
+++ b/maths/sum_of_arithmetic_series.py
@@ -0,0 +1,22 @@
+# DarkCoder
+def sum_of_series(first_term, common_diff, num_of_terms):
+    """
+    Find the sum of n terms in an arithmetic progression.
+
+    >>> sum_of_series(1, 1, 10)
+    55.0
+    >>> sum_of_series(1, 10, 100)
+    49600.0
+    """
+    sum = ((num_of_terms/2)*(2*first_term+(num_of_terms-1)*common_diff))
+    # formula for sum of series
+    return sum
+
+
+def main():
+    print(sum_of_series(1, 1, 10))
+
+
+if __name__ == "__main__":
+    import doctest
+    doctest.testmod()

From b1a769cf44df6f1eec740e10e393fab548e3822a Mon Sep 17 00:00:00 2001
From: Parth Paradkar <parthparadkar3@gmail.com>
Date: Mon, 7 Oct 2019 00:20:50 +0530
Subject: [PATCH 240/348] Add pure implementation of K-Nearest Neighbours
 (#1278)

* Pure implementation of KNN added

* Comments and test case added

* doctest added
---
 machine_learning/k_nearest_neighbours.py | 55 ++++++++++++++++++++++++
 1 file changed, 55 insertions(+)
 create mode 100644 machine_learning/k_nearest_neighbours.py

diff --git a/machine_learning/k_nearest_neighbours.py b/machine_learning/k_nearest_neighbours.py
new file mode 100644
index 000000000000..83d8399fe9b6
--- /dev/null
+++ b/machine_learning/k_nearest_neighbours.py
@@ -0,0 +1,55 @@
+import numpy as np
+from collections import Counter
+from sklearn import datasets
+from sklearn.model_selection import train_test_split
+
+data = datasets.load_iris()
+
+X = np.array(data['data'])
+y = np.array(data['target'])
+classes = data['target_names']
+
+X_train, X_test, y_train, y_test = train_test_split(X, y)
+
+def euclidean_distance(a, b):
+    """
+    Gives the euclidean distance between two points
+    >>> euclidean_distance([0, 0], [3, 4])
+    5.0
+    >>> euclidean_distance([1, 2, 3], [1, 8, 11])
+    10.0
+    """
+    return np.linalg.norm(np.array(a) - np.array(b))
+
+def classifier(train_data, train_target, classes, point, k=5):
+    """
+    Classifies the point using the KNN algorithm
+    k closest points are found (ranked in ascending order of euclidean distance)
+    Params:
+    :train_data: Set of points that are classified into two or more classes
+    :train_target: List of classes in the order of train_data points
+    :classes: Labels of the classes
+    :point: The data point that needs to be classifed
+
+    >>> X_train = [[0, 0], [1, 0], [0, 1], [0.5, 0.5], [3, 3], [2, 3], [3, 2]]
+    >>> y_train = [0, 0, 0, 0, 1, 1, 1]
+    >>> classes = ['A','B']; point = [1.2,1.2]
+    >>> classifier(X_train, y_train, classes,point)
+    'A'
+    """
+    data = zip(train_data, train_target)
+    # List of distances of all points from the point to be classified
+    distances = []
+    for data_point in data:
+        distance = euclidean_distance(data_point[0], point)
+        distances.append((distance, data_point[1]))
+    # Choosing 'k' points with the least distances. 
+    votes = [i[1] for i in sorted(distances)[:k]]
+    # Most commonly occuring class among them 
+    # is the class into which the point is classified
+    result = Counter(votes).most_common(1)[0][0]
+    return classes[result]
+
+
+if __name__ == "__main__":
+    print(classifier(X_train, y_train, classes, [4.4, 3.1, 1.3, 1.4]))
\ No newline at end of file

From 9cc9f67d646d427eb6b8296767aea50dd139969f Mon Sep 17 00:00:00 2001
From: Sushil Singh <36241112+OddExtension5@users.noreply.github.com>
Date: Mon, 7 Oct 2019 00:22:04 +0530
Subject: [PATCH 241/348] Chinese Remainder Theorem | Diophantine Equation |
 Modular Division (#1248)

* Update .gitignore to remove __pycache__/

* added chinese_remainder_theorem

* Added Diophantine_equation algorithm

* Update Diophantine eqn & chinese remainder theorem

* Update Diophantine eqn & chinese remainder theorem

* added efficient modular division algorithm

* added GCD function

* update chinese_remainder_theorem | dipohantine eqn | modular_division

* update chinese_remainder_theorem | dipohantine eqn | modular_division

* added a new directory named blockchain & a files from data_structures/hashing/number_theory

* added a new directory named blockchain & a files from data_structures/hashing/number_theory
---
 blockchain/chinese_remainder_theorem.py |  91 +++++++++++++++
 blockchain/diophantine_equation.py      | 124 ++++++++++++++++++++
 blockchain/modular_division.py          | 149 ++++++++++++++++++++++++
 3 files changed, 364 insertions(+)
 create mode 100644 blockchain/chinese_remainder_theorem.py
 create mode 100644 blockchain/diophantine_equation.py
 create mode 100644 blockchain/modular_division.py

diff --git a/blockchain/chinese_remainder_theorem.py b/blockchain/chinese_remainder_theorem.py
new file mode 100644
index 000000000000..f1409530a70e
--- /dev/null
+++ b/blockchain/chinese_remainder_theorem.py
@@ -0,0 +1,91 @@
+# Chinese Remainder Theorem:
+# GCD ( Greatest Common Divisor ) or HCF ( Highest Common Factor )
+
+# If GCD(a,b) = 1, then for any remainder ra modulo a and any remainder rb modulo b there exists integer n,
+# such that n = ra (mod a) and n = ra(mod b).  If n1 and n2 are two such integers, then n1=n2(mod ab)
+
+# Algorithm :
+
+# 1. Use extended euclid algorithm to find x,y such that a*x + b*y = 1
+# 2. Take n = ra*by + rb*ax
+
+
+# Extended Euclid
+def extended_euclid(a, b):
+    """
+    >>> extended_euclid(10, 6)
+    (-1, 2)
+
+    >>> extended_euclid(7, 5)
+    (-2, 3)
+
+    """
+    if b == 0:
+        return (1, 0)
+    (x, y) = extended_euclid(b, a % b)
+    k = a // b
+    return (y, x - k * y)
+
+
+# Uses ExtendedEuclid to find inverses
+def chinese_remainder_theorem(n1, r1, n2, r2):
+    """
+    >>> chinese_remainder_theorem(5,1,7,3)
+    31
+
+    Explanation : 31 is the smallest number such that
+                (i)  When we divide it by 5, we get remainder 1
+                (ii) When we divide it by 7, we get remainder 3
+
+    >>> chinese_remainder_theorem(6,1,4,3)
+    14
+
+    """
+    (x, y) = extended_euclid(n1, n2)
+    m = n1 * n2
+    n = r2 * x * n1 + r1 * y * n2
+    return ((n % m + m) % m)
+
+
+# ----------SAME SOLUTION USING InvertModulo instead ExtendedEuclid----------------
+
+# This function find the inverses of a i.e., a^(-1)
+def invert_modulo(a, n):
+    """
+    >>> invert_modulo(2, 5)
+    3
+
+    >>> invert_modulo(8,7)
+    1
+
+    """
+    (b, x) = extended_euclid(a, n)
+    if b < 0:
+        b = (b % n + n) % n
+    return b
+
+
+# Same a above using InvertingModulo
+def chinese_remainder_theorem2(n1, r1, n2, r2):
+    """
+    >>> chinese_remainder_theorem2(5,1,7,3)
+    31
+
+    >>> chinese_remainder_theorem2(6,1,4,3)
+    14
+
+    """
+    x, y = invert_modulo(n1, n2), invert_modulo(n2, n1)
+    m = n1 * n2
+    n = r2 * x * n1 + r1 * y * n2
+    return (n % m + m) % m
+
+
+# import testmod for testing our function
+from doctest import testmod
+
+if __name__ == '__main__':
+    testmod(name='chinese_remainder_theorem', verbose=True)
+    testmod(name='chinese_remainder_theorem2', verbose=True)
+    testmod(name='invert_modulo', verbose=True)
+    testmod(name='extended_euclid', verbose=True)
diff --git a/blockchain/diophantine_equation.py b/blockchain/diophantine_equation.py
new file mode 100644
index 000000000000..3ac7094eed6b
--- /dev/null
+++ b/blockchain/diophantine_equation.py
@@ -0,0 +1,124 @@
+# Diophantine Equation : Given integers a,b,c ( at least one of a and b != 0), the diophantine equation
+# a*x + b*y = c has a solution (where x and y are integers) iff gcd(a,b) divides c.
+
+# GCD ( Greatest Common Divisor ) or HCF ( Highest Common Factor )
+
+
+def diophantine(a, b, c):
+    """
+    >>> diophantine(10,6,14)
+    (-7.0, 14.0)
+
+    >>> diophantine(391,299,-69)
+    (9.0, -12.0)
+
+    But above equation has one more solution i.e., x = -4, y = 5.
+    That's why we need diophantine all solution function.
+
+    """
+
+    assert c % greatest_common_divisor(a, b) == 0  # greatest_common_divisor(a,b) function implemented below
+    (d, x, y) = extended_gcd(a, b)  # extended_gcd(a,b) function implemented below
+    r = c / d
+    return (r * x, r * y)
+
+
+# Lemma : if n|ab and gcd(a,n) = 1, then n|b.
+
+# Finding All solutions of Diophantine Equations:
+
+# Theorem : Let gcd(a,b) = d, a = d*p, b = d*q. If (x0,y0) is a solution of Diophantine Equation a*x + b*y = c.
+# a*x0 + b*y0 = c, then all the solutions have the form a(x0 + t*q) + b(y0 - t*p) = c, where t is an arbitrary integer.
+
+# n is the number of solution you want, n = 2 by default
+
+def diophantine_all_soln(a, b, c, n=2):
+    """
+    >>> diophantine_all_soln(10, 6, 14)
+    -7.0 14.0
+    -4.0 9.0
+
+    >>> diophantine_all_soln(10, 6, 14, 4)
+    -7.0 14.0
+    -4.0 9.0
+    -1.0 4.0
+    2.0 -1.0
+
+    >>> diophantine_all_soln(391, 299, -69, n = 4)
+    9.0 -12.0
+    22.0 -29.0
+    35.0 -46.0
+    48.0 -63.0
+
+    """
+    (x0, y0) = diophantine(a, b, c)  # Initial value
+    d = greatest_common_divisor(a, b)
+    p = a // d
+    q = b // d
+
+    for i in range(n):
+        x = x0 + i * q
+        y = y0 - i * p
+        print(x, y)
+
+
+# Euclid's Lemma :  d divides a and b, if and only if d divides a-b and b
+
+# Euclid's Algorithm
+
+def greatest_common_divisor(a, b):
+    """
+    >>> greatest_common_divisor(7,5)
+    1
+
+    Note : In number theory, two integers a and b are said to be relatively prime, mutually prime, or co-prime
+           if the only positive integer (factor) that divides both of them is 1  i.e., gcd(a,b) = 1.
+
+    >>> greatest_common_divisor(121, 11)
+    11
+
+    """
+    if a < b:
+        a, b = b, a
+
+    while a % b != 0:
+        a, b = b, a % b
+
+    return b
+
+
+# Extended Euclid's Algorithm : If d divides a and b and d = a*x + b*y for integers x and y, then d = gcd(a,b)
+
+
+def extended_gcd(a, b):
+    """
+    >>> extended_gcd(10, 6)
+    (2, -1, 2)
+
+    >>> extended_gcd(7, 5)
+    (1, -2, 3)
+
+    """
+    assert a >= 0 and b >= 0
+
+    if b == 0:
+        d, x, y = a, 1, 0
+    else:
+        (d, p, q) = extended_gcd(b, a % b)
+        x = q
+        y = p - q * (a // b)
+
+    assert a % d == 0 and b % d == 0
+    assert d == a * x + b * y
+
+    return (d, x, y)
+
+
+# import testmod for testing our function
+from doctest import testmod
+
+if __name__ == '__main__':
+    testmod(name='diophantine', verbose=True)
+    testmod(name='diophantine_all_soln', verbose=True)
+    testmod(name='extended_gcd', verbose=True)
+    testmod(name='greatest_common_divisor', verbose=True)
diff --git a/blockchain/modular_division.py b/blockchain/modular_division.py
new file mode 100644
index 000000000000..4e1623fbe923
--- /dev/null
+++ b/blockchain/modular_division.py
@@ -0,0 +1,149 @@
+# Modular Division :
+# An efficient algorithm for dividing b by a modulo n.
+
+# GCD ( Greatest Common Divisor ) or HCF ( Highest Common Factor )
+
+# Given three integers a, b, and n, such that gcd(a,n)=1 and n>1, the algorithm should return an integer x such that
+#        0≤x≤n−1, and  b/a=x(modn) (that is, b=ax(modn)).
+
+# Theorem:
+# a has a multiplicative inverse modulo n iff gcd(a,n) = 1
+
+
+# This find x = b*a^(-1) mod n
+# Uses ExtendedEuclid to find the inverse of a
+
+
+def modular_division(a, b, n):
+    """
+    >>> modular_division(4,8,5)
+    2
+
+    >>> modular_division(3,8,5)
+    1
+
+    >>> modular_division(4, 11, 5)
+    4
+
+    """
+    assert n > 1 and a > 0 and greatest_common_divisor(a, n) == 1
+    (d, t, s) = extended_gcd(n, a)  # Implemented below
+    x = (b * s) % n
+    return x
+
+
+# This function find the inverses of a i.e., a^(-1)
+def invert_modulo(a, n):
+    """
+    >>> invert_modulo(2, 5)
+    3
+
+    >>> invert_modulo(8,7)
+    1
+
+    """
+    (b, x) = extended_euclid(a, n)  # Implemented below
+    if b < 0:
+        b = (b % n + n) % n
+    return b
+
+
+# ------------------ Finding Modular division using invert_modulo -------------------
+
+# This function used the above inversion of a to find x = (b*a^(-1))mod n
+def modular_division2(a, b, n):
+    """
+    >>> modular_division2(4,8,5)
+    2
+
+    >>> modular_division2(3,8,5)
+    1
+
+    >>> modular_division2(4, 11, 5)
+    4
+
+    """
+    s = invert_modulo(a, n)
+    x = (b * s) % n
+    return x
+
+
+# Extended Euclid's Algorithm : If d divides a and b and d = a*x + b*y for integers x and y, then d = gcd(a,b)
+
+def extended_gcd(a, b):
+    """
+    >>> extended_gcd(10, 6)
+    (2, -1, 2)
+
+    >>> extended_gcd(7, 5)
+    (1, -2, 3)
+
+   ** extended_gcd function is used when d = gcd(a,b) is required in output
+
+    """
+    assert a >= 0 and b >= 0
+
+    if b == 0:
+        d, x, y = a, 1, 0
+    else:
+        (d, p, q) = extended_gcd(b, a % b)
+        x = q
+        y = p - q * (a // b)
+
+    assert a % d == 0 and b % d == 0
+    assert d == a * x + b * y
+
+    return (d, x, y)
+
+
+# Extended Euclid
+def extended_euclid(a, b):
+    """
+    >>> extended_euclid(10, 6)
+    (-1, 2)
+
+    >>> extended_euclid(7, 5)
+    (-2, 3)
+
+    """
+    if b == 0:
+        return (1, 0)
+    (x, y) = extended_euclid(b, a % b)
+    k = a // b
+    return (y, x - k * y)
+
+
+# Euclid's Lemma :  d divides a and b, if and only if d divides a-b and b
+# Euclid's Algorithm
+
+def greatest_common_divisor(a, b):
+    """
+    >>> greatest_common_divisor(7,5)
+    1
+
+    Note : In number theory, two integers a and b are said to be relatively prime, mutually prime, or co-prime
+           if the only positive integer (factor) that divides both of them is 1  i.e., gcd(a,b) = 1.
+
+    >>> greatest_common_divisor(121, 11)
+    11
+
+    """
+    if a < b:
+        a, b = b, a
+
+    while a % b != 0:
+        a, b = b, a % b
+
+    return b
+
+
+# Import testmod for testing our function
+from doctest import testmod
+
+if __name__ == '__main__':
+    testmod(name='modular_division', verbose=True)
+    testmod(name='modular_division2', verbose=True)
+    testmod(name='invert_modulo', verbose=True)
+    testmod(name='extended_gcd', verbose=True)
+    testmod(name='extended_euclid', verbose=True)
+    testmod(name='greatest_common_divisor', verbose=True)

From 067a9b513628c8aa91fb1c74f44dfa5ee3ef6c1d Mon Sep 17 00:00:00 2001
From: mvhb <mvhb@cin.ufpe.br>
Date: Sun, 6 Oct 2019 15:55:55 -0300
Subject: [PATCH 242/348] adding input option and increasing the number of
 doctest (#1281)

* adding input option and incresing the number of doctest

* mixing positive and negative numbers in the same test case
---
 sorts/stooge_sort.py | 16 ++++++++++++----
 1 file changed, 12 insertions(+), 4 deletions(-)

diff --git a/sorts/stooge_sort.py b/sorts/stooge_sort.py
index 8cccd1e8c657..089b01a4def1 100644
--- a/sorts/stooge_sort.py
+++ b/sorts/stooge_sort.py
@@ -1,11 +1,14 @@
 def stooge_sort(arr):
     """
-    >>> arr = [2, 4, 5, 3, 1]
-    >>> stooge_sort(arr)
-    >>> print(arr)
-    [1, 2, 3, 4, 5]
+    Examples:
+    >>> stooge_sort([18.1, 0, -7.1, -1, 2, 2])
+    [-7.1, -1, 0, 2, 2, 18.1]
+
+    >>> stooge_sort([])
+    []
     """
     stooge(arr, 0, len(arr) - 1)
+    return arr
 
 
 def stooge(arr, i, h):
@@ -29,3 +32,8 @@ def stooge(arr, i, h):
 
         # Recursively sort first 2/3 elements
         stooge(arr, i, (h - t))
+
+if __name__ == "__main__":
+    user_input = input("Enter numbers separated by a comma:\n").strip()
+    unsorted = [int(item) for item in user_input.split(",")]
+    print(stooge_sort(unsorted))

From 01bc785e84c0f116898ac482d3ad95d2acf4af51 Mon Sep 17 00:00:00 2001
From: Anup Kumar Panwar <1anuppanwar@gmail.com>
Date: Mon, 7 Oct 2019 23:53:46 +0530
Subject: [PATCH 243/348] Fixed links in DIRECTORY.md (#1291)

---
 DIRECTORY.md | 818 +++++++++++++++++++++++++++------------------------
 1 file changed, 433 insertions(+), 385 deletions(-)

diff --git a/DIRECTORY.md b/DIRECTORY.md
index 248fe7b9eaa6..a4838d24dab7 100644
--- a/DIRECTORY.md
+++ b/DIRECTORY.md
@@ -1,411 +1,459 @@
 ## Arithmetic Analysis
-  * [bisection](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/bisection.py)
-  * [in static equilibrium](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/in_static_equilibrium.py)
-  * [intersection](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/intersection.py)
-  * [lu decomposition](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/lu_decomposition.py)
-  * [newton method](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/newton_method.py)
-  * [newton raphson method](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/newton_raphson_method.py)
+
+- [bisection](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/bisection.py)
+- [in static equilibrium](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/in_static_equilibrium.py)
+- [intersection](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/intersection.py)
+- [lu decomposition](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/lu_decomposition.py)
+- [newton method](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/newton_method.py)
+- [newton raphson method](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/newton_raphson_method.py)
+
 ## Backtracking
-  * [all combinations](https://github.com/TheAlgorithms/Python/blob/master/backtracking/all_combinations.py)
-  * [all permutations](https://github.com/TheAlgorithms/Python/blob/master/backtracking/all_permutations.py)
-  * [all subsequences](https://github.com/TheAlgorithms/Python/blob/master/backtracking/all_subsequences.py)
-  * [minimax](https://github.com/TheAlgorithms/Python/blob/master/backtracking/minimax.py)
-  * [n queens](https://github.com/TheAlgorithms/Python/blob/master/backtracking/n_queens.py)
-  * [sudoku](https://github.com/TheAlgorithms/Python/blob/master/backtracking/sudoku.py)
-  * [sum of subsets](https://github.com/TheAlgorithms/Python/blob/master/backtracking/sum_of_subsets.py)
+
+- [all combinations](https://github.com/TheAlgorithms/Python/blob/master/backtracking/all_combinations.py)
+- [all permutations](https://github.com/TheAlgorithms/Python/blob/master/backtracking/all_permutations.py)
+- [all subsequences](https://github.com/TheAlgorithms/Python/blob/master/backtracking/all_subsequences.py)
+- [minimax](https://github.com/TheAlgorithms/Python/blob/master/backtracking/minimax.py)
+- [n queens](https://github.com/TheAlgorithms/Python/blob/master/backtracking/n_queens.py)
+- [sudoku](https://github.com/TheAlgorithms/Python/blob/master/backtracking/sudoku.py)
+- [sum of subsets](https://github.com/TheAlgorithms/Python/blob/master/backtracking/sum_of_subsets.py)
+
 ## Boolean Algebra
-  * [quine mc cluskey](https://github.com/TheAlgorithms/Python/blob/master/boolean_algebra/quine_mc_cluskey.py)
+
+- [quine mc cluskey](https://github.com/TheAlgorithms/Python/blob/master/boolean_algebra/quine_mc_cluskey.py)
+
 ## Ciphers
-  * [affine cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/affine_cipher.py)
-  * [atbash](https://github.com/TheAlgorithms/Python/blob/master/ciphers/atbash.py)
-  * [base16](https://github.com/TheAlgorithms/Python/blob/master/ciphers/base16.py)
-  * [base32](https://github.com/TheAlgorithms/Python/blob/master/ciphers/base32.py)
-  * [base64 cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/base64_cipher.py)
-  * [base85](https://github.com/TheAlgorithms/Python/blob/master/ciphers/base85.py)
-  * [brute force caesar cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/brute_force_caesar_cipher.py)
-  * [caesar cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/caesar_cipher.py)
-  * [cryptomath module](https://github.com/TheAlgorithms/Python/blob/master/ciphers/cryptomath_module.py)
-  * [elgamal key generator](https://github.com/TheAlgorithms/Python/blob/master/ciphers/elgamal_key_generator.py)
-  * [hill cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/hill_cipher.py)
-  * [morse code implementation](https://github.com/TheAlgorithms/Python/blob/master/ciphers/morse_code_implementation.py)
-  * [onepad cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/onepad_cipher.py)
-  * [playfair cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/playfair_cipher.py)
-  * [rabin miller](https://github.com/TheAlgorithms/Python/blob/master/ciphers/rabin_miller.py)
-  * [rot13](https://github.com/TheAlgorithms/Python/blob/master/ciphers/rot13.py)
-  * [rsa cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/rsa_cipher.py)
-  * [rsa key generator](https://github.com/TheAlgorithms/Python/blob/master/ciphers/rsa_key_generator.py)
-  * [simple substitution cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/simple_substitution_cipher.py)
-  * [trafid cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/trafid_cipher.py)
-  * [transposition cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/transposition_cipher.py)
-  * [transposition cipher encrypt decrypt file](https://github.com/TheAlgorithms/Python/blob/master/ciphers/transposition_cipher_encrypt_decrypt_file.py)
-  * [vigenere cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/vigenere_cipher.py)
-  * [xor cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/xor_cipher.py)
+
+- [affine cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/affine_cipher.py)
+- [atbash](https://github.com/TheAlgorithms/Python/blob/master/ciphers/atbash.py)
+- [base16](https://github.com/TheAlgorithms/Python/blob/master/ciphers/base16.py)
+- [base32](https://github.com/TheAlgorithms/Python/blob/master/ciphers/base32.py)
+- [base64 cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/base64_cipher.py)
+- [base85](https://github.com/TheAlgorithms/Python/blob/master/ciphers/base85.py)
+- [brute force caesar cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/brute_force_caesar_cipher.py)
+- [caesar cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/caesar_cipher.py)
+- [cryptomath module](https://github.com/TheAlgorithms/Python/blob/master/ciphers/cryptomath_module.py)
+- [elgamal key generator](https://github.com/TheAlgorithms/Python/blob/master/ciphers/elgamal_key_generator.py)
+- [hill cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/hill_cipher.py)
+- [morse code implementation](https://github.com/TheAlgorithms/Python/blob/master/ciphers/morse_code_implementation.py)
+- [onepad cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/onepad_cipher.py)
+- [playfair cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/playfair_cipher.py)
+- [rabin miller](https://github.com/TheAlgorithms/Python/blob/master/ciphers/rabin_miller.py)
+- [rot13](https://github.com/TheAlgorithms/Python/blob/master/ciphers/rot13.py)
+- [rsa cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/rsa_cipher.py)
+- [rsa key generator](https://github.com/TheAlgorithms/Python/blob/master/ciphers/rsa_key_generator.py)
+- [simple substitution cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/simple_substitution_cipher.py)
+- [trafid cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/trafid_cipher.py)
+- [transposition cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/transposition_cipher.py)
+- [transposition cipher encrypt decrypt file](https://github.com/TheAlgorithms/Python/blob/master/ciphers/transposition_cipher_encrypt_decrypt_file.py)
+- [vigenere cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/vigenere_cipher.py)
+- [xor cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/xor_cipher.py)
+
 ## Compression
-  * [burrows wheeler](https://github.com/TheAlgorithms/Python/blob/master/compression/burrows_wheeler.py)
-  * [huffman](https://github.com/TheAlgorithms/Python/blob/master/compression/huffman.py)
-  * [peak signal to noise ratio](https://github.com/TheAlgorithms/Python/blob/master/compression/peak_signal_to_noise_ratio.py)
+
+- [burrows wheeler](https://github.com/TheAlgorithms/Python/blob/master/compression/burrows_wheeler.py)
+- [huffman](https://github.com/TheAlgorithms/Python/blob/master/compression/huffman.py)
+- [peak signal to noise ratio](https://github.com/TheAlgorithms/Python/blob/master/compression/peak_signal_to_noise_ratio.py)
+
 ## Conversions
-  * [decimal to binary](https://github.com/TheAlgorithms/Python/blob/master/conversions/decimal_to_binary.py)
-  * [decimal to hexadecimal](https://github.com/TheAlgorithms/Python/blob/master/conversions/decimal_to_hexadecimal.py)
-  * [decimal to octal](https://github.com/TheAlgorithms/Python/blob/master/conversions/decimal_to_octal.py)
+
+- [decimal to binary](https://github.com/TheAlgorithms/Python/blob/master/conversions/decimal_to_binary.py)
+- [decimal to hexadecimal](https://github.com/TheAlgorithms/Python/blob/master/conversions/decimal_to_hexadecimal.py)
+- [decimal to octal](https://github.com/TheAlgorithms/Python/blob/master/conversions/decimal_to_octal.py)
+
 ## Data Structures
-  * Binary Tree
-    * [avl tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/avl_tree.py)
-    * [basic binary tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/basic_binary_tree.py)
-    * [binary search tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_search_tree.py)
-    * [fenwick tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/fenwick_tree.py)
-    * [lazy segment tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/lazy_segment_tree.py)
-    * [lca](https://github.com/TheAlgorithms/Python/blob/master/data_structures/lca.py)
-    * [red black tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/red_black_tree.py)
-    * [segment tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/segment_tree.py)
-    * [treap](https://github.com/TheAlgorithms/Python/blob/master/data_structures/treap.py)
-  * Hashing
-    * [double hash](https://github.com/TheAlgorithms/Python/blob/master/data_structures/double_hash.py)
-    * [hash table](https://github.com/TheAlgorithms/Python/blob/master/data_structures/hash_table.py)
-    * [hash table with linked list](https://github.com/TheAlgorithms/Python/blob/master/data_structures/hash_table_with_linked_list.py)
-  * Number Theory
-    * [prime numbers](https://github.com/TheAlgorithms/Python/blob/master/data_structures/prime_numbers.py)
-    * [quadratic probing](https://github.com/TheAlgorithms/Python/blob/master/data_structures/quadratic_probing.py)
-  * Heap
-    * [heap](https://github.com/TheAlgorithms/Python/blob/master/data_structures/heap.py)
-  * Linked List
-    * [doubly linked list](https://github.com/TheAlgorithms/Python/blob/master/data_structures/doubly_linked_list.py)
-    * [is palindrome](https://github.com/TheAlgorithms/Python/blob/master/data_structures/is_palindrome.py)
-    * [singly linked list](https://github.com/TheAlgorithms/Python/blob/master/data_structures/singly_linked_list.py)
-    * [swap nodes](https://github.com/TheAlgorithms/Python/blob/master/data_structures/swap_nodes.py)
-  * Queue
-    * [double ended queue](https://github.com/TheAlgorithms/Python/blob/master/data_structures/double_ended_queue.py)
-    * [queue on list](https://github.com/TheAlgorithms/Python/blob/master/data_structures/queue_on_list.py)
-    * [queue on pseudo stack](https://github.com/TheAlgorithms/Python/blob/master/data_structures/queue_on_pseudo_stack.py)
-  * Stacks
-    * [balanced parentheses](https://github.com/TheAlgorithms/Python/blob/master/data_structures/balanced_parentheses.py)
-    * [infix to postfix conversion](https://github.com/TheAlgorithms/Python/blob/master/data_structures/infix_to_postfix_conversion.py)
-    * [infix to prefix conversion](https://github.com/TheAlgorithms/Python/blob/master/data_structures/infix_to_prefix_conversion.py)
-    * [next greater element](https://github.com/TheAlgorithms/Python/blob/master/data_structures/next_greater_element.py)
-    * [postfix evaluation](https://github.com/TheAlgorithms/Python/blob/master/data_structures/postfix_evaluation.py)
-    * [stack](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stack.py)
-    * [stock span problem](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stock_span_problem.py)
-  * Trie
-    * [trie](https://github.com/TheAlgorithms/Python/blob/master/data_structures/trie.py)
+
+- Binary Tree
+  - [avl tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/avl_tree.py)
+  - [basic binary tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/basic_binary_tree.py)
+  - [binary search tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/binary_search_tree.py)
+  - [fenwick tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/fenwick_tree.py)
+  - [lazy segment tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/lazy_segment_tree.py)
+  - [lca](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/lca.py)
+  - [red black tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/red_black_tree.py)
+  - [segment tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/segment_tree.py)
+  - [treap](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/treap.py)
+- Hashing
+  - [double hash](https://github.com/TheAlgorithms/Python/blob/master/data_structures/hashing/double_hash.py)
+  - [hash table](https://github.com/TheAlgorithms/Python/blob/master/data_structures/hashing/hash_table.py)
+  - [hash table with linked list](https://github.com/TheAlgorithms/Python/blob/master/data_structures/hashing/hash_table_with_linked_list.py)
+- Number Theory
+  - [prime numbers](https://github.com/TheAlgorithms/Python/blob/master/data_structures/number_theory/prime_numbers.py)
+  - [quadratic probing](https://github.com/TheAlgorithms/Python/blob/master/data_structures/number_theory/quadratic_probing.py)
+- Heap
+  - [heap](https://github.com/TheAlgorithms/Python/blob/master/data_structures/heap/heap.py)
+- Linked List
+  - [doubly linked list](https://github.com/TheAlgorithms/Python/blob/master/data_structures/linked_list/doubly_linked_list.py)
+  - [is palindrome](https://github.com/TheAlgorithms/Python/blob/master/data_structures/linked_list/is_palindrome.py)
+  - [singly linked list](https://github.com/TheAlgorithms/Python/blob/master/data_structures/linked_list/singly_linked_list.py)
+  - [swap nodes](https://github.com/TheAlgorithms/Python/blob/master/data_structures/linked_list/swap_nodes.py)
+- Queue
+  - [double ended queue](https://github.com/TheAlgorithms/Python/blob/master/data_structures/queue/double_ended_queue.py)
+  - [queue on list](https://github.com/TheAlgorithms/Python/blob/master/data_structures/queue/queue_on_list.py)
+  - [queue on pseudo stack](https://github.com/TheAlgorithms/Python/blob/master/data_structures/queue/queue_on_pseudo_stack.py)
+- Stacks
+  - [balanced parentheses](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stacks/balanced_parentheses.py)
+  - [infix to postfix conversion](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stacks/infix_to_postfix_conversion.py)
+  - [infix to prefix conversion](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stacks/infix_to_prefix_conversion.py)
+  - [next greater element](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stacks/next_greater_element.py)
+  - [postfix evaluation](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stacks/postfix_evaluation.py)
+  - [stack](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stacks/stack.py)
+  - [stock span problem](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stacks/stock_span_problem.py)
+- Trie
+  - [trie](https://github.com/TheAlgorithms/Python/blob/master/data_structures/trie/trie.py)
+
 ## Digital Image Processing
-    * [change contrast](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/change_contrast.py)
-  * Edge Detection
-    * [canny](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/canny.py)
-  * Filters
-    * [convolve](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/convolve.py)
-    * [gaussian filter](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/gaussian_filter.py)
-    * [median filter](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/median_filter.py)
-    * [sobel filter](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/sobel_filter.py)
-    * [test digital image processing](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/test_digital_image_processing.py)
+
+- [change contrast](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/change_contrast.py)
+- Edge Detection
+  - [canny](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/edge_detection/canny.py)
+- Filters
+  - [convolve](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/filters/convolve.py)
+  - [gaussian filter](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/filters/gaussian_filter.py)
+  - [median filter](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/filters/median_filter.py)
+  - [sobel filter](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/filters/sobel_filter.py)
+- [test digital image processing](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/test_digital_image_processing.py)
+
 ## Divide And Conquer
-  * [closest pair of points](https://github.com/TheAlgorithms/Python/blob/master/divide_and_conquer/closest_pair_of_points.py)
-  * [convex hull](https://github.com/TheAlgorithms/Python/blob/master/divide_and_conquer/convex_hull.py)
-  * [inversions](https://github.com/TheAlgorithms/Python/blob/master/divide_and_conquer/inversions.py)
-  * [max subarray sum](https://github.com/TheAlgorithms/Python/blob/master/divide_and_conquer/max_subarray_sum.py)
+
+- [closest pair of points](https://github.com/TheAlgorithms/Python/blob/master/divide_and_conquer/closest_pair_of_points.py)
+- [convex hull](https://github.com/TheAlgorithms/Python/blob/master/divide_and_conquer/convex_hull.py)
+- [inversions](https://github.com/TheAlgorithms/Python/blob/master/divide_and_conquer/inversions.py)
+- [max subarray sum](https://github.com/TheAlgorithms/Python/blob/master/divide_and_conquer/max_subarray_sum.py)
+
 ## Dynamic Programming
-  * [abbreviation](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/abbreviation.py)
-  * [bitmask](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/bitmask.py)
-  * [climbing stairs](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/climbing_stairs.py)
-  * [coin change](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/coin_change.py)
-  * [edit distance](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/edit_distance.py)
-  * [factorial](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/factorial.py)
-  * [fast fibonacci](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/fast_fibonacci.py)
-  * [fibonacci](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/fibonacci.py)
-  * [floyd warshall](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/floyd_warshall.py)
-  * [fractional knapsack](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/fractional_knapsack.py)
-  * [integer partition](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/integer_partition.py)
-  * [k means clustering tensorflow](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/k_means_clustering_tensorflow.py)
-  * [knapsack](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/knapsack.py)
-  * [longest common subsequence](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/longest_common_subsequence.py)
-  * [longest increasing subsequence](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/longest_increasing_subsequence.py)
-  * [longest increasing subsequence o(nlogn)](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/longest_increasing_subsequence_o(nlogn).py)
-  * [longest sub array](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/longest_sub_array.py)
-  * [matrix chain order](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/matrix_chain_order.py)
-  * [max sub array](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/max_sub_array.py)
-  * [minimum partition](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/minimum_partition.py)
-  * [rod cutting](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/rod_cutting.py)
-  * [subset generation](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/subset_generation.py)
-  * [sum of subset](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/sum_of_subset.py)
+
+- [abbreviation](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/abbreviation.py)
+- [bitmask](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/bitmask.py)
+- [climbing stairs](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/climbing_stairs.py)
+- [coin change](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/coin_change.py)
+- [edit distance](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/edit_distance.py)
+- [factorial](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/factorial.py)
+- [fast fibonacci](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/fast_fibonacci.py)
+- [fibonacci](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/fibonacci.py)
+- [floyd warshall](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/floyd_warshall.py)
+- [fractional knapsack](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/fractional_knapsack.py)
+- [integer partition](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/integer_partition.py)
+- [k means clustering tensorflow](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/k_means_clustering_tensorflow.py)
+- [knapsack](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/knapsack.py)
+- [longest common subsequence](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/longest_common_subsequence.py)
+- [longest increasing subsequence](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/longest_increasing_subsequence.py)
+- [longest increasing subsequence o(nlogn)](<https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/longest_increasing_subsequence_o(nlogn).py>)
+- [longest sub array](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/longest_sub_array.py)
+- [matrix chain order](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/matrix_chain_order.py)
+- [max sub array](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/max_sub_array.py)
+- [minimum partition](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/minimum_partition.py)
+- [rod cutting](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/rod_cutting.py)
+- [subset generation](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/subset_generation.py)
+- [sum of subset](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/sum_of_subset.py)
+
 ## File Transfer
-  * [recieve file](https://github.com/TheAlgorithms/Python/blob/master/file_transfer/recieve_file.py)
-  * [send file](https://github.com/TheAlgorithms/Python/blob/master/file_transfer/send_file.py)
+
+- [recieve file](https://github.com/TheAlgorithms/Python/blob/master/file_transfer/recieve_file.py)
+- [send file](https://github.com/TheAlgorithms/Python/blob/master/file_transfer/send_file.py)
+
 ## Graphs
-  * [a star](https://github.com/TheAlgorithms/Python/blob/master/graphs/a_star.py)
-  * [articulation points](https://github.com/TheAlgorithms/Python/blob/master/graphs/articulation_points.py)
-  * [basic graphs](https://github.com/TheAlgorithms/Python/blob/master/graphs/basic_graphs.py)
-  * [bellman ford](https://github.com/TheAlgorithms/Python/blob/master/graphs/bellman_ford.py)
-  * [bfs](https://github.com/TheAlgorithms/Python/blob/master/graphs/bfs.py)
-  * [bfs shortest path](https://github.com/TheAlgorithms/Python/blob/master/graphs/bfs_shortest_path.py)
-  * [breadth first search](https://github.com/TheAlgorithms/Python/blob/master/graphs/breadth_first_search.py)
-  * [check bipartite graph bfs](https://github.com/TheAlgorithms/Python/blob/master/graphs/check_bipartite_graph_bfs.py)
-  * [check bipartite graph dfs](https://github.com/TheAlgorithms/Python/blob/master/graphs/check_bipartite_graph_dfs.py)
-  * [depth first search](https://github.com/TheAlgorithms/Python/blob/master/graphs/depth_first_search.py)
-  * [dfs](https://github.com/TheAlgorithms/Python/blob/master/graphs/dfs.py)
-  * [dijkstra](https://github.com/TheAlgorithms/Python/blob/master/graphs/dijkstra.py)
-  * [dijkstra 2](https://github.com/TheAlgorithms/Python/blob/master/graphs/dijkstra_2.py)
-  * [dijkstra algorithm](https://github.com/TheAlgorithms/Python/blob/master/graphs/dijkstra_algorithm.py)
-  * [directed and undirected (weighted) graph](https://github.com/TheAlgorithms/Python/blob/master/graphs/directed_and_undirected_(weighted)_graph.py)
-  * [edmonds karp multiple source and sink](https://github.com/TheAlgorithms/Python/blob/master/graphs/edmonds_karp_multiple_source_and_sink.py)
-  * [eulerian path and circuit for undirected graph](https://github.com/TheAlgorithms/Python/blob/master/graphs/eulerian_path_and_circuit_for_undirected_graph.py)
-  * [even tree](https://github.com/TheAlgorithms/Python/blob/master/graphs/even_tree.py)
-  * [finding bridges](https://github.com/TheAlgorithms/Python/blob/master/graphs/finding_bridges.py)
-  * [graph list](https://github.com/TheAlgorithms/Python/blob/master/graphs/graph_list.py)
-  * [graph matrix](https://github.com/TheAlgorithms/Python/blob/master/graphs/graph_matrix.py)
-  * [graphs floyd warshall](https://github.com/TheAlgorithms/Python/blob/master/graphs/graphs_floyd_warshall.py)
-  * [kahns algorithm long](https://github.com/TheAlgorithms/Python/blob/master/graphs/kahns_algorithm_long.py)
-  * [kahns algorithm topo](https://github.com/TheAlgorithms/Python/blob/master/graphs/kahns_algorithm_topo.py)
-  * [minimum spanning tree kruskal](https://github.com/TheAlgorithms/Python/blob/master/graphs/minimum_spanning_tree_kruskal.py)
-  * [minimum spanning tree prims](https://github.com/TheAlgorithms/Python/blob/master/graphs/minimum_spanning_tree_prims.py)
-  * [multi hueristic astar](https://github.com/TheAlgorithms/Python/blob/master/graphs/multi_hueristic_astar.py)
-  * [page rank](https://github.com/TheAlgorithms/Python/blob/master/graphs/page_rank.py)
-  * [prim](https://github.com/TheAlgorithms/Python/blob/master/graphs/prim.py)
-  * [scc kosaraju](https://github.com/TheAlgorithms/Python/blob/master/graphs/scc_kosaraju.py)
-  * [tarjans scc](https://github.com/TheAlgorithms/Python/blob/master/graphs/tarjans_scc.py)
+
+- [a star](https://github.com/TheAlgorithms/Python/blob/master/graphs/a_star.py)
+- [articulation points](https://github.com/TheAlgorithms/Python/blob/master/graphs/articulation_points.py)
+- [basic graphs](https://github.com/TheAlgorithms/Python/blob/master/graphs/basic_graphs.py)
+- [bellman ford](https://github.com/TheAlgorithms/Python/blob/master/graphs/bellman_ford.py)
+- [bfs](https://github.com/TheAlgorithms/Python/blob/master/graphs/bfs.py)
+- [bfs shortest path](https://github.com/TheAlgorithms/Python/blob/master/graphs/bfs_shortest_path.py)
+- [breadth first search](https://github.com/TheAlgorithms/Python/blob/master/graphs/breadth_first_search.py)
+- [check bipartite graph bfs](https://github.com/TheAlgorithms/Python/blob/master/graphs/check_bipartite_graph_bfs.py)
+- [check bipartite graph dfs](https://github.com/TheAlgorithms/Python/blob/master/graphs/check_bipartite_graph_dfs.py)
+- [depth first search](https://github.com/TheAlgorithms/Python/blob/master/graphs/depth_first_search.py)
+- [dfs](https://github.com/TheAlgorithms/Python/blob/master/graphs/dfs.py)
+- [dijkstra](https://github.com/TheAlgorithms/Python/blob/master/graphs/dijkstra.py)
+- [dijkstra 2](https://github.com/TheAlgorithms/Python/blob/master/graphs/dijkstra_2.py)
+- [dijkstra algorithm](https://github.com/TheAlgorithms/Python/blob/master/graphs/dijkstra_algorithm.py)
+- [directed and undirected (weighted) graph](<https://github.com/TheAlgorithms/Python/blob/master/graphs/directed_and_undirected_(weighted)_graph.py>)
+- [edmonds karp multiple source and sink](https://github.com/TheAlgorithms/Python/blob/master/graphs/edmonds_karp_multiple_source_and_sink.py)
+- [eulerian path and circuit for undirected graph](https://github.com/TheAlgorithms/Python/blob/master/graphs/eulerian_path_and_circuit_for_undirected_graph.py)
+- [even tree](https://github.com/TheAlgorithms/Python/blob/master/graphs/even_tree.py)
+- [finding bridges](https://github.com/TheAlgorithms/Python/blob/master/graphs/finding_bridges.py)
+- [graph list](https://github.com/TheAlgorithms/Python/blob/master/graphs/graph_list.py)
+- [graph matrix](https://github.com/TheAlgorithms/Python/blob/master/graphs/graph_matrix.py)
+- [graphs floyd warshall](https://github.com/TheAlgorithms/Python/blob/master/graphs/graphs_floyd_warshall.py)
+- [kahns algorithm long](https://github.com/TheAlgorithms/Python/blob/master/graphs/kahns_algorithm_long.py)
+- [kahns algorithm topo](https://github.com/TheAlgorithms/Python/blob/master/graphs/kahns_algorithm_topo.py)
+- [minimum spanning tree kruskal](https://github.com/TheAlgorithms/Python/blob/master/graphs/minimum_spanning_tree_kruskal.py)
+- [minimum spanning tree prims](https://github.com/TheAlgorithms/Python/blob/master/graphs/minimum_spanning_tree_prims.py)
+- [multi hueristic astar](https://github.com/TheAlgorithms/Python/blob/master/graphs/multi_hueristic_astar.py)
+- [page rank](https://github.com/TheAlgorithms/Python/blob/master/graphs/page_rank.py)
+- [prim](https://github.com/TheAlgorithms/Python/blob/master/graphs/prim.py)
+- [scc kosaraju](https://github.com/TheAlgorithms/Python/blob/master/graphs/scc_kosaraju.py)
+- [tarjans scc](https://github.com/TheAlgorithms/Python/blob/master/graphs/tarjans_scc.py)
+
 ## Hashes
-  * [chaos machine](https://github.com/TheAlgorithms/Python/blob/master/hashes/chaos_machine.py)
-  * [enigma machine](https://github.com/TheAlgorithms/Python/blob/master/hashes/enigma_machine.py)
-  * [md5](https://github.com/TheAlgorithms/Python/blob/master/hashes/md5.py)
-  * [sha1](https://github.com/TheAlgorithms/Python/blob/master/hashes/sha1.py)
+
+- [chaos machine](https://github.com/TheAlgorithms/Python/blob/master/hashes/chaos_machine.py)
+- [enigma machine](https://github.com/TheAlgorithms/Python/blob/master/hashes/enigma_machine.py)
+- [md5](https://github.com/TheAlgorithms/Python/blob/master/hashes/md5.py)
+- [sha1](https://github.com/TheAlgorithms/Python/blob/master/hashes/sha1.py)
+
 ## Linear Algebra
-  * Src
-    * [lib](https://github.com/TheAlgorithms/Python/blob/master/linear_algebra/lib.py)
-    * [polynom-for-points](https://github.com/TheAlgorithms/Python/blob/master/linear_algebra/polynom-for-points.py)
-    * [tests](https://github.com/TheAlgorithms/Python/blob/master/linear_algebra/tests.py)
+
+- Src
+  - [lib](https://github.com/TheAlgorithms/Python/blob/master/linear_algebra/src/lib.py)
+  - [polynom-for-points](https://github.com/TheAlgorithms/Python/blob/master/linear_algebra/src/polynom-for-points.py)
+  - [tests](https://github.com/TheAlgorithms/Python/blob/master/linear_algebra/src/tests.py)
+
 ## Machine Learning
-  * [decision tree](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/decision_tree.py)
-  * [gradient descent](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/gradient_descent.py)
-  * [k means clust](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/k_means_clust.py)
-  * [knn sklearn](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/knn_sklearn.py)
-  * [linear regression](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/linear_regression.py)
-  * [logistic regression](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/logistic_regression.py)
-  * [naive bayes](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/naive_bayes.ipynb)
-  * Random Forest Classification
-    * [random forest classification](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/random_forest_classification.py)
-    * [random forest classifier](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/random_forest_classifier.ipynb)
-  * Random Forest Regression
-    * [random forest regression](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/random_forest_regression.ipynb)
-    * [random forest regression](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/random_forest_regression.py)
-  * [reuters one vs rest classifier](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/reuters_one_vs_rest_classifier.ipynb)
-  * [scoring functions](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/scoring_functions.py)
-  * [sorted vector machines](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/sorted_vector_machines.py)
+
+- [decision tree](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/decision_tree.py)
+- [gradient descent](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/gradient_descent.py)
+- [k means clust](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/k_means_clust.py)
+- [knn sklearn](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/knn_sklearn.py)
+- [linear regression](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/linear_regression.py)
+- [logistic regression](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/logistic_regression.py)
+- [naive bayes](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/naive_bayes.ipynb)
+- Random Forest Classification
+  - [random forest classification](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/random_forest_classification/random_forest_classification.py)
+  - [random forest classifier](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/random_forest_classification/random_forest_classifier.ipynb)
+- Random Forest Regression
+  - [random forest regression](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/random_forest_regression/random_forest_regression.ipynb)
+  - [random forest regression](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/random_forest_regression/random_forest_regression.py)
+- [reuters one vs rest classifier](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/reuters_one_vs_rest_classifier.ipynb)
+- [scoring functions](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/scoring_functions.py)
+- [sorted vector machines](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/sorted_vector_machines.py)
+
 ## Maths
-  * [3n+1](https://github.com/TheAlgorithms/Python/blob/master/maths/3n+1.py)
-  * [abs](https://github.com/TheAlgorithms/Python/blob/master/maths/abs.py)
-  * [abs max](https://github.com/TheAlgorithms/Python/blob/master/maths/abs_max.py)
-  * [abs min](https://github.com/TheAlgorithms/Python/blob/master/maths/abs_min.py)
-  * [average mean](https://github.com/TheAlgorithms/Python/blob/master/maths/average_mean.py)
-  * [average median](https://github.com/TheAlgorithms/Python/blob/master/maths/average_median.py)
-  * [basic maths](https://github.com/TheAlgorithms/Python/blob/master/maths/basic_maths.py)
-  * [binary exponentiation](https://github.com/TheAlgorithms/Python/blob/master/maths/binary_exponentiation.py)
-  * [collatz sequence](https://github.com/TheAlgorithms/Python/blob/master/maths/collatz_sequence.py)
-  * [extended euclidean algorithm](https://github.com/TheAlgorithms/Python/blob/master/maths/extended_euclidean_algorithm.py)
-  * [factorial python](https://github.com/TheAlgorithms/Python/blob/master/maths/factorial_python.py)
-  * [factorial recursive](https://github.com/TheAlgorithms/Python/blob/master/maths/factorial_recursive.py)
-  * [fermat little theorem](https://github.com/TheAlgorithms/Python/blob/master/maths/fermat_little_theorem.py)
-  * [fibonacci](https://github.com/TheAlgorithms/Python/blob/master/maths/fibonacci.py)
-  * [fibonacci sequence recursion](https://github.com/TheAlgorithms/Python/blob/master/maths/fibonacci_sequence_recursion.py)
-  * [find lcm](https://github.com/TheAlgorithms/Python/blob/master/maths/find_lcm.py)
-  * [find max](https://github.com/TheAlgorithms/Python/blob/master/maths/find_max.py)
-  * [find min](https://github.com/TheAlgorithms/Python/blob/master/maths/find_min.py)
-  * [gaussian](https://github.com/TheAlgorithms/Python/blob/master/maths/gaussian.py)
-  * [greater common divisor](https://github.com/TheAlgorithms/Python/blob/master/maths/greater_common_divisor.py)
-  * [is square free](https://github.com/TheAlgorithms/Python/blob/master/maths/is_square_free.py)
-  * [largest of very large numbers](https://github.com/TheAlgorithms/Python/blob/master/maths/largest_of_very_large_numbers.py)
-  * [lucas lehmer primality test](https://github.com/TheAlgorithms/Python/blob/master/maths/lucas_lehmer_primality_test.py)
-  * [lucas series](https://github.com/TheAlgorithms/Python/blob/master/maths/lucas_series.py)
-  * [mobius function](https://github.com/TheAlgorithms/Python/blob/master/maths/mobius_function.py)
-  * [modular exponential](https://github.com/TheAlgorithms/Python/blob/master/maths/modular_exponential.py)
-  * [newton raphson](https://github.com/TheAlgorithms/Python/blob/master/maths/newton_raphson.py)
-  * [prime check](https://github.com/TheAlgorithms/Python/blob/master/maths/prime_check.py)
-  * [prime factors](https://github.com/TheAlgorithms/Python/blob/master/maths/prime_factors.py)
-  * [quadratic equations complex numbers](https://github.com/TheAlgorithms/Python/blob/master/maths/quadratic_equations_complex_numbers.py)
-  * [segmented sieve](https://github.com/TheAlgorithms/Python/blob/master/maths/segmented_sieve.py)
-  * [sieve of eratosthenes](https://github.com/TheAlgorithms/Python/blob/master/maths/sieve_of_eratosthenes.py)
-  * [simpson rule](https://github.com/TheAlgorithms/Python/blob/master/maths/simpson_rule.py)
-  * [test prime check](https://github.com/TheAlgorithms/Python/blob/master/maths/test_prime_check.py)
-  * [trapezoidal rule](https://github.com/TheAlgorithms/Python/blob/master/maths/trapezoidal_rule.py)
-  * [volume](https://github.com/TheAlgorithms/Python/blob/master/maths/volume.py)
-  * [zellers congruence](https://github.com/TheAlgorithms/Python/blob/master/maths/zellers_congruence.py)
+
+- [3n+1](https://github.com/TheAlgorithms/Python/blob/master/maths/3n+1.py)
+- [abs](https://github.com/TheAlgorithms/Python/blob/master/maths/abs.py)
+- [abs max](https://github.com/TheAlgorithms/Python/blob/master/maths/abs_max.py)
+- [abs min](https://github.com/TheAlgorithms/Python/blob/master/maths/abs_min.py)
+- [average mean](https://github.com/TheAlgorithms/Python/blob/master/maths/average_mean.py)
+- [average median](https://github.com/TheAlgorithms/Python/blob/master/maths/average_median.py)
+- [basic maths](https://github.com/TheAlgorithms/Python/blob/master/maths/basic_maths.py)
+- [binary exponentiation](https://github.com/TheAlgorithms/Python/blob/master/maths/binary_exponentiation.py)
+- [collatz sequence](https://github.com/TheAlgorithms/Python/blob/master/maths/collatz_sequence.py)
+- [extended euclidean algorithm](https://github.com/TheAlgorithms/Python/blob/master/maths/extended_euclidean_algorithm.py)
+- [factorial python](https://github.com/TheAlgorithms/Python/blob/master/maths/factorial_python.py)
+- [factorial recursive](https://github.com/TheAlgorithms/Python/blob/master/maths/factorial_recursive.py)
+- [fermat little theorem](https://github.com/TheAlgorithms/Python/blob/master/maths/fermat_little_theorem.py)
+- [fibonacci](https://github.com/TheAlgorithms/Python/blob/master/maths/fibonacci.py)
+- [fibonacci sequence recursion](https://github.com/TheAlgorithms/Python/blob/master/maths/fibonacci_sequence_recursion.py)
+- [find lcm](https://github.com/TheAlgorithms/Python/blob/master/maths/find_lcm.py)
+- [find max](https://github.com/TheAlgorithms/Python/blob/master/maths/find_max.py)
+- [find min](https://github.com/TheAlgorithms/Python/blob/master/maths/find_min.py)
+- [gaussian](https://github.com/TheAlgorithms/Python/blob/master/maths/gaussian.py)
+- [greater common divisor](https://github.com/TheAlgorithms/Python/blob/master/maths/greater_common_divisor.py)
+- [is square free](https://github.com/TheAlgorithms/Python/blob/master/maths/is_square_free.py)
+- [largest of very large numbers](https://github.com/TheAlgorithms/Python/blob/master/maths/largest_of_very_large_numbers.py)
+- [lucas lehmer primality test](https://github.com/TheAlgorithms/Python/blob/master/maths/lucas_lehmer_primality_test.py)
+- [lucas series](https://github.com/TheAlgorithms/Python/blob/master/maths/lucas_series.py)
+- [mobius function](https://github.com/TheAlgorithms/Python/blob/master/maths/mobius_function.py)
+- [modular exponential](https://github.com/TheAlgorithms/Python/blob/master/maths/modular_exponential.py)
+- [newton raphson](https://github.com/TheAlgorithms/Python/blob/master/maths/newton_raphson.py)
+- [prime check](https://github.com/TheAlgorithms/Python/blob/master/maths/prime_check.py)
+- [prime factors](https://github.com/TheAlgorithms/Python/blob/master/maths/prime_factors.py)
+- [quadratic equations complex numbers](https://github.com/TheAlgorithms/Python/blob/master/maths/quadratic_equations_complex_numbers.py)
+- [segmented sieve](https://github.com/TheAlgorithms/Python/blob/master/maths/segmented_sieve.py)
+- [sieve of eratosthenes](https://github.com/TheAlgorithms/Python/blob/master/maths/sieve_of_eratosthenes.py)
+- [simpson rule](https://github.com/TheAlgorithms/Python/blob/master/maths/simpson_rule.py)
+- [test prime check](https://github.com/TheAlgorithms/Python/blob/master/maths/test_prime_check.py)
+- [trapezoidal rule](https://github.com/TheAlgorithms/Python/blob/master/maths/trapezoidal_rule.py)
+- [volume](https://github.com/TheAlgorithms/Python/blob/master/maths/volume.py)
+- [zellers congruence](https://github.com/TheAlgorithms/Python/blob/master/maths/zellers_congruence.py)
+
 ## Matrix
-  * [matrix operation](https://github.com/TheAlgorithms/Python/blob/master/matrix/matrix_operation.py)
-  * [nth fibonacci using matrix exponentiation](https://github.com/TheAlgorithms/Python/blob/master/matrix/nth_fibonacci_using_matrix_exponentiation.py)
-  * [rotate matrix](https://github.com/TheAlgorithms/Python/blob/master/matrix/rotate_matrix.py)
-  * [searching in sorted matrix](https://github.com/TheAlgorithms/Python/blob/master/matrix/searching_in_sorted_matrix.py)
-  * [spiral print](https://github.com/TheAlgorithms/Python/blob/master/matrix/spiral_print.py)
-  * Tests
-    * [test matrix operation](https://github.com/TheAlgorithms/Python/blob/master/matrix/test_matrix_operation.py)
+
+- [matrix operation](https://github.com/TheAlgorithms/Python/blob/master/matrix/matrix_operation.py)
+- [nth fibonacci using matrix exponentiation](https://github.com/TheAlgorithms/Python/blob/master/matrix/nth_fibonacci_using_matrix_exponentiation.py)
+- [rotate matrix](https://github.com/TheAlgorithms/Python/blob/master/matrix/rotate_matrix.py)
+- [searching in sorted matrix](https://github.com/TheAlgorithms/Python/blob/master/matrix/searching_in_sorted_matrix.py)
+- [spiral print](https://github.com/TheAlgorithms/Python/blob/master/matrix/spiral_print.py)
+- Tests
+  - [test matrix operation](https://github.com/TheAlgorithms/Python/blob/master/matrix/tests/test_matrix_operation.py)
+
 ## Networking Flow
-  * [ford fulkerson](https://github.com/TheAlgorithms/Python/blob/master/networking_flow/ford_fulkerson.py)
-  * [minimum cut](https://github.com/TheAlgorithms/Python/blob/master/networking_flow/minimum_cut.py)
+
+- [ford fulkerson](https://github.com/TheAlgorithms/Python/blob/master/networking_flow/ford_fulkerson.py)
+- [minimum cut](https://github.com/TheAlgorithms/Python/blob/master/networking_flow/minimum_cut.py)
+
 ## Neural Network
-  * [back propagation neural network](https://github.com/TheAlgorithms/Python/blob/master/neural_network/back_propagation_neural_network.py)
-  * [convolution neural network](https://github.com/TheAlgorithms/Python/blob/master/neural_network/convolution_neural_network.py)
-  * [fully connected neural network](https://github.com/TheAlgorithms/Python/blob/master/neural_network/fully_connected_neural_network.ipynb)
-  * [perceptron](https://github.com/TheAlgorithms/Python/blob/master/neural_network/perceptron.py)
+
+- [back propagation neural network](https://github.com/TheAlgorithms/Python/blob/master/neural_network/back_propagation_neural_network.py)
+- [convolution neural network](https://github.com/TheAlgorithms/Python/blob/master/neural_network/convolution_neural_network.py)
+- [fully connected neural network](https://github.com/TheAlgorithms/Python/blob/master/neural_network/fully_connected_neural_network.ipynb)
+- [perceptron](https://github.com/TheAlgorithms/Python/blob/master/neural_network/perceptron.py)
+
 ## Other
-  * [anagrams](https://github.com/TheAlgorithms/Python/blob/master/other/anagrams.py)
-  * [binary exponentiation](https://github.com/TheAlgorithms/Python/blob/master/other/binary_exponentiation.py)
-  * [binary exponentiation 2](https://github.com/TheAlgorithms/Python/blob/master/other/binary_exponentiation_2.py)
-  * [detecting english programmatically](https://github.com/TheAlgorithms/Python/blob/master/other/detecting_english_programmatically.py)
-  * [euclidean gcd](https://github.com/TheAlgorithms/Python/blob/master/other/euclidean_gcd.py)
-  * [fischer yates shuffle](https://github.com/TheAlgorithms/Python/blob/master/other/fischer_yates_shuffle.py)
-  * [food wastage analysis from 1961-2013 fao](https://github.com/TheAlgorithms/Python/blob/master/other/food_wastage_analysis_from_1961-2013_fao.ipynb)
-  * [frequency finder](https://github.com/TheAlgorithms/Python/blob/master/other/frequency_finder.py)
-  * [game of life](https://github.com/TheAlgorithms/Python/blob/master/other/game_of_life.py)
-  * [linear congruential generator](https://github.com/TheAlgorithms/Python/blob/master/other/linear_congruential_generator.py)
-  * [nested brackets](https://github.com/TheAlgorithms/Python/blob/master/other/nested_brackets.py)
-  * [palindrome](https://github.com/TheAlgorithms/Python/blob/master/other/palindrome.py)
-  * [password generator](https://github.com/TheAlgorithms/Python/blob/master/other/password_generator.py)
-  * [primelib](https://github.com/TheAlgorithms/Python/blob/master/other/primelib.py)
-  * [sierpinski triangle](https://github.com/TheAlgorithms/Python/blob/master/other/sierpinski_triangle.py)
-  * [tower of hanoi](https://github.com/TheAlgorithms/Python/blob/master/other/tower_of_hanoi.py)
-  * [two sum](https://github.com/TheAlgorithms/Python/blob/master/other/two_sum.py)
-  * [word patterns](https://github.com/TheAlgorithms/Python/blob/master/other/word_patterns.py)
+
+- [anagrams](https://github.com/TheAlgorithms/Python/blob/master/other/anagrams.py)
+- [binary exponentiation](https://github.com/TheAlgorithms/Python/blob/master/other/binary_exponentiation.py)
+- [binary exponentiation 2](https://github.com/TheAlgorithms/Python/blob/master/other/binary_exponentiation_2.py)
+- [detecting english programmatically](https://github.com/TheAlgorithms/Python/blob/master/other/detecting_english_programmatically.py)
+- [euclidean gcd](https://github.com/TheAlgorithms/Python/blob/master/other/euclidean_gcd.py)
+- [fischer yates shuffle](https://github.com/TheAlgorithms/Python/blob/master/other/fischer_yates_shuffle.py)
+- [food wastage analysis from 1961-2013 fao](https://github.com/TheAlgorithms/Python/blob/master/other/food_wastage_analysis_from_1961-2013_fao.ipynb)
+- [frequency finder](https://github.com/TheAlgorithms/Python/blob/master/other/frequency_finder.py)
+- [game of life](https://github.com/TheAlgorithms/Python/blob/master/other/game_of_life.py)
+- [linear congruential generator](https://github.com/TheAlgorithms/Python/blob/master/other/linear_congruential_generator.py)
+- [nested brackets](https://github.com/TheAlgorithms/Python/blob/master/other/nested_brackets.py)
+- [palindrome](https://github.com/TheAlgorithms/Python/blob/master/other/palindrome.py)
+- [password generator](https://github.com/TheAlgorithms/Python/blob/master/other/password_generator.py)
+- [primelib](https://github.com/TheAlgorithms/Python/blob/master/other/primelib.py)
+- [sierpinski triangle](https://github.com/TheAlgorithms/Python/blob/master/other/sierpinski_triangle.py)
+- [tower of hanoi](https://github.com/TheAlgorithms/Python/blob/master/other/tower_of_hanoi.py)
+- [two sum](https://github.com/TheAlgorithms/Python/blob/master/other/two_sum.py)
+- [word patterns](https://github.com/TheAlgorithms/Python/blob/master/other/word_patterns.py)
+
 ## Project Euler
-  * Problem 01
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
-    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol2.py)
-    * [sol3](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol3.py)
-    * [sol4](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol4.py)
-    * [sol5](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol5.py)
-    * [sol6](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol6.py)
-  * Problem 02
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
-    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol2.py)
-    * [sol3](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol3.py)
-    * [sol4](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol4.py)
-  * Problem 03
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
-    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol2.py)
-  * Problem 04
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
-    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol2.py)
-  * Problem 05
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
-    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol2.py)
-  * Problem 06
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
-    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol2.py)
-    * [sol3](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol3.py)
-  * Problem 07
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
-    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol2.py)
-    * [sol3](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol3.py)
-  * Problem 08
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
-    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol2.py)
-  * Problem 09
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
-    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol2.py)
-    * [sol3](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol3.py)
-  * Problem 10
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
-    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol2.py)
-    * [sol3](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol3.py)
-  * Problem 11
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
-    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol2.py)
-  * Problem 12
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
-    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol2.py)
-  * Problem 13
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
-  * Problem 14
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
-    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol2.py)
-  * Problem 15
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
-  * Problem 16
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
-    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol2.py)
-  * Problem 17
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
-  * Problem 18
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
-  * Problem 19
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
-  * Problem 20
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
-    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol2.py)
-  * Problem 21
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
-  * Problem 22
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
-    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol2.py)
-  * Problem 234
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
-  * Problem 24
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
-  * Problem 25
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
-    * [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol2.py)
-  * Problem 28
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
-  * Problem 29
-    * [solution](https://github.com/TheAlgorithms/Python/blob/master/project_euler/solution.py)
-  * Problem 31
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
-  * Problem 36
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
-  * Problem 40
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
-  * Problem 48
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
-  * Problem 52
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
-  * Problem 53
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
-  * Problem 56
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
-  * Problem 76
-    * [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/sol1.py)
+
+- Problem 01
+  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_01/sol1.py)
+  - [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_01/sol2.py)
+  - [sol3](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_01/sol3.py)
+  - [sol4](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_01/sol4.py)
+  - [sol5](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_01/sol5.py)
+  - [sol6](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_01/sol6.py)
+- Problem 02
+  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_02/sol1.py)
+  - [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_02/sol2.py)
+  - [sol3](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_02/sol3.py)
+  - [sol4](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_02/sol4.py)
+- Problem 03
+  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_03/sol1.py)
+  - [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_03/sol2.py)
+- Problem 04
+  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_04/sol1.py)
+  - [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_04/sol2.py)
+- Problem 05
+  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_05/sol1.py)
+  - [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_05/sol2.py)
+- Problem 06
+  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_06/sol1.py)
+  - [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_06/sol2.py)
+  - [sol3](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_06/sol3.py)
+- Problem 07
+  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_07/sol1.py)
+  - [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_07/sol2.py)
+  - [sol3](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_07/sol3.py)
+- Problem 08
+  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_08/sol1.py)
+  - [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_08/sol2.py)
+- Problem 09
+  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_09/sol1.py)
+  - [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_09/sol2.py)
+  - [sol3](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_09/sol3.py)
+- Problem 10
+  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_10/sol1.py)
+  - [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_10/sol2.py)
+  - [sol3](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_10/sol3.py)
+- Problem 11
+  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_11/sol1.py)
+  - [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_11/sol2.py)
+- Problem 12
+  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_12/sol1.py)
+  - [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_12/sol2.py)
+- Problem 13
+  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_13/sol1.py)
+- Problem 14
+  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_14/sol1.py)
+  - [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_14/sol2.py)
+- Problem 15
+  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_15/sol1.py)
+- Problem 16
+  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_16/sol1.py)
+  - [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_16/sol2.py)
+- Problem 17
+  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_17/sol1.py)
+- Problem 18
+  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_18/sol1.py)
+- Problem 19
+  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_19/sol1.py)
+- Problem 20
+  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_20/sol1.py)
+  - [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_20/sol2.py)
+- Problem 21
+  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_21/sol1.py)
+- Problem 22
+  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_22/sol1.py)
+  - [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_22/sol2.py)
+- Problem 234
+  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_234/sol1.py)
+- Problem 24
+  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_24/sol1.py)
+- Problem 25
+  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_25/sol1.py)
+  - [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_25/sol2.py)
+- Problem 28
+  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_28/sol1.py)
+- Problem 29
+  - [solution](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_28/solution.py)
+- Problem 31
+  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_31/sol1.py)
+- Problem 36
+  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_36/sol1.py)
+- Problem 40
+  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_40/sol1.py)
+- Problem 48
+  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_48/sol1.py)
+- Problem 52
+  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_52/sol1.py)
+- Problem 53
+  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_53/sol1.py)
+- Problem 56
+  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_56/sol1.py)
+- Problem 76
+  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_76/sol1.py)
+
 ## Searches
-  * [binary search](https://github.com/TheAlgorithms/Python/blob/master/searches/binary_search.py)
-  * [interpolation search](https://github.com/TheAlgorithms/Python/blob/master/searches/interpolation_search.py)
-  * [jump search](https://github.com/TheAlgorithms/Python/blob/master/searches/jump_search.py)
-  * [linear search](https://github.com/TheAlgorithms/Python/blob/master/searches/linear_search.py)
-  * [quick select](https://github.com/TheAlgorithms/Python/blob/master/searches/quick_select.py)
-  * [sentinel linear search](https://github.com/TheAlgorithms/Python/blob/master/searches/sentinel_linear_search.py)
-  * [tabu search](https://github.com/TheAlgorithms/Python/blob/master/searches/tabu_search.py)
-  * [ternary search](https://github.com/TheAlgorithms/Python/blob/master/searches/ternary_search.py)
+
+- [binary search](https://github.com/TheAlgorithms/Python/blob/master/searches/binary_search.py)
+- [interpolation search](https://github.com/TheAlgorithms/Python/blob/master/searches/interpolation_search.py)
+- [jump search](https://github.com/TheAlgorithms/Python/blob/master/searches/jump_search.py)
+- [linear search](https://github.com/TheAlgorithms/Python/blob/master/searches/linear_search.py)
+- [quick select](https://github.com/TheAlgorithms/Python/blob/master/searches/quick_select.py)
+- [sentinel linear search](https://github.com/TheAlgorithms/Python/blob/master/searches/sentinel_linear_search.py)
+- [tabu search](https://github.com/TheAlgorithms/Python/blob/master/searches/tabu_search.py)
+- [ternary search](https://github.com/TheAlgorithms/Python/blob/master/searches/ternary_search.py)
+
 ## Sorts
-  * [bitonic sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/bitonic_sort.py)
-  * [bogo sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/bogo_sort.py)
-  * [bubble sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/bubble_sort.py)
-  * [bucket sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/bucket_sort.py)
-  * [cocktail shaker sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/cocktail_shaker_sort.py)
-  * [comb sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/comb_sort.py)
-  * [counting sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/counting_sort.py)
-  * [cycle sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/cycle_sort.py)
-  * [external sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/external_sort.py)
-  * [gnome sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/gnome_sort.py)
-  * [heap sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/heap_sort.py)
-  * [insertion sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/insertion_sort.py)
-  * [merge sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/merge_sort.py)
-  * [merge sort fastest](https://github.com/TheAlgorithms/Python/blob/master/sorts/merge_sort_fastest.py)
-  * [odd even transposition parallel](https://github.com/TheAlgorithms/Python/blob/master/sorts/odd_even_transposition_parallel.py)
-  * [odd even transposition single threaded](https://github.com/TheAlgorithms/Python/blob/master/sorts/odd_even_transposition_single_threaded.py)
-  * [pancake sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/pancake_sort.py)
-  * [pigeon sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/pigeon_sort.py)
-  * [quick sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/quick_sort.py)
-  * [quick sort 3 partition](https://github.com/TheAlgorithms/Python/blob/master/sorts/quick_sort_3_partition.py)
-  * [radix sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/radix_sort.py)
-  * [random normal distribution quicksort](https://github.com/TheAlgorithms/Python/blob/master/sorts/random_normal_distribution_quicksort.py)
-  * [random pivot quick sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/random_pivot_quick_sort.py)
-  * [selection sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/selection_sort.py)
-  * [shell sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/shell_sort.py)
-  * [tim sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/tim_sort.py)
-  * [topological sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/topological_sort.py)
-  * [tree sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/tree_sort.py)
-  * [wiggle sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/wiggle_sort.py)
+
+- [bitonic sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/bitonic_sort.py)
+- [bogo sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/bogo_sort.py)
+- [bubble sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/bubble_sort.py)
+- [bucket sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/bucket_sort.py)
+- [cocktail shaker sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/cocktail_shaker_sort.py)
+- [comb sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/comb_sort.py)
+- [counting sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/counting_sort.py)
+- [cycle sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/cycle_sort.py)
+- [external sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/external_sort.py)
+- [gnome sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/gnome_sort.py)
+- [heap sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/heap_sort.py)
+- [insertion sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/insertion_sort.py)
+- [merge sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/merge_sort.py)
+- [merge sort fastest](https://github.com/TheAlgorithms/Python/blob/master/sorts/merge_sort_fastest.py)
+- [odd even transposition parallel](https://github.com/TheAlgorithms/Python/blob/master/sorts/odd_even_transposition_parallel.py)
+- [odd even transposition single threaded](https://github.com/TheAlgorithms/Python/blob/master/sorts/odd_even_transposition_single_threaded.py)
+- [pancake sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/pancake_sort.py)
+- [pigeon sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/pigeon_sort.py)
+- [quick sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/quick_sort.py)
+- [quick sort 3 partition](https://github.com/TheAlgorithms/Python/blob/master/sorts/quick_sort_3_partition.py)
+- [radix sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/radix_sort.py)
+- [random normal distribution quicksort](https://github.com/TheAlgorithms/Python/blob/master/sorts/random_normal_distribution_quicksort.py)
+- [random pivot quick sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/random_pivot_quick_sort.py)
+- [selection sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/selection_sort.py)
+- [shell sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/shell_sort.py)
+- [tim sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/tim_sort.py)
+- [topological sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/topological_sort.py)
+- [tree sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/tree_sort.py)
+- [wiggle sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/wiggle_sort.py)
+
 ## Strings
-  * [boyer moore search](https://github.com/TheAlgorithms/Python/blob/master/strings/boyer_moore_search.py)
-  * [knuth morris pratt](https://github.com/TheAlgorithms/Python/blob/master/strings/knuth_morris_pratt.py)
-  * [levenshtein distance](https://github.com/TheAlgorithms/Python/blob/master/strings/levenshtein_distance.py)
-  * [manacher](https://github.com/TheAlgorithms/Python/blob/master/strings/manacher.py)
-  * [min cost string conversion](https://github.com/TheAlgorithms/Python/blob/master/strings/min_cost_string_conversion.py)
-  * [naive string search](https://github.com/TheAlgorithms/Python/blob/master/strings/naive_string_search.py)
-  * [rabin karp](https://github.com/TheAlgorithms/Python/blob/master/strings/rabin_karp.py)
+
+- [boyer moore search](https://github.com/TheAlgorithms/Python/blob/master/strings/boyer_moore_search.py)
+- [knuth morris pratt](https://github.com/TheAlgorithms/Python/blob/master/strings/knuth_morris_pratt.py)
+- [levenshtein distance](https://github.com/TheAlgorithms/Python/blob/master/strings/levenshtein_distance.py)
+- [manacher](https://github.com/TheAlgorithms/Python/blob/master/strings/manacher.py)
+- [min cost string conversion](https://github.com/TheAlgorithms/Python/blob/master/strings/min_cost_string_conversion.py)
+- [naive string search](https://github.com/TheAlgorithms/Python/blob/master/strings/naive_string_search.py)
+- [rabin karp](https://github.com/TheAlgorithms/Python/blob/master/strings/rabin_karp.py)
+
 ## Traversals
-  * [binary tree traversals](https://github.com/TheAlgorithms/Python/blob/master/traversals/binary_tree_traversals.py)
 
+- [binary tree traversals](https://github.com/TheAlgorithms/Python/blob/master/traversals/binary_tree_traversals.py)

From 22bd6ff967fd8a983490e241485f950c0a82380c Mon Sep 17 00:00:00 2001
From: Maram Sumanth <maram.sumanth@gmail.com>
Date: Mon, 7 Oct 2019 23:56:40 +0530
Subject: [PATCH 244/348] Update average_mean.py (#1293)

---
 maths/average_mean.py | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/maths/average_mean.py b/maths/average_mean.py
index e04b63be0e19..77464ef5d9f7 100644
--- a/maths/average_mean.py
+++ b/maths/average_mean.py
@@ -3,17 +3,13 @@
 
 def average(nums):
     """Find mean of a list of numbers."""
-    sum = 0
-    for x in nums:
-        sum += x
-    avg = sum / len(nums)
-    print(avg)
+    avg = sum(nums) / len(nums)
     return avg
 
 
 def main():
     """Call average module to find mean of a specific list of numbers."""
-    average([2, 4, 6, 8, 20, 50, 70])
+    print(average([2, 4, 6, 8, 20, 50, 70]))
 
 
 if __name__ == "__main__":

From 06d736199b058ab80d747da242085d48a6803096 Mon Sep 17 00:00:00 2001
From: Nishant-Ingle <30694286+Nishant-Ingle@users.noreply.github.com>
Date: Mon, 7 Oct 2019 23:59:14 +0530
Subject: [PATCH 245/348] Added comment (#1294)

---
 data_structures/binary_tree/binary_search_tree.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/data_structures/binary_tree/binary_search_tree.py b/data_structures/binary_tree/binary_search_tree.py
index c6e037880bb6..1e6c17112e81 100644
--- a/data_structures/binary_tree/binary_search_tree.py
+++ b/data_structures/binary_tree/binary_search_tree.py
@@ -40,6 +40,7 @@ class BinarySearchTree:
     def __init__(self):
         self.root = None
 
+    # Insert a new node in Binary Search Tree with value label
     def insert(self, label):
         # Create a new Node
         new_node = Node(label, None)

From 3a06aba66a0a4265077979c6ad9aad923deb3023 Mon Sep 17 00:00:00 2001
From: Craigory V Coppola <craigorycoppola@gmail.com>
Date: Mon, 7 Oct 2019 14:32:16 -0400
Subject: [PATCH 246/348] Update Linear Algebra Readme (#1298)

Update formatting to better indicate matrix and vector sections
---
 linear_algebra/README.md | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/linear_algebra/README.md b/linear_algebra/README.md
index 1e34d0bd7805..f1b554e139de 100644
--- a/linear_algebra/README.md
+++ b/linear_algebra/README.md
@@ -6,7 +6,8 @@ This module contains some useful classes and functions for dealing with linear a
 
 ## Overview  
 
-- class Vector  
+### class Vector  
+-
     - This class represents a vector of arbitray size and operations on it.  
 
     **Overview about the methods:**    
@@ -32,7 +33,8 @@ This module contains some useful classes and functions for dealing with linear a
 - function randomVector(N,a,b)
     - returns a random vector of size N, with random integer components between 'a' and 'b'.
 
-- class Matrix
+### class Matrix
+-
     - This class represents a matrix of arbitrary size and operations on it.
 
     **Overview about the methods:**  

From 25701a98773b30eb70e078d9a04f246989d11d64 Mon Sep 17 00:00:00 2001
From: Kaushik Amar Das <cozek@users.noreply.github.com>
Date: Tue, 8 Oct 2019 13:42:27 +0530
Subject: [PATCH 247/348] added doctests to scoring_functions.py (#1300)

* added doctests to scoring_functions.py

* dedented lines
---
 machine_learning/scoring_functions.py | 60 +++++++++++++++++++++++++--
 1 file changed, 57 insertions(+), 3 deletions(-)

diff --git a/machine_learning/scoring_functions.py b/machine_learning/scoring_functions.py
index 2b24287b3726..5c84f7026e74 100755
--- a/machine_learning/scoring_functions.py
+++ b/machine_learning/scoring_functions.py
@@ -16,6 +16,16 @@
 
 # Mean Absolute Error
 def mae(predict, actual):
+    """
+    Examples(rounded for precision):
+    >>> actual = [1,2,3];predict = [1,4,3]
+    >>> np.around(mae(predict,actual),decimals = 2)
+    0.67
+
+    >>> actual = [1,1,1];predict = [1,1,1]
+    >>> mae(predict,actual)
+    0.0
+    """
     predict = np.array(predict)
     actual = np.array(actual)
 
@@ -27,6 +37,16 @@ def mae(predict, actual):
 
 # Mean Squared Error
 def mse(predict, actual):
+    """
+    Examples(rounded for precision):
+    >>> actual = [1,2,3];predict = [1,4,3]
+    >>> np.around(mse(predict,actual),decimals = 2)
+    1.33
+
+    >>> actual = [1,1,1];predict = [1,1,1]
+    >>> mse(predict,actual)
+    0.0
+    """
     predict = np.array(predict)
     actual = np.array(actual)
 
@@ -39,6 +59,16 @@ def mse(predict, actual):
 
 # Root Mean Squared Error
 def rmse(predict, actual):
+    """
+    Examples(rounded for precision):
+    >>> actual = [1,2,3];predict = [1,4,3]
+    >>> np.around(rmse(predict,actual),decimals = 2)
+    1.15
+
+    >>> actual = [1,1,1];predict = [1,1,1]
+    >>> rmse(predict,actual)
+    0.0
+    """
     predict = np.array(predict)
     actual = np.array(actual)
 
@@ -51,6 +81,16 @@ def rmse(predict, actual):
 
 # Root Mean Square Logarithmic Error
 def rmsle(predict, actual):
+    """
+    Examples(rounded for precision):
+    >>> actual = [10,10,30];predict = [10,2,30]
+    >>> np.around(rmsle(predict,actual),decimals = 2)
+    0.75
+
+    >>> actual = [1,1,1];predict = [1,1,1]
+    >>> rmsle(predict,actual)
+    0.0
+    """
     predict = np.array(predict)
     actual = np.array(actual)
 
@@ -68,15 +108,29 @@ def rmsle(predict, actual):
 
 # Mean Bias Deviation
 def mbd(predict, actual):
+    """
+    This value is Negative, if the model underpredicts,
+    positive, if it overpredicts.
+
+    Example(rounded for precision):
+
+    Here the model overpredicts
+    >>> actual = [1,2,3];predict = [2,3,4]
+    >>> np.around(mbd(predict,actual),decimals = 2)
+    50.0
+
+    Here the model underpredicts
+    >>> actual = [1,2,3];predict = [0,1,1]
+    >>> np.around(mbd(predict,actual),decimals = 2)
+    -66.67
+    """
     predict = np.array(predict)
     actual = np.array(actual)
 
     difference = predict - actual
     numerator = np.sum(difference) / len(predict)
     denumerator = np.sum(actual) / len(predict)
-    print(numerator)
-    print(denumerator)
-
+    # print(numerator, denumerator)
     score = float(numerator) / denumerator * 100
 
     return score

From 0da4d0a7f35c825447aa4666bb073a3ad118f319 Mon Sep 17 00:00:00 2001
From: Du YuanChao <shellhub.me@gmail.com>
Date: Tue, 8 Oct 2019 16:22:40 +0800
Subject: [PATCH 248/348] make code more readable (#1304)

---
 searches/binary_search.py | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/searches/binary_search.py b/searches/binary_search.py
index 9237c0e1f6f5..76a50560e943 100644
--- a/searches/binary_search.py
+++ b/searches/binary_search.py
@@ -43,11 +43,10 @@ def binary_search(sorted_collection, item):
         current_item = sorted_collection[midpoint]
         if current_item == item:
             return midpoint
+        elif item < current_item:
+            right = midpoint - 1
         else:
-            if item < current_item:
-                right = midpoint - 1
-            else:
-                left = midpoint + 1
+            left = midpoint + 1
     return None
 
 

From f0568d642ee6bcebbba330452e09e76d3c73e150 Mon Sep 17 00:00:00 2001
From: Du YuanChao <shellhub.me@gmail.com>
Date: Tue, 8 Oct 2019 16:24:01 +0800
Subject: [PATCH 249/348] less code (#1292)

---
 maths/abs.py | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/maths/abs.py b/maths/abs.py
index 4d15ee6e82a8..7509c5c20a22 100644
--- a/maths/abs.py
+++ b/maths/abs.py
@@ -10,11 +10,7 @@ def abs_val(num):
     >>abs_val(0)
     0
     """
-    if num < 0:
-        return -num
-
-    # Returns if number is not < 0
-    return num
+    return -num if num < 0 else num
 
 
 def main():

From e80d248e65d20227d23098d354ca82f111d79967 Mon Sep 17 00:00:00 2001
From: Du YuanChao <shellhub.me@gmail.com>
Date: Tue, 8 Oct 2019 16:25:00 +0800
Subject: [PATCH 250/348] optimization (#1303)

---
 sorts/selection_sort.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/sorts/selection_sort.py b/sorts/selection_sort.py
index 43ad26a7bf27..6a9c063d3364 100644
--- a/sorts/selection_sort.py
+++ b/sorts/selection_sort.py
@@ -35,7 +35,8 @@ def selection_sort(collection):
         for k in range(i + 1, length):
             if collection[k] < collection[least]:
                 least = k
-        collection[least], collection[i] = (collection[i], collection[least])
+        if least != i:
+            collection[least], collection[i] = (collection[i], collection[least])
     return collection
 
 

From 61f7f94fde8dff80740ee5ef19b2998f192da8d2 Mon Sep 17 00:00:00 2001
From: Rishabh Kumar <rishabh0098@gmail.com>
Date: Tue, 8 Oct 2019 17:55:50 +0530
Subject: [PATCH 251/348] Create karatsuba.py (#1309)

* Create karatsuba.py

Added karatsuba algorithm for multiplication of two numbers

* Update karatsuba.py

Added doctests and divmod

* Update karatsuba.py
---
 maths/karatsuba.py | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 maths/karatsuba.py

diff --git a/maths/karatsuba.py b/maths/karatsuba.py
new file mode 100644
index 000000000000..be4630184933
--- /dev/null
+++ b/maths/karatsuba.py
@@ -0,0 +1,31 @@
+""" Multiply two numbers using Karatsuba algorithm """
+
+def karatsuba(a, b):
+    """
+    >>> karatsuba(15463, 23489) == 15463 * 23489
+    True
+    >>> karatsuba(3, 9) == 3 * 9
+    True
+    """
+    if len(str(a)) == 1 or len(str(b)) == 1:
+        return (a * b)
+    else:
+        m1 = max(len(str(a)), len(str(b)))
+        m2 = m1 // 2
+
+        a1, a2 = divmod(a, 10**m2)
+        b1, b2 = divmod(b, 10**m2)
+
+        x = karatsuba(a2, b2)
+        y = karatsuba((a1 + a2), (b1 + b2))
+        z = karatsuba(a1, b1)
+
+        return ((z * 10**(2*m2)) + ((y - z - x) * 10**(m2)) + (x))
+
+
+def main():
+    print(karatsuba(15463, 23489))
+
+
+if __name__ == "__main__":
+    main()

From b6cc37d461da2a631fe077d0cf952c5981d2dfdd Mon Sep 17 00:00:00 2001
From: Jigyasa G <jigsgandhi97@gmail.com>
Date: Thu, 10 Oct 2019 00:42:09 +0530
Subject: [PATCH 252/348] mergesort added (#1313)

* mergesort added

* added doctest
---
 divide_and_conquer/mergesort.py | 45 +++++++++++++++++++++++++++++++++
 1 file changed, 45 insertions(+)
 create mode 100644 divide_and_conquer/mergesort.py

diff --git a/divide_and_conquer/mergesort.py b/divide_and_conquer/mergesort.py
new file mode 100644
index 000000000000..b2a5a4c321ae
--- /dev/null
+++ b/divide_and_conquer/mergesort.py
@@ -0,0 +1,45 @@
+def merge(a,b,m,e):
+    l=a[b:m+1]
+    r=a[m+1:e+1]
+    k=b
+    i=0
+    j=0
+    while i<len(l) and j<len(r):
+        #change sign for Descending order
+        if l[i]<r[j]: 
+            a[k]=l[i]
+            i+=1
+        else:
+            a[k]=r[j]
+            j+=1
+        k+=1
+    while i<len(l):
+        a[k]=l[i]
+        i+=1
+        k+=1
+    while j<len(r):
+        a[k]=r[j]
+        j+=1
+        k+=1
+    return a
+    
+def mergesort(a,b,e):
+    """
+    >>> mergesort([3,2,1],0,2)
+    [1, 2, 3]
+    >>> mergesort([3,2,1,0,1,2,3,5,4],0,8)
+    [0, 1, 1, 2, 2, 3, 3, 4, 5]
+    """
+    if b<e:
+        m = (b+e)//2
+        #print("ms1",a,b,m)
+        mergesort(a,b,m)
+        #print("ms2",a,m+1,e)
+        mergesort(a,m+1,e)
+        #print("m",a,b,m,e)
+        merge(a,b,m,e)
+        return a
+
+if __name__ == "__main__":
+    import doctest
+    doctest.testmod()

From ea47ae2932b11f2b28c5e7276c8c42bfdeb46474 Mon Sep 17 00:00:00 2001
From: Jigyasa G <jigsgandhi97@gmail.com>
Date: Thu, 10 Oct 2019 00:50:19 +0530
Subject: [PATCH 253/348] Adding missing Doctests  (#1330)

* Adding doctests in abbreviation

* Adding doctests in fibonacci.py
---
 dynamic_programming/abbreviation.py | 12 ++++++++++--
 dynamic_programming/fibonacci.py    | 16 ++++++++++++++++
 2 files changed, 26 insertions(+), 2 deletions(-)

diff --git a/dynamic_programming/abbreviation.py b/dynamic_programming/abbreviation.py
index f4d07e402925..a2aec35af77b 100644
--- a/dynamic_programming/abbreviation.py
+++ b/dynamic_programming/abbreviation.py
@@ -11,8 +11,13 @@
 daBcd -> capitalize a and c(dABCd) -> remove d (ABC)
 """
 
-
 def abbr(a, b):
+    """
+    >>> abbr("daBcd", "ABC")
+    True
+    >>> abbr("dBcd", "ABC")
+    False
+    """
     n = len(a)
     m = len(b)
     dp = [[False for _ in range(m + 1)] for _ in range(n + 1)]
@@ -28,4 +33,7 @@ def abbr(a, b):
 
 
 if __name__ == "__main__":
-    print(abbr("daBcd", "ABC"))  # expect True
+    # print(abbr("daBcd", "ABC"))  # expect True
+    import doctest
+
+    doctest.testmod()
diff --git a/dynamic_programming/fibonacci.py b/dynamic_programming/fibonacci.py
index 2dd1c2555f3e..125686416603 100644
--- a/dynamic_programming/fibonacci.py
+++ b/dynamic_programming/fibonacci.py
@@ -14,8 +14,20 @@ def __init__(self, N=None):
                 self.fib_array.append(self.fib_array[i - 1] + self.fib_array[i - 2])
         elif N == 0:
             self.fib_array.append(0)
+        print(self.fib_array)
 
     def get(self, sequence_no=None):
+        """
+        >>> Fibonacci(5).get(3)
+        [0, 1, 1, 2, 3, 5]
+        [0, 1, 1, 2]
+        >>> Fibonacci(5).get(6)
+        [0, 1, 1, 2, 3, 5]
+        Out of bound.
+        >>> Fibonacci(5).get(-1)
+        [0, 1, 1, 2, 3, 5]
+        []
+        """
         if sequence_no != None:
             if sequence_no < len(self.fib_array):
                 return print(self.fib_array[: sequence_no + 1])
@@ -46,3 +58,7 @@ def get(self, sequence_no=None):
                 print("\nInvalid input, please try again.")
     except NameError:
         print("\n********* Invalid input, good bye!! ************\n")
+        
+    import doctest
+
+    doctest.testmod()

From e67887989232bb64533995cc1044e13d739b02ef Mon Sep 17 00:00:00 2001
From: Jigyasa G <jigsgandhi97@gmail.com>
Date: Fri, 11 Oct 2019 23:59:50 +0530
Subject: [PATCH 254/348] Adding doctests for sum_of_subset.py (#1333)

---
 dynamic_programming/sum_of_subset.py | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/dynamic_programming/sum_of_subset.py b/dynamic_programming/sum_of_subset.py
index 581039080101..5c7944d5090e 100644
--- a/dynamic_programming/sum_of_subset.py
+++ b/dynamic_programming/sum_of_subset.py
@@ -1,5 +1,10 @@
 def isSumSubset(arr, arrLen, requiredSum):
-
+    """
+    >>> isSumSubset([2, 4, 6, 8], 4, 5)
+    False
+    >>> isSumSubset([2, 4, 6, 8], 4, 14)
+    True
+    """
     # a subset value says 1 if that subset sum can be formed else 0
     # initially no subsets can be formed hence False/0
     subset = [[False for i in range(requiredSum + 1)] for i in range(arrLen + 1)]
@@ -22,14 +27,9 @@ def isSumSubset(arr, arrLen, requiredSum):
     # uncomment to print the subset
     # for i in range(arrLen+1):
     #     print(subset[i])
+    print(subset[arrLen][requiredSum])
 
-    return subset[arrLen][requiredSum]
-
+if __name__ == "__main__":
+    import doctest
 
-arr = [2, 4, 6, 8]
-requiredSum = 5
-arrLen = len(arr)
-if isSumSubset(arr, arrLen, requiredSum):
-    print("Found a subset with required sum")
-else:
-    print("No subset with required sum")
+    doctest.testmod()

From 67291a5bce1f5761ce2d6978193ec4a3b1f6dcc6 Mon Sep 17 00:00:00 2001
From: Jigyasa G <jigsgandhi97@gmail.com>
Date: Sat, 12 Oct 2019 00:02:41 +0530
Subject: [PATCH 255/348] Modified longest_common_ssubsequence.py for
 successful doctests (#1332)

---
 dynamic_programming/longest_common_subsequence.py | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/dynamic_programming/longest_common_subsequence.py b/dynamic_programming/longest_common_subsequence.py
index 12fcae684051..4bb1db044d3b 100644
--- a/dynamic_programming/longest_common_subsequence.py
+++ b/dynamic_programming/longest_common_subsequence.py
@@ -76,6 +76,7 @@ def longest_common_subsequence(x: str, y: str):
     expected_subseq = "GTAB"
 
     ln, subseq = longest_common_subsequence(a, b)
-    assert expected_ln == ln
-    assert expected_subseq == subseq
-    print("len =", ln, ", sub-sequence =", subseq)
+##    print("len =", ln, ", sub-sequence =", subseq)
+    import doctest
+
+    doctest.testmod()

From b190c8f629d1fb8371fb9ea434d986a843b2ecab Mon Sep 17 00:00:00 2001
From: Aliabbas Merchant <merchantaliabbas@gmail.com>
Date: Tue, 15 Oct 2019 00:05:51 +0530
Subject: [PATCH 256/348] Rename GCD File (#1354)

---
 ...greater_common_divisor.py => greatest_common_divisor.py} | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)
 rename maths/{greater_common_divisor.py => greatest_common_divisor.py} (76%)

diff --git a/maths/greater_common_divisor.py b/maths/greatest_common_divisor.py
similarity index 76%
rename from maths/greater_common_divisor.py
rename to maths/greatest_common_divisor.py
index ec608488a61f..ebc08f37ffa6 100644
--- a/maths/greater_common_divisor.py
+++ b/maths/greatest_common_divisor.py
@@ -1,12 +1,12 @@
 """
-Greater Common Divisor.
+Greatest Common Divisor.
 
 Wikipedia reference: https://en.wikipedia.org/wiki/Greatest_common_divisor
 """
 
 
 def gcd(a, b):
-    """Calculate Greater Common Divisor (GCD)."""
+    """Calculate Greatest Common Divisor (GCD)."""
     return b if a == 0 else gcd(b % a, a)
 
 
@@ -16,9 +16,9 @@ def main():
         nums = input("Enter two Integers separated by comma (,): ").split(",")
         num_1 = int(nums[0])
         num_2 = int(nums[1])
+        print(f"gcd({num_1}, {num_2}) = {gcd(num_1, num_2)}")
     except (IndexError, UnboundLocalError, ValueError):
         print("Wrong Input")
-    print(f"gcd({num_1}, {num_2}) = {gcd(num_1, num_2)}")
 
 
 if __name__ == "__main__":

From dcee2eac68e0c1b4061c94c69e920ed2d42f42f2 Mon Sep 17 00:00:00 2001
From: Andrii Siriak <siryaka@gmail.com>
Date: Thu, 17 Oct 2019 17:02:40 +0300
Subject: [PATCH 257/348] Update build badge (#1378)

* Update build badge

* Update README.md
---
 README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index a5af46ad8505..8ccb789be7e9 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
-# The Algorithms - Python <!-- [![Build Status](https://travis-ci.org/TheAlgorithms/Python.svg)](https://travis-ci.org/TheAlgorithms/Python) -->
+# The Algorithms - Python
 [![Donate](https://img.shields.io/badge/Donate-PayPal-green.svg?logo=paypal&style=flat-square)](https://www.paypal.me/TheAlgorithms/100)&nbsp;
-[![Build Status](https://img.shields.io/travis/TheAlgorithms/Python.svg?label=Travis%20CI&logo=travis&style=flat-square)](https://travis-ci.org/TheAlgorithms/Python)&nbsp;
+[![Build Status](https://img.shields.io/travis/TheAlgorithms/Python.svg?label=Travis%20CI&logo=travis&style=flat-square)](https://travis-ci.com/TheAlgorithms/Python)&nbsp;
 [![LGTM](https://img.shields.io/lgtm/alerts/github/TheAlgorithms/Python.svg?label=LGTM&logo=LGTM&style=flat-square)](https://lgtm.com/projects/g/TheAlgorithms/Python/alerts)&nbsp;
 [![Gitter chat](https://img.shields.io/badge/Chat-Gitter-ff69b4.svg?label=Chat&logo=gitter&style=flat-square)](https://gitter.im/TheAlgorithms)&nbsp;
 [![contributions welcome](https://img.shields.io/static/v1.svg?label=Contributions&message=Welcome&color=0059b3&style=flat-square)](https://github.com/TheAlgorithms/Python/blob/master/CONTRIBUTING.md)&nbsp;

From 927a8c7722a141b19a86fdb2f6fb3ae7dcb94c9e Mon Sep 17 00:00:00 2001
From: Stephen <24819660+infrontoftheforest@users.noreply.github.com>
Date: Thu, 17 Oct 2019 14:50:51 +0000
Subject: [PATCH 258/348] added horner's method (#1360)

---
 maths/polynomial_evaluation.py | 60 +++++++++++++++++++++++++---------
 1 file changed, 44 insertions(+), 16 deletions(-)

diff --git a/maths/polynomial_evaluation.py b/maths/polynomial_evaluation.py
index 3c91ecd93031..d2394f398c36 100644
--- a/maths/polynomial_evaluation.py
+++ b/maths/polynomial_evaluation.py
@@ -1,25 +1,53 @@
-def evaluate_poly(poly, x):
-    """
-        Objective: Computes the polynomial function for a given value x. 
-                Returns that value. 
-        Input Prams: 
-            poly: tuple of numbers - value of cofficients
-            x: value for x in f(x)
-        Return: value of f(x)
-
-        >>> evaluate_poly((0.0, 0.0, 5.0, 9.3, 7.0), 10)
-        79800.0
-    """
+from typing import Sequence
+
+
+def evaluate_poly(poly: Sequence[float], x: float) -> float:
+    """Evaluate a polynomial f(x) at specified point x and return the value.
 
+    Arguments:
+    poly -- the coeffiecients of a polynomial as an iterable in order of
+            ascending degree
+    x -- the point at which to evaluate the polynomial
+
+    >>> evaluate_poly((0.0, 0.0, 5.0, 9.3, 7.0), 10.0)
+    79800.0
+    """
     return sum(c * (x ** i) for i, c in enumerate(poly))
 
 
+def horner(poly: Sequence[float], x: float) -> float:
+    """Evaluate a polynomial at specified point using Horner's method.
+
+    In terms of computational complexity, Horner's method is an efficient method
+    of evaluating a polynomial. It avoids the use of expensive exponentiation,
+    and instead uses only multiplication and addition to evaluate the polynomial
+    in O(n), where n is the degree of the polynomial.
+
+    https://en.wikipedia.org/wiki/Horner's_method
+
+    Arguments:
+    poly -- the coeffiecients of a polynomial as an iterable in order of
+            ascending degree
+    x -- the point at which to evaluate the polynomial
+
+    >>> horner((0.0, 0.0, 5.0, 9.3, 7.0), 10.0)
+    79800.0
+    """
+    result = 0.0
+    for coeff in reversed(poly):
+        result = result * x + coeff
+    return result
+
+
 if __name__ == "__main__":
     """
-        Example: poly = (0.0, 0.0, 5.0, 9.3, 7.0)  # f(x) = 7.0x^4 + 9.3x^3 + 5.0x^2 
-                 x = -13
-                 print (evaluate_poly(poly, x))  # f(-13) = 7.0(-13)^4 + 9.3(-13)^3 + 5.0(-13)^2 = 180339.9
+    Example:
+    >>> poly = (0.0, 0.0, 5.0, 9.3, 7.0)  # f(x) = 7.0x^4 + 9.3x^3 + 5.0x^2
+    >>> x = -13.0
+    >>> print(evaluate_poly(poly, x))  # f(-13) = 7.0(-13)^4 + 9.3(-13)^3 + 5.0(-13)^2 = 180339.9
+    180339.9
     """
     poly = (0.0, 0.0, 5.0, 9.3, 7.0)
-    x = 10
+    x = 10.0
     print(evaluate_poly(poly, x))
+    print(horner(poly, x))

From 63d8cadc3e5aea15d0eadec970a3639752572d94 Mon Sep 17 00:00:00 2001
From: Milad Sadeghi DM <Cor3Down@ProtonMail.ch>
Date: Thu, 17 Oct 2019 21:43:28 +0330
Subject: [PATCH 259/348] Fixing Some Minor Issues (#1386)

* Replacing mutable default argument in __init__

* Fixing typo mistakes in lib.py

* Simplifying chained comparisons

* Update lib.py
---
 linear_algebra/src/lib.py | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/linear_algebra/src/lib.py b/linear_algebra/src/lib.py
index 5ce0f696ad71..090427d9a520 100644
--- a/linear_algebra/src/lib.py
+++ b/linear_algebra/src/lib.py
@@ -27,7 +27,7 @@
 
 class Vector(object):
     """
-        This class represents a vector of arbitray size.
+        This class represents a vector of arbitrary size.
         You need to give the vector components. 
         
         Overview about the methods:
@@ -46,11 +46,13 @@ class Vector(object):
         TODO: compare-operator
     """
 
-    def __init__(self, components=[]):
+    def __init__(self, components=None):
         """
             input: components or nothing
             simple constructor for init the vector
         """
+        if components is None:
+            components = []
         self.__components = list(components)
 
     def set(self, components):
@@ -112,7 +114,7 @@ def __sub__(self, other):
         """
             input: other vector
             assumes: other vector has the same size
-            returns a new vector that represents the differenz.
+            returns a new vector that represents the difference.
         """
         size = len(self)
         if size == len(other):
@@ -136,7 +138,7 @@ def __mul__(self, other):
                 summe += self.__components[i] * other.component(i)
             return summe
         else:  # error case
-            raise Exception("invalide operand!")
+            raise Exception("invalid operand!")
 
     def copy(self):
         """
@@ -223,7 +225,7 @@ class Matrix(object):
 
     def __init__(self, matrix, w, h):
         """
-            simple constructor for initialzes 
+            simple constructor for initializing
             the matrix with components.
         """
         self.__matrix = matrix
@@ -249,7 +251,7 @@ def changeComponent(self, x, y, value):
         """
             changes the x-y component of this matrix
         """
-        if x >= 0 and x < self.__height and y >= 0 and y < self.__width:
+        if 0 <= x < self.__height and 0 <= y < self.__width:
             self.__matrix[x][y] = value
         else:
             raise Exception("changeComponent: indices out of bounds")
@@ -258,7 +260,7 @@ def component(self, x, y):
         """
             returns the specified (x,y) component
         """
-        if x >= 0 and x < self.__height and y >= 0 and y < self.__width:
+        if 0 <= x < self.__height and 0 <= y < self.__width:
             return self.__matrix[x][y]
         else:
             raise Exception("changeComponent: indices out of bounds")

From 83c104e839c158c3e84e567c38f5d30a4224e832 Mon Sep 17 00:00:00 2001
From: Du YuanChao <shellhub.me@gmail.com>
Date: Fri, 18 Oct 2019 12:20:36 +0800
Subject: [PATCH 260/348] Divide and Conquer (#1308)

Thanks for your persistence!
---
 maths/find_max_recursion.py | 25 +++++++++++++++++++++++++
 maths/find_min_recursion.py | 25 +++++++++++++++++++++++++
 2 files changed, 50 insertions(+)
 create mode 100644 maths/find_max_recursion.py
 create mode 100644 maths/find_min_recursion.py

diff --git a/maths/find_max_recursion.py b/maths/find_max_recursion.py
new file mode 100644
index 000000000000..fc10ecf3757a
--- /dev/null
+++ b/maths/find_max_recursion.py
@@ -0,0 +1,25 @@
+# Divide and Conquer algorithm
+def find_max(nums, left, right):
+    """
+    find max value in list
+    :param nums: contains elements
+    :param left: index of first element
+    :param right: index of last element
+    :return: max in nums
+    
+    >>> nums = [1, 3, 5, 7, 9, 2, 4, 6, 8, 10]
+    >>> find_max(nums, 0, len(nums) - 1) == max(nums)
+    True
+    """
+    if left == right:
+        return nums[left]
+    mid = (left + right) >> 1  # the middle
+    left_max = find_max(nums, left, mid)  # find max in range[left, mid]
+    right_max = find_max(nums, mid + 1, right)  # find max in range[mid + 1, right]
+
+    return left_max if left_max >= right_max else right_max
+
+
+if __name__ == "__main__":
+    nums = [1, 3, 5, 7, 9, 2, 4, 6, 8, 10]
+    assert find_max(nums, 0, len(nums) - 1) == 10
diff --git a/maths/find_min_recursion.py b/maths/find_min_recursion.py
new file mode 100644
index 000000000000..4488967cc57a
--- /dev/null
+++ b/maths/find_min_recursion.py
@@ -0,0 +1,25 @@
+# Divide and Conquer algorithm
+def find_min(nums, left, right):
+    """
+    find min value in list
+    :param nums: contains elements
+    :param left: index of first element
+    :param right: index of last element
+    :return: min in nums
+
+    >>> nums = [1, 3, 5, 7, 9, 2, 4, 6, 8, 10]
+    >>> find_min(nums, 0, len(nums) - 1) == min(nums)
+    True
+    """
+    if left == right:
+        return nums[left]
+    mid = (left + right) >> 1  # the middle
+    left_min = find_min(nums, left, mid)  # find min in range[left, mid]
+    right_min = find_min(nums, mid + 1, right)  # find min in range[mid + 1, right]
+
+    return left_min if left_min <= right_min else right_min
+
+
+if __name__ == "__main__":
+    nums = [1, 3, 5, 7, 9, 2, 4, 6, 8, 10]
+    assert find_min(nums, 0, len(nums) - 1) == 1

From 28b964c9b56a52465ef69f36246947247ef1c21b Mon Sep 17 00:00:00 2001
From: aritrartira <53134837+aritrartira@users.noreply.github.com>
Date: Fri, 18 Oct 2019 10:16:13 +0530
Subject: [PATCH 261/348] Added missing problem statements (#1364)

---
 project_euler/README.md | 56 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 56 insertions(+)

diff --git a/project_euler/README.md b/project_euler/README.md
index 9f77f719f0f1..89b6d63b5744 100644
--- a/project_euler/README.md
+++ b/project_euler/README.md
@@ -37,21 +37,77 @@ PROBLEMS:
 
 7. By listing the first six prime numbers: 2, 3, 5, 7, 11, and 13, we can see that the 6th prime is 13.
    What is the Nth prime number?
+   
+8. Find the consecutive k digits in a number N that have the largest product.
 
 9. A Pythagorean triplet is a set of three natural numbers, a < b < c, for which,
     a^2 + b^2 = c^2
     There exists exactly one Pythagorean triplet for which a + b + c = 1000.
     Find the product abc.
 
+10. Find sum of all prime numbers below 2 million.
+
+11. In the given 20x20 grid, find 4 adjacent numbers (horizontally, vertically or diagonally) that have the largest product.
+
+12. The sequence of triangle numbers is generated by adding the natural numbers. So the 7th triangle number would be 1 + 2 + 3 + 4 + 5 + 6 + 7 = 28. The first ten terms would be:
+
+    1, 3, 6, 10, 15, 21, 28, 36, 45, 55, ...
+
+    Let us list the factors of the first seven triangle numbers:
+
+    1: 1
+    3: 1,3
+    6: 1,2,3,6
+    10: 1,2,5,10
+    15: 1,3,5,15
+    21: 1,3,7,21
+    28: 1,2,4,7,14,28
+    We can see that 28 is the first triangle number to have over five divisors.
+
+    What is the value of the first triangle number to have over five hundred divisors?
+    
+13. Work out the first 10 digits of the sum of the given hundred 50 digit numbers.  
+    
 14. The following iterative sequence is defined for the set of positive integers:
     n → n/2 (n is even)
     n → 3n + 1 (n is odd)
     Using the rule above and starting with 13, we generate the following sequence:
     13 → 40 → 20 → 10 → 5 → 16 → 8 → 4 → 2 → 1
     Which starting number, under one million, produces the longest chain?
+    
+15. Starting from top left corner of a 20x20 grid how many routes are there to reach the bottom left corner?
 
 16. 2^15 = 32768 and the sum of its digits is 3 + 2 + 7 + 6 + 8 = 26.
     What is the sum of the digits of the number 2^1000?
+    
+17. If the numbers 1 through 1000 were written in words, how many total letters would be used?
+
+18. By starting at the top of the triangle below and moving to adjacent numbers on the row below, the maximum total from top to bottom is 23.
+   3
+  7 4
+ 2 4 6
+8 5 9 3
+
+That is, 3 + 7 + 4 + 9 = 23.
+
+Find the maximum total from top to bottom of the triangle below:
+
+              75
+             95 64
+            17 47 82
+           18 35 87 10
+          20 04 82 47 65
+         19 01 23 75 03 34
+        88 02 77 73 07 63 67
+       99 65 04 28 06 16 70 92
+      41 41 26 56 83 40 80 70 33
+     41 48 72 33 47 32 37 16 94 29
+    53 71 44 65 25 43 91 52 97 51 14
+   70 11 33 28 77 73 17 78 39 68 17 57
+  91 71 52 38 17 14 91 43 58 50 27 29 48
+ 63 66 04 68 89 53 67 30 73 16 69 87 40 31
+04 62 98 27 23 09 70 98 73 93 38 53 60 04 23
+
 20. n! means n × (n − 1) × ... × 3 × 2 × 1
     For example, 10! = 10 × 9 × ... × 3 × 2 × 1 = 3628800,
     and the sum of the digits in the number 10! is 3 + 6 + 2 + 8 + 8 + 0 + 0 = 27.

From 14c23bc8475a6d1d0ddbab6a6259bf8f30af41cd Mon Sep 17 00:00:00 2001
From: Stephen <24819660+infrontoftheforest@users.noreply.github.com>
Date: Fri, 18 Oct 2019 04:48:16 +0000
Subject: [PATCH 262/348] create qr_decomposition (#1363)

---
 maths/qr_decomposition.py | 71 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 71 insertions(+)
 create mode 100644 maths/qr_decomposition.py

diff --git a/maths/qr_decomposition.py b/maths/qr_decomposition.py
new file mode 100644
index 000000000000..197211f1e694
--- /dev/null
+++ b/maths/qr_decomposition.py
@@ -0,0 +1,71 @@
+import numpy as np
+
+
+def qr_householder(A):
+    """Return a QR-decomposition of the matrix A using Householder reflection.
+
+    The QR-decomposition decomposes the matrix A of shape (m, n) into an
+    orthogonal matrix Q of shape (m, m) and an upper triangular matrix R of
+    shape (m, n).  Note that the matrix A does not have to be square.  This
+    method of decomposing A uses the Householder reflection, which is
+    numerically stable and of complexity O(n^3).
+
+    https://en.wikipedia.org/wiki/QR_decomposition#Using_Householder_reflections
+
+    Arguments:
+    A -- a numpy.ndarray of shape (m, n)
+
+    Note: several optimizations can be made for numeric efficiency, but this is
+    intended to demonstrate how it would be represented in a mathematics
+    textbook.  In cases where efficiency is particularly important, an optimized
+    version from BLAS should be used.
+
+    >>> A = np.array([[12, -51, 4], [6, 167, -68], [-4, 24, -41]], dtype=float)
+    >>> Q, R = qr_householder(A)
+
+    >>> # check that the decomposition is correct
+    >>> np.allclose(Q@R, A)
+    True
+
+    >>> # check that Q is orthogonal
+    >>> np.allclose(Q@Q.T, np.eye(A.shape[0]))
+    True
+    >>> np.allclose(Q.T@Q, np.eye(A.shape[0]))
+    True
+
+    >>> # check that R is upper triangular
+    >>> np.allclose(np.triu(R), R)
+    True
+    """
+    m, n = A.shape
+    t = min(m, n)
+    Q = np.eye(m)
+    R = A.copy()
+
+    for k in range(t - 1):
+        # select a column of modified matrix A':
+        x = R[k:, [k]]
+        # construct first basis vector
+        e1 = np.zeros_like(x)
+        e1[0] = 1.0
+        # determine scaling factor
+        alpha = np.linalg.norm(x)
+        # construct vector v for Householder reflection
+        v = x + np.sign(x[0])*alpha*e1
+        v /= np.linalg.norm(v)
+
+        # construct the Householder matrix
+        Q_k = np.eye(m - k) - 2.0*v@v.T
+        # pad with ones and zeros as necessary
+        Q_k = np.block([[np.eye(k),            np.zeros((k, m - k))],
+                        [np.zeros((m - k, k)), Q_k                 ]])
+
+        Q = Q@Q_k.T
+        R = Q_k@R
+
+    return Q, R
+
+
+if __name__ == "__main__":
+    import doctest
+    doctest.testmod()

From 870eebf349f78047461eb639d60921096179facb Mon Sep 17 00:00:00 2001
From: Yurii <33547678+yuriimchg@users.noreply.github.com>
Date: Fri, 18 Oct 2019 08:27:55 +0300
Subject: [PATCH 263/348] rewrite the algorithm from scratch (#1351)

---
 maths/factorial_python.py | 38 ++++++++++++++++++++------------------
 1 file changed, 20 insertions(+), 18 deletions(-)

diff --git a/maths/factorial_python.py b/maths/factorial_python.py
index 6c1349fd5f4c..10083af0bef2 100644
--- a/maths/factorial_python.py
+++ b/maths/factorial_python.py
@@ -1,19 +1,21 @@
-"""Python program to find the factorial of a number provided by the user."""
+def factorial(input_number: int) -> int:
+    """
+        Non-recursive algorithm of finding factorial of the
+        input number.
+        >>> factorial(1)
+        1
+        >>> factorial(6)
+        720
+        >>> factorial(0)
+        1
+    """
 
-# change the value for a different result
-NUM = 10
-
-# uncomment to take input from the user
-# num = int(input("Enter a number: "))
-
-FACTORIAL = 1
-
-# check if the number is negative, positive or zero
-if NUM < 0:
-    print("Sorry, factorial does not exist for negative numbers")
-elif NUM == 0:
-    print("The factorial of 0 is 1")
-else:
-    for i in range(1, NUM + 1):
-        FACTORIAL = FACTORIAL * i
-    print("The factorial of", NUM, "is", FACTORIAL)
+    if input_number < 0:
+        raise ValueError('Input input_number should be non-negative')
+    elif input_number == 0:
+        return 1
+    else:
+        result = 1
+        for i in range(input_number):
+            result = result * (i + 1)
+    return result

From 3cc35310769b5681201e0fb2828ee4e40d947f05 Mon Sep 17 00:00:00 2001
From: Yurii <33547678+yuriimchg@users.noreply.github.com>
Date: Fri, 18 Oct 2019 08:35:29 +0300
Subject: [PATCH 264/348] Feature/update least common multiple (#1352)

* renamed module to extend the acronym

* add type hints (will not work with Python less than 3.4)

* update docstring

* refactor the function

* add unittests for the least common squares multiple
---
 maths/find_lcm.py              | 34 --------------------------
 maths/least_common_multiple.py | 44 ++++++++++++++++++++++++++++++++++
 2 files changed, 44 insertions(+), 34 deletions(-)
 delete mode 100644 maths/find_lcm.py
 create mode 100644 maths/least_common_multiple.py

diff --git a/maths/find_lcm.py b/maths/find_lcm.py
deleted file mode 100644
index dffadd1f3c5b..000000000000
--- a/maths/find_lcm.py
+++ /dev/null
@@ -1,34 +0,0 @@
-"""Find Least Common Multiple."""
-
-# https://en.wikipedia.org/wiki/Least_common_multiple
-
-
-def find_lcm(num_1, num_2):
-    """Find the least common multiple of two numbers.
-       >>> find_lcm(5,2)
-       10
-       >>> find_lcm(12,76)
-       228
-    """
-    if num_1 >= num_2:
-        max_num = num_1
-    else:
-        max_num = num_2
-
-    lcm = max_num
-    while True:
-        if (lcm % num_1 == 0) and (lcm % num_2 == 0):
-            break
-        lcm += max_num
-    return lcm
-
-
-def main():
-    """Use test numbers to run the find_lcm algorithm."""
-    num_1 = int(input().strip())
-    num_2 = int(input().strip())
-    print(find_lcm(num_1, num_2))
-
-
-if __name__ == "__main__":
-    main()
diff --git a/maths/least_common_multiple.py b/maths/least_common_multiple.py
new file mode 100644
index 000000000000..863744e182b6
--- /dev/null
+++ b/maths/least_common_multiple.py
@@ -0,0 +1,44 @@
+import unittest
+
+
+def find_lcm(first_num: int, second_num: int) -> int:
+    """Find the least common multiple of two numbers.
+
+       Learn more: https://en.wikipedia.org/wiki/Least_common_multiple
+
+       >>> find_lcm(5,2)
+       10
+       >>> find_lcm(12,76)
+       228
+    """
+    max_num = first_num if first_num >= second_num else second_num
+    common_mult = max_num
+    while (common_mult % first_num > 0) or (common_mult % second_num > 0):
+        common_mult += max_num
+    return common_mult
+
+
+class TestLeastCommonMultiple(unittest.TestCase):
+
+    test_inputs = [
+        (10, 20),
+        (13, 15),
+        (4, 31),
+        (10, 42),
+        (43, 34),
+        (5, 12),
+        (12, 25),
+        (10, 25),
+        (6, 9),
+    ]
+    expected_results = [20, 195, 124, 210, 1462, 60, 300, 50, 18]
+
+    def test_lcm_function(self):
+        for i, (first_num, second_num) in enumerate(self.test_inputs):
+            actual_result = find_lcm(first_num, second_num)
+            with self.subTest(i=i):
+                self.assertEqual(actual_result, self.expected_results[i])
+
+
+if __name__ == "__main__":
+    unittest.main()

From b7fb0630f2c466412337d25d2e611eeef7bc381b Mon Sep 17 00:00:00 2001
From: Yurii <33547678+yuriimchg@users.noreply.github.com>
Date: Fri, 18 Oct 2019 08:36:52 +0300
Subject: [PATCH 265/348] Feature/fix caesar cipher (#1350)

* change var names for better reading

* rewrite encrypt function to fix ascii char ranges

* fix decrypt function

* update formatting (add f-strings)

* upd fuctions

* add f-string formatting (python3.6+)

* add type hints (python3.4+)
---
 ciphers/caesar_cipher.py | 69 ++++++++++++++++++++--------------------
 1 file changed, 35 insertions(+), 34 deletions(-)

diff --git a/ciphers/caesar_cipher.py b/ciphers/caesar_cipher.py
index 3f24e049afb0..52155bbdc49e 100644
--- a/ciphers/caesar_cipher.py
+++ b/ciphers/caesar_cipher.py
@@ -1,61 +1,62 @@
-def encrypt(strng, key):
-    encrypted = ""
-    for x in strng:
-        indx = (ord(x) + key) % 256
-        if indx > 126:
-            indx = indx - 95
-        encrypted = encrypted + chr(indx)
-    return encrypted
+def encrypt(input_string: str, key: int) -> str:
+    result = ''
+    for x in input_string:
+        if not x.isalpha():
+            result += x
+        elif x.isupper():
+            result += chr((ord(x) + key - 65) % 26 + 65)
+        elif x.islower():
+            result += chr((ord(x) + key - 97) % 26 + 97)
+    return result
 
 
-def decrypt(strng, key):
-    decrypted = ""
-    for x in strng:
-        indx = (ord(x) - key) % 256
-        if indx < 32:
-            indx = indx + 95
-        decrypted = decrypted + chr(indx)
-    return decrypted
+def decrypt(input_string: str, key: int) -> str:
+    result = ''
+    for x in input_string:
+        if not x.isalpha():
+            result += x
+        elif x.isupper():
+            result += chr((ord(x) - key - 65) % 26 + 65)
+        elif x.islower():
+            result += chr((ord(x) - key - 97) % 26 + 97)
+    return result
 
 
-def brute_force(strng):
+def brute_force(input_string: str) -> None:
     key = 1
-    decrypted = ""
+    result = ''
     while key <= 94:
-        for x in strng:
+        for x in input_string:
             indx = (ord(x) - key) % 256
             if indx < 32:
                 indx = indx + 95
-            decrypted = decrypted + chr(indx)
-        print("Key: {}\t| Message: {}".format(key, decrypted))
-        decrypted = ""
+            result = result + chr(indx)
+        print(f'Key: {key}\t| Message: {result}')
+        result = ''
         key += 1
     return None
 
 
 def main():
     while True:
-        print("-" * 10 + "\n**Menu**\n" + "-" * 10)
-        print("1.Encrpyt")
-        print("2.Decrypt")
-        print("3.BruteForce")
-        print("4.Quit")
+        print(f'{"-" * 10}\n Menu\n{"-", * 10}')
+        print(*["1.Encrpyt", "2.Decrypt", "3.BruteForce", "4.Quit"], sep='\n')
         choice = input("What would you like to do?: ")
         if choice not in ["1", "2", "3", "4"]:
             print("Invalid choice, please enter a valid choice")
         elif choice == "1":
-            strng = input("Please enter the string to be encrypted: ")
-            key = int(input("Please enter off-set between 1-94: "))
+            input_string = input("Please enter the string to be encrypted: ")
+            key = int(input("Please enter off-set between 0-25: "))
             if key in range(1, 95):
-                print(encrypt(strng.lower(), key))
+                print(encrypt(input_string.lower(), key))
         elif choice == "2":
-            strng = input("Please enter the string to be decrypted: ")
+            input_string = input("Please enter the string to be decrypted: ")
             key = int(input("Please enter off-set between 1-94: "))
             if key in range(1, 95):
-                print(decrypt(strng, key))
+                print(decrypt(input_string, key))
         elif choice == "3":
-            strng = input("Please enter the string to be decrypted: ")
-            brute_force(strng)
+            input_string = input("Please enter the string to be decrypted: ")
+            brute_force(input_string)
             main()
         elif choice == "4":
             print("Goodbye.")

From 9c634735d39a6d51aa94b0c92cf0473af72439f1 Mon Sep 17 00:00:00 2001
From: Laisha Wadhwa <laisha.w16@iiits.in>
Date: Fri, 18 Oct 2019 11:40:08 +0530
Subject: [PATCH 266/348] added fibonacci_search.py (#1341)

* added fibonacci_search.py

* added Fibonacci_search.py after error handling

* added doctests
---
 searches/fibonacci_search.py | 50 ++++++++++++++++++++++++++++++++++++
 1 file changed, 50 insertions(+)
 create mode 100644 searches/fibonacci_search.py

diff --git a/searches/fibonacci_search.py b/searches/fibonacci_search.py
new file mode 100644
index 000000000000..f76528b9c283
--- /dev/null
+++ b/searches/fibonacci_search.py
@@ -0,0 +1,50 @@
+#run using python fibonacci_search.py -v
+
+'''
+@params
+arr: input array
+val: the value to be searched
+output: the index of element in the array or -1 if not found
+return 0 if input array is empty
+'''
+def fibonacci_search(arr, val):
+
+    """
+    >>> fibonacci_search([1,6,7,0,0,0], 6)
+    1
+    >>> fibonacci_search([1,-1, 5, 2, 9], 10)
+    -1
+    >>> fibonacci_search([], 9)
+    0
+    """
+    fib_N_2 = 0
+    fib_N_1 = 1
+    fibNext = fib_N_1 + fib_N_2
+    length = len(arr)
+    if length == 0:
+    	return 0
+    while (fibNext < len(arr)):
+        fib_N_2 = fib_N_1
+        fib_N_1 = fibNext
+        fibNext = fib_N_1 + fib_N_2
+    index = -1;
+    while (fibNext > 1):
+        i = min(index + fib_N_2, (length-1))
+        if (arr[i] < val):
+            fibNext = fib_N_1
+            fib_N_1 = fib_N_2
+            fib_N_2 = fibNext - fib_N_1
+            index = i
+        elif (arr[i] > val):
+            fibNext = fib_N_2
+            fib_N_1 = fib_N_1 - fib_N_2
+            fib_N_2 = fibNext - fib_N_1
+        else :
+            return i
+    if (fib_N_1 and index < length-1) and (arr[index+1] == val):
+        return index+1;
+    return -1
+
+if __name__ == "__main__":
+    import doctest
+    doctest.testmod()

From ddb094919b8af4b1268e118fa3e33868c30f4386 Mon Sep 17 00:00:00 2001
From: Jigyasa G <jigsgandhi97@gmail.com>
Date: Fri, 18 Oct 2019 11:43:20 +0530
Subject: [PATCH 267/348] Adding doctests for fractional_knapsack.py (#1331)

* Adding doctests for fractional_knapsack.py

* Update fractional_knapsack.py
---
 dynamic_programming/fractional_knapsack.py | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/dynamic_programming/fractional_knapsack.py b/dynamic_programming/fractional_knapsack.py
index 881b6a3969d0..728cdeb009ac 100644
--- a/dynamic_programming/fractional_knapsack.py
+++ b/dynamic_programming/fractional_knapsack.py
@@ -3,6 +3,10 @@
 
 
 def fracKnapsack(vl, wt, W, n):
+    """
+    >>> fracKnapsack([60, 100, 120], [10, 20, 30], 50, 3)
+    240.0
+    """
 
     r = list(sorted(zip(vl, wt), key=lambda x: x[0] / x[1], reverse=True))
     vl, wt = [i[0] for i in r], [i[1] for i in r]
@@ -16,5 +20,7 @@ def fracKnapsack(vl, wt, W, n):
         else sum(vl[:k])
     )
 
+if __name__ == "__main__":
+    import doctest
 
-print("%.0f" % fracKnapsack([60, 100, 120], [10, 20, 30], 50, 3))
+    doctest.testmod()

From 455509acee831cb4a8c3bf9d495fd0e296825c68 Mon Sep 17 00:00:00 2001
From: Phyllipe Bezerra <32442929+pmba@users.noreply.github.com>
Date: Fri, 18 Oct 2019 03:13:58 -0300
Subject: [PATCH 268/348] Add Topological Sort (#1302)

* add topological sort

* fix topological sort?

* running black

* renaming file
---
 blockchain/chinese_remainder_theorem.py  | 12 +++---
 blockchain/diophantine_equation.py       | 16 +++++---
 blockchain/modular_division.py           | 16 ++++----
 graphs/g_topological_sort.py             | 47 ++++++++++++++++++++++++
 machine_learning/k_nearest_neighbours.py | 14 ++++---
 maths/fibonacci_sequence_recursion.py    |  2 +-
 maths/sum_of_arithmetic_series.py        |  3 +-
 sorts/stooge_sort.py                     |  1 +
 8 files changed, 84 insertions(+), 27 deletions(-)
 create mode 100644 graphs/g_topological_sort.py

diff --git a/blockchain/chinese_remainder_theorem.py b/blockchain/chinese_remainder_theorem.py
index f1409530a70e..8c3eb9b4b01e 100644
--- a/blockchain/chinese_remainder_theorem.py
+++ b/blockchain/chinese_remainder_theorem.py
@@ -44,7 +44,7 @@ def chinese_remainder_theorem(n1, r1, n2, r2):
     (x, y) = extended_euclid(n1, n2)
     m = n1 * n2
     n = r2 * x * n1 + r1 * y * n2
-    return ((n % m + m) % m)
+    return (n % m + m) % m
 
 
 # ----------SAME SOLUTION USING InvertModulo instead ExtendedEuclid----------------
@@ -84,8 +84,8 @@ def chinese_remainder_theorem2(n1, r1, n2, r2):
 # import testmod for testing our function
 from doctest import testmod
 
-if __name__ == '__main__':
-    testmod(name='chinese_remainder_theorem', verbose=True)
-    testmod(name='chinese_remainder_theorem2', verbose=True)
-    testmod(name='invert_modulo', verbose=True)
-    testmod(name='extended_euclid', verbose=True)
+if __name__ == "__main__":
+    testmod(name="chinese_remainder_theorem", verbose=True)
+    testmod(name="chinese_remainder_theorem2", verbose=True)
+    testmod(name="invert_modulo", verbose=True)
+    testmod(name="extended_euclid", verbose=True)
diff --git a/blockchain/diophantine_equation.py b/blockchain/diophantine_equation.py
index 3ac7094eed6b..ec2ed26e40ec 100644
--- a/blockchain/diophantine_equation.py
+++ b/blockchain/diophantine_equation.py
@@ -17,7 +17,9 @@ def diophantine(a, b, c):
 
     """
 
-    assert c % greatest_common_divisor(a, b) == 0  # greatest_common_divisor(a,b) function implemented below
+    assert (
+        c % greatest_common_divisor(a, b) == 0
+    )  # greatest_common_divisor(a,b) function implemented below
     (d, x, y) = extended_gcd(a, b)  # extended_gcd(a,b) function implemented below
     r = c / d
     return (r * x, r * y)
@@ -32,6 +34,7 @@ def diophantine(a, b, c):
 
 # n is the number of solution you want, n = 2 by default
 
+
 def diophantine_all_soln(a, b, c, n=2):
     """
     >>> diophantine_all_soln(10, 6, 14)
@@ -66,6 +69,7 @@ def diophantine_all_soln(a, b, c, n=2):
 
 # Euclid's Algorithm
 
+
 def greatest_common_divisor(a, b):
     """
     >>> greatest_common_divisor(7,5)
@@ -117,8 +121,8 @@ def extended_gcd(a, b):
 # import testmod for testing our function
 from doctest import testmod
 
-if __name__ == '__main__':
-    testmod(name='diophantine', verbose=True)
-    testmod(name='diophantine_all_soln', verbose=True)
-    testmod(name='extended_gcd', verbose=True)
-    testmod(name='greatest_common_divisor', verbose=True)
+if __name__ == "__main__":
+    testmod(name="diophantine", verbose=True)
+    testmod(name="diophantine_all_soln", verbose=True)
+    testmod(name="extended_gcd", verbose=True)
+    testmod(name="greatest_common_divisor", verbose=True)
diff --git a/blockchain/modular_division.py b/blockchain/modular_division.py
index 4e1623fbe923..1255f04328d5 100644
--- a/blockchain/modular_division.py
+++ b/blockchain/modular_division.py
@@ -70,6 +70,7 @@ def modular_division2(a, b, n):
 
 # Extended Euclid's Algorithm : If d divides a and b and d = a*x + b*y for integers x and y, then d = gcd(a,b)
 
+
 def extended_gcd(a, b):
     """
     >>> extended_gcd(10, 6)
@@ -116,6 +117,7 @@ def extended_euclid(a, b):
 # Euclid's Lemma :  d divides a and b, if and only if d divides a-b and b
 # Euclid's Algorithm
 
+
 def greatest_common_divisor(a, b):
     """
     >>> greatest_common_divisor(7,5)
@@ -140,10 +142,10 @@ def greatest_common_divisor(a, b):
 # Import testmod for testing our function
 from doctest import testmod
 
-if __name__ == '__main__':
-    testmod(name='modular_division', verbose=True)
-    testmod(name='modular_division2', verbose=True)
-    testmod(name='invert_modulo', verbose=True)
-    testmod(name='extended_gcd', verbose=True)
-    testmod(name='extended_euclid', verbose=True)
-    testmod(name='greatest_common_divisor', verbose=True)
+if __name__ == "__main__":
+    testmod(name="modular_division", verbose=True)
+    testmod(name="modular_division2", verbose=True)
+    testmod(name="invert_modulo", verbose=True)
+    testmod(name="extended_gcd", verbose=True)
+    testmod(name="extended_euclid", verbose=True)
+    testmod(name="greatest_common_divisor", verbose=True)
diff --git a/graphs/g_topological_sort.py b/graphs/g_topological_sort.py
new file mode 100644
index 000000000000..1a2f4fa11d88
--- /dev/null
+++ b/graphs/g_topological_sort.py
@@ -0,0 +1,47 @@
+# Author: Phyllipe Bezerra (https://github.com/pmba)
+
+clothes = {
+    0: "underwear",
+    1: "pants",
+    2: "belt",
+    3: "suit",
+    4: "shoe",
+    5: "socks",
+    6: "shirt",
+    7: "tie",
+    8: "clock",
+}
+
+graph = [[1, 4], [2, 4], [3], [], [], [4], [2, 7], [3], []]
+
+visited = [0 for x in range(len(graph))]
+stack = []
+
+
+def print_stack(stack, clothes):
+    order = 1
+    while stack:
+        cur_clothe = stack.pop()
+        print(order, clothes[cur_clothe])
+        order += 1
+
+
+def dfs(u, visited, graph):
+    visited[u] = 1
+    for v in graph[u]:
+        if not visited[v]:
+            dfs(v, visited, graph)
+
+    stack.append(u)
+
+
+def top_sort(graph, visited):
+    for v in range(len(graph)):
+        if not visited[v]:
+            dfs(v, visited, graph)
+
+
+if __name__ == "__main__":
+    top_sort(graph, visited)
+    print(stack)
+    print_stack(stack, clothes)
diff --git a/machine_learning/k_nearest_neighbours.py b/machine_learning/k_nearest_neighbours.py
index 83d8399fe9b6..a60b744bc65e 100644
--- a/machine_learning/k_nearest_neighbours.py
+++ b/machine_learning/k_nearest_neighbours.py
@@ -5,12 +5,13 @@
 
 data = datasets.load_iris()
 
-X = np.array(data['data'])
-y = np.array(data['target'])
-classes = data['target_names']
+X = np.array(data["data"])
+y = np.array(data["target"])
+classes = data["target_names"]
 
 X_train, X_test, y_train, y_test = train_test_split(X, y)
 
+
 def euclidean_distance(a, b):
     """
     Gives the euclidean distance between two points
@@ -21,6 +22,7 @@ def euclidean_distance(a, b):
     """
     return np.linalg.norm(np.array(a) - np.array(b))
 
+
 def classifier(train_data, train_target, classes, point, k=5):
     """
     Classifies the point using the KNN algorithm
@@ -43,13 +45,13 @@ def classifier(train_data, train_target, classes, point, k=5):
     for data_point in data:
         distance = euclidean_distance(data_point[0], point)
         distances.append((distance, data_point[1]))
-    # Choosing 'k' points with the least distances. 
+    # Choosing 'k' points with the least distances.
     votes = [i[1] for i in sorted(distances)[:k]]
-    # Most commonly occuring class among them 
+    # Most commonly occuring class among them
     # is the class into which the point is classified
     result = Counter(votes).most_common(1)[0][0]
     return classes[result]
 
 
 if __name__ == "__main__":
-    print(classifier(X_train, y_train, classes, [4.4, 3.1, 1.3, 1.4]))
\ No newline at end of file
+    print(classifier(X_train, y_train, classes, [4.4, 3.1, 1.3, 1.4]))
diff --git a/maths/fibonacci_sequence_recursion.py b/maths/fibonacci_sequence_recursion.py
index 2e0d835cf15e..91619600d5b4 100644
--- a/maths/fibonacci_sequence_recursion.py
+++ b/maths/fibonacci_sequence_recursion.py
@@ -6,7 +6,7 @@ def recur_fibo(n):
     >>> [recur_fibo(i) for i in range(12)]
     [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
     """
-    return n if n <= 1 else recur_fibo(n-1) + recur_fibo(n-2)
+    return n if n <= 1 else recur_fibo(n - 1) + recur_fibo(n - 2)
 
 
 def main():
diff --git a/maths/sum_of_arithmetic_series.py b/maths/sum_of_arithmetic_series.py
index f7ea5dc84cb8..74eef0f18a12 100755
--- a/maths/sum_of_arithmetic_series.py
+++ b/maths/sum_of_arithmetic_series.py
@@ -8,7 +8,7 @@ def sum_of_series(first_term, common_diff, num_of_terms):
     >>> sum_of_series(1, 10, 100)
     49600.0
     """
-    sum = ((num_of_terms/2)*(2*first_term+(num_of_terms-1)*common_diff))
+    sum = (num_of_terms / 2) * (2 * first_term + (num_of_terms - 1) * common_diff)
     # formula for sum of series
     return sum
 
@@ -19,4 +19,5 @@ def main():
 
 if __name__ == "__main__":
     import doctest
+
     doctest.testmod()
diff --git a/sorts/stooge_sort.py b/sorts/stooge_sort.py
index 089b01a4def1..de997a85df12 100644
--- a/sorts/stooge_sort.py
+++ b/sorts/stooge_sort.py
@@ -33,6 +33,7 @@ def stooge(arr, i, h):
         # Recursively sort first 2/3 elements
         stooge(arr, i, (h - t))
 
+
 if __name__ == "__main__":
     user_input = input("Enter numbers separated by a comma:\n").strip()
     unsorted = [int(item) for item in user_input.split(",")]

From 2197bfa029641c1695f8172ecf95f25dad9ddd0d Mon Sep 17 00:00:00 2001
From: archit kaushal <38643326+archu5@users.noreply.github.com>
Date: Fri, 18 Oct 2019 11:50:22 +0530
Subject: [PATCH 269/348] #840 adds polymonial regression program in python
 (#1235)

* #840 adds polymonial regression program in python

* Update polymonial_regression.py

* Update polymonial_regression.py
---
 machine_learning/polymonial_regression.py | 37 +++++++++++++++++++++++
 1 file changed, 37 insertions(+)
 create mode 100644 machine_learning/polymonial_regression.py

diff --git a/machine_learning/polymonial_regression.py b/machine_learning/polymonial_regression.py
new file mode 100644
index 000000000000..03f5f0a9713d
--- /dev/null
+++ b/machine_learning/polymonial_regression.py
@@ -0,0 +1,37 @@
+import matplotlib.pyplot as plt
+import pandas as pd
+
+# Importing the dataset
+dataset = pd.read_csv('https://s3.us-west-2.amazonaws.com/public.gamelab.fun/dataset/position_salaries.csv')
+X = dataset.iloc[:, 1:2].values
+y = dataset.iloc[:, 2].values
+
+
+# Splitting the dataset into the Training set and Test set
+from sklearn.model_selection import train_test_split 
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
+
+
+# Fitting Polynomial Regression to the dataset
+from sklearn.preprocessing import PolynomialFeatures
+from sklearn.linear_model import LinearRegression
+poly_reg = PolynomialFeatures(degree=4)
+X_poly = poly_reg.fit_transform(X)
+pol_reg = LinearRegression()
+pol_reg.fit(X_poly, y)
+
+
+# Visualizing the Polymonial Regression results
+def viz_polymonial():
+    plt.scatter(X, y, color='red')
+    plt.plot(X, pol_reg.predict(poly_reg.fit_transform(X)), color='blue')
+    plt.title('Truth or Bluff (Linear Regression)')
+    plt.xlabel('Position level')
+    plt.ylabel('Salary')
+    plt.show()
+    return
+viz_polymonial()
+
+# Predicting a new result with Polymonial Regression
+pol_reg.predict(poly_reg.fit_transform([[5.5]]))
+#output should be 132148.43750003

From e177198177695d70cd17c351fce7033c9f4f2789 Mon Sep 17 00:00:00 2001
From: Pierrick <43653255+laurent-pck@users.noreply.github.com>
Date: Fri, 18 Oct 2019 08:35:13 +0200
Subject: [PATCH 270/348] Add unicode support in ciphers/base64_cipher.py
 script. (#1316)

* Add unicode support in ciphers/base64_cipher.py script.

* Add doctests and correct the padding length computation in base64_cipher.
---
 ciphers/base64_cipher.py | 57 ++++++++++++++++++++++++++--------------
 1 file changed, 37 insertions(+), 20 deletions(-)

diff --git a/ciphers/base64_cipher.py b/ciphers/base64_cipher.py
index 9fca5b02679f..eea065b94ee0 100644
--- a/ciphers/base64_cipher.py
+++ b/ciphers/base64_cipher.py
@@ -1,35 +1,52 @@
-def encodeBase64(text):
-    base64chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
-
+def encode_base64(text):
+    r"""
+    >>> encode_base64('WELCOME to base64 encoding 😁')
+    'V0VMQ09NRSB0byBiYXNlNjQgZW5jb2Rpbmcg8J+YgQ=='
+    >>> encode_base64('AÅᐃ𐀏🤓')
+    'QcOF4ZCD8JCAj/CfpJM='
+    >>> encode_base64('A'*60)
+    'QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB\r\nQUFB'
+    """
+    base64_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
+
+    byte_text = bytes(text, "utf-8")  # put text in bytes for unicode support
     r = ""  # the result
-    c = 3 - len(text) % 3  # the length of padding
+    c = -len(byte_text) % 3  # the length of padding
     p = "=" * c  # the padding
-    s = text + "\0" * c  # the text to encode
+    s = byte_text + b"\x00" * c  # the text to encode
 
     i = 0
     while i < len(s):
         if i > 0 and ((i / 3 * 4) % 76) == 0:
-            r = r + "\r\n"
+            r = r + "\r\n" # for unix newline, put "\n"
 
-        n = (ord(s[i]) << 16) + (ord(s[i + 1]) << 8) + ord(s[i + 2])
+        n = (s[i] << 16) + (s[i + 1] << 8) + s[i + 2]
 
         n1 = (n >> 18) & 63
         n2 = (n >> 12) & 63
         n3 = (n >> 6) & 63
         n4 = n & 63
 
-        r += base64chars[n1] + base64chars[n2] + base64chars[n3] + base64chars[n4]
+        r += base64_chars[n1] + base64_chars[n2] + base64_chars[n3] + base64_chars[n4]
         i += 3
 
     return r[0 : len(r) - len(p)] + p
 
 
-def decodeBase64(text):
-    base64chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
+def decode_base64(text):
+    r"""
+    >>> decode_base64('V0VMQ09NRSB0byBiYXNlNjQgZW5jb2Rpbmcg8J+YgQ==')
+    'WELCOME to base64 encoding 😁'
+    >>> decode_base64('QcOF4ZCD8JCAj/CfpJM=')
+    'AÅᐃ𐀏🤓'
+    >>> decode_base64("QUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFB\r\nQUFB")
+    'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+    """
+    base64_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
     s = ""
 
     for i in text:
-        if i in base64chars:
+        if i in base64_chars:
             s += i
             c = ""
         else:
@@ -43,28 +60,28 @@ def decodeBase64(text):
         if c == "==":
             p = "AA"
 
-    r = ""
+    r = b""
     s = s + p
 
     i = 0
     while i < len(s):
         n = (
-            (base64chars.index(s[i]) << 18)
-            + (base64chars.index(s[i + 1]) << 12)
-            + (base64chars.index(s[i + 2]) << 6)
-            + base64chars.index(s[i + 3])
+            (base64_chars.index(s[i]) << 18)
+            + (base64_chars.index(s[i + 1]) << 12)
+            + (base64_chars.index(s[i + 2]) << 6)
+            + base64_chars.index(s[i + 3])
         )
 
-        r += chr((n >> 16) & 255) + chr((n >> 8) & 255) + chr(n & 255)
+        r += bytes([(n >> 16) & 255]) + bytes([(n >> 8) & 255]) + bytes([n & 255])
 
         i += 4
 
-    return r[0 : len(r) - len(p)]
+    return str(r[0 : len(r) - len(p)], "utf-8")
 
 
 def main():
-    print(encodeBase64("WELCOME to base64 encoding"))
-    print(decodeBase64(encodeBase64("WELCOME to base64 encoding")))
+    print(encode_base64("WELCOME to base64 encoding 😁"))
+    print(decode_base64(encode_base64("WELCOME to base64 encoding 😁")))
 
 
 if __name__ == "__main__":

From 7376addcd5f786a3c46e48e5600cf88d363015c3 Mon Sep 17 00:00:00 2001
From: Mariusz Skoneczko <mariusz@skoneczko.com>
Date: Fri, 18 Oct 2019 17:38:31 +1100
Subject: [PATCH 271/348] Implement Linked Queue and Linked Stack data
 structures (#1324)

* Add LinkedQueue

* Add LinkedStack
---
 data_structures/queue/linked_queue.py  | 74 ++++++++++++++++++++++++++
 data_structures/stacks/linked_stack.py | 67 +++++++++++++++++++++++
 2 files changed, 141 insertions(+)
 create mode 100644 data_structures/queue/linked_queue.py
 create mode 100644 data_structures/stacks/linked_stack.py

diff --git a/data_structures/queue/linked_queue.py b/data_structures/queue/linked_queue.py
new file mode 100644
index 000000000000..614c60cd1ae2
--- /dev/null
+++ b/data_structures/queue/linked_queue.py
@@ -0,0 +1,74 @@
+""" A Queue using a Linked List like structure """
+from typing import Any, Optional
+
+
+class Node:
+    def __init__(self, data: Any, next: Optional["Node"] = None):
+        self.data: Any = data
+        self.next: Optional["Node"] = next
+
+
+class LinkedQueue:
+    """
+    Linked List Queue implementing put (to end of queue),
+    get (from front of queue) and is_empty
+
+    >>> queue = LinkedQueue()
+    >>> queue.is_empty()
+    True
+    >>> queue.put(5)
+    >>> queue.put(9)
+    >>> queue.put('python')
+    >>> queue.is_empty();
+    False
+    >>> queue.get()
+    5
+    >>> queue.put('algorithms')
+    >>> queue.get()
+    9
+    >>> queue.get()
+    'python'
+    >>> queue.get()
+    'algorithms'
+    >>> queue.is_empty()
+    True
+    >>> queue.get()
+    Traceback (most recent call last):
+        ...
+    IndexError: get from empty queue
+    """
+
+    def __init__(self) -> None:
+        self.front: Optional[Node] = None
+        self.rear: Optional[Node] = None
+
+    def is_empty(self) -> bool:
+        """ returns boolean describing if queue is empty """
+        return self.front is None
+
+    def put(self, item: Any) -> None:
+        """ append item to rear of queue """
+        node: Node = Node(item)
+        if self.is_empty():
+            # the queue contains just the single element
+            self.front = node
+            self.rear = node
+        else:
+            # not empty, so we add it to the rear of the queue
+            assert isinstance(self.rear, Node)
+            self.rear.next = node
+            self.rear = node
+
+    def get(self) -> Any:
+        """ returns and removes item at front of queue """
+        if self.is_empty():
+            raise IndexError("get from empty queue")
+        else:
+            # "remove" element by having front point to the next one
+            assert isinstance(self.front, Node)
+            node: Node = self.front
+            self.front = node.next
+            if self.front is None:
+                self.rear = None
+
+            return node.data
diff --git a/data_structures/stacks/linked_stack.py b/data_structures/stacks/linked_stack.py
new file mode 100644
index 000000000000..18ba87ddc221
--- /dev/null
+++ b/data_structures/stacks/linked_stack.py
@@ -0,0 +1,67 @@
+""" A Stack using a Linked List like structure """
+from typing import Any, Optional
+
+
+class Node:
+    def __init__(self, data: Any, next: Optional["Node"] = None):
+        self.data: Any = data
+        self.next: Optional["Node"] = next
+
+
+class LinkedStack:
+    """
+    Linked List Stack implementing push (to top),
+    pop (from top) and is_empty
+
+    >>> stack = LinkedStack()
+    >>> stack.is_empty()
+    True
+    >>> stack.push(5)
+    >>> stack.push(9)
+    >>> stack.push('python')
+    >>> stack.is_empty();
+    False
+    >>> stack.pop()
+    'python'
+    >>> stack.push('algorithms')
+    >>> stack.pop()
+    'algorithms'
+    >>> stack.pop()
+    9
+    >>> stack.pop()
+    5
+    >>> stack.is_empty()
+    True
+    >>> stack.pop()
+    Traceback (most recent call last):
+        ...
+    IndexError: pop from empty stack
+    """
+
+    def __init__(self) -> None:
+        self.top: Optional[Node] = None
+
+    def is_empty(self) -> bool:
+        """ returns boolean describing if stack is empty """
+        return self.top is None
+
+    def push(self, item: Any) -> None:
+        """ append item to top of stack """
+        node: Node = Node(item)
+        if self.is_empty():
+            self.top = node
+        else:
+            # each node points to the item "lower" in the stack
+            node.next = self.top
+            self.top = node
+
+    def pop(self) -> Any:
+        """ returns and removes item at top of stack """
+        if self.is_empty():
+            raise IndexError("pop from empty stack")
+        else:
+            # "remove" element by having top point to the next one
+            assert isinstance(self.top, Node)
+            node: Node = self.top
+            self.top = node.next
+            return node.data

From 179284a41bf265c59913b72d94bee47d7d6b7414 Mon Sep 17 00:00:00 2001
From: Hocnonsense <48747984+Hocnonsense@users.noreply.github.com>
Date: Fri, 18 Oct 2019 15:39:37 +0800
Subject: [PATCH 272/348] Update treap.py (#1358)

* Update treap.py

check merge()

* Update treap.py

random() is used. its difficult to write doctests
l->left
r->right
key->value
add __repr__ and __str__ in preorder
---
 data_structures/binary_tree/treap.py | 188 +++++++++++++++++----------
 1 file changed, 116 insertions(+), 72 deletions(-)

diff --git a/data_structures/binary_tree/treap.py b/data_structures/binary_tree/treap.py
index 5d34abc3c931..0b5947f4cc04 100644
--- a/data_structures/binary_tree/treap.py
+++ b/data_structures/binary_tree/treap.py
@@ -2,129 +2,173 @@
 from typing import Tuple
 
 
-class Node:
+class Node(object):
     """
     Treap's node
-    Treap is a binary tree by key and heap by priority
+    Treap is a binary tree by value and heap by priority
     """
-
-    def __init__(self, key: int):
-        self.key = key
+    def __init__(self, value: int = None):
+        self.value = value
         self.prior = random()
-        self.l = None
-        self.r = None
+        self.left = None
+        self.right = None
 
+    def __repr__(self):
+        from pprint import pformat
 
-def split(root: Node, key: int) -> Tuple[Node, Node]:
+        if self.left is None and self.right is None:
+            return "'%s: %.5s'" % (self.value, self.prior)
+        else:
+            return pformat(
+                {
+                    "%s: %.5s"
+                    % (self.value, self.prior): (self.left, self.right)
+                },
+                indent=1,
+            )
+
+    def __str__(self):
+        value = str(self.value) + " "
+        left = str(self.left or "")
+        right = str(self.right or "")
+        return value + left + right
+
+def split(root: Node, value: int) -> Tuple[Node, Node]:
     """
-    We split current tree into 2 trees with key:
+    We split current tree into 2 trees with value:
 
-    Left tree contains all keys less than split key.
-    Right tree contains all keys greater or equal, than split key
+    Left tree contains all values less than split value.
+    Right tree contains all values greater or equal, than split value
     """
     if root is None:  # None tree is split into 2 Nones
         return (None, None)
-    if root.key >= key:
-        """
-        Right tree's root will be current node.
-        Now we split(with the same key) current node's left son
-        Left tree: left part of that split
-        Right tree's left son: right part of that split
-        """
-        l, root.l = split(root.l, key)
-        return (l, root)
+    elif root.value is None:
+        return (None, None)
     else:
-        """
-        Just symmetric to previous case
-        """
-        root.r, r = split(root.r, key)
-        return (root, r)
-
+        if value < root.value:
+            """
+            Right tree's root will be current node.
+            Now we split(with the same value) current node's left son
+            Left tree: left part of that split
+            Right tree's left son: right part of that split
+            """
+            left, root.left = split(root.left, value)
+            return (left, root)
+        else:
+            """
+            Just symmetric to previous case
+            """
+            root.right, right = split(root.right, value)
+            return (root, right)
 
 def merge(left: Node, right: Node) -> Node:
     """
     We merge 2 trees into one.
-    Note: all left tree's keys must be less than all right tree's
+    Note: all left tree's values must be less than all right tree's
     """
-    if (not left) or (not right):
-        """
-        If one node is None, return the other
-        """
+    if (not left) or (not right):   # If one node is None, return the other
         return left or right
-    if left.key > right.key:
+    elif left.prior < right.prior:
         """
         Left will be root because it has more priority
         Now we need to merge left's right son and right tree
         """
-        left.r = merge(left.r, right)
+        left.right = merge(left.right, right)
         return left
     else:
         """
         Symmetric as well
         """
-        right.l = merge(left, right.l)
+        right.left = merge(left, right.left)
         return right
 
-
-def insert(root: Node, key: int) -> Node:
+def insert(root: Node, value: int) -> Node:
     """
     Insert element
 
-    Split current tree with a key into l, r,
+    Split current tree with a value into left, right,
     Insert new node into the middle
-    Merge l, node, r into root
+    Merge left, node, right into root
     """
-    node = Node(key)
-    l, r = split(root, key)
-    root = merge(l, node)
-    root = merge(root, r)
-    return root
+    node = Node(value)
+    left, right = split(root, value)
+    return merge(merge(left, node), right)
 
-
-def erase(root: Node, key: int) -> Node:
+def erase(root: Node, value: int) -> Node:
     """
     Erase element
 
-    Split all nodes with keys less into l,
-    Split all nodes with keys greater into r.
-    Merge l, r
+    Split all nodes with values less into left,
+    Split all nodes with values greater into right.
+    Merge left, right
     """
-    l, r = split(root, key)
-    _, r = split(r, key + 1)
-    return merge(l, r)
-
+    left, right = split(root, value-1)
+    _, right = split(right, value)
+    return merge(left, right)
 
-def node_print(root: Node):
+def inorder(root: Node):
     """
     Just recursive print of a tree
     """
-    if not root:
+    if not root:    # None
         return
-    node_print(root.l)
-    print(root.key, end=" ")
-    node_print(root.r)
+    else:
+        inorder(root.left)
+        print(root.value, end=" ")
+        inorder(root.right)
 
 
-def interactTreap():
+def interactTreap(root, args):
     """
     Commands:
-    + key to add key into treap
-    - key to erase all nodes with key
-
-    After each command, program prints treap
+    + value to add value into treap
+    - value to erase all nodes with value
+
+        >>> root = interactTreap(None, "+1")
+        >>> inorder(root)
+        1 
+        >>> root = interactTreap(root, "+3 +5 +17 +19 +2 +16 +4 +0")
+        >>> inorder(root)
+        0 1 2 3 4 5 16 17 19 
+        >>> root = interactTreap(root, "+4 +4 +4")
+        >>> inorder(root)
+        0 1 2 3 4 4 4 4 5 16 17 19 
+        >>> root = interactTreap(root, "-0")
+        >>> inorder(root)
+        1 2 3 4 4 4 4 5 16 17 19 
+        >>> root = interactTreap(root, "-4")
+        >>> inorder(root)
+        1 2 3 5 16 17 19 
+        >>> root = interactTreap(root, "=0")
+        Unknown command
     """
-    root = None
-    while True:
-        cmd = input().split()
-        cmd[1] = int(cmd[1])
-        if cmd[0] == "+":
-            root = insert(root, cmd[1])
-        elif cmd[0] == "-":
-            root = erase(root, cmd[1])
+    for arg in args.split():
+        if arg[0] == "+":
+            root = insert(root, int(arg[1:]))
+
+        elif arg[0] == "-":
+            root = erase(root, int(arg[1:]))
+
         else:
             print("Unknown command")
-        node_print(root)
 
+    return root
+
+def main():
+    """After each command, program prints treap"""
+    root = None
+    print("enter numbers to creat a tree, + value to add value into treap, - value to erase all nodes with value. 'q' to quit. ")
+
+    args = input()
+    while args != 'q':
+        root = interactTreap(root, args)
+        print(root)
+        args = input()
+
+    print("good by!")
+    pass
 
 if __name__ == "__main__":
-    interactTreap()
+    import doctest
+    doctest.testmod()
+    main()

From 4590363806857d389c489b2e45330e7b9b26f52c Mon Sep 17 00:00:00 2001
From: Hrishikesh Suslade <41867989+hash84@users.noreply.github.com>
Date: Fri, 18 Oct 2019 23:53:37 +0530
Subject: [PATCH 273/348] Added Pytests for Decission Tree mean_squared_error
 method (#1374)

* Added Pytests for Decission Tree

Modified the mean_squared_error to be a static method

Created the Test_Decision_Tree class
Consists of two methods
1. helper_mean_squared_error_test: This method calculates the mean squared error manually without using
numpy. Instead a for loop is used for the same.
2. test_one_mean_squared_error: This method considers a simple test case and compares the results by the
helper function and the original mean_squared_error method of Decision_Tree class. This is done using asert
keyword.

Execution:
PyTest installation
pip3 install pytest OR pip install pytest

Test function execution
pytest decision_tree.py

* Modified the pytests to be compatible with the doctest
Added 2 doctest in the mean_squared_error method
For its verification a static method helper_mean_squared_error(labels, prediction) is used
It uses a for loop to calculate the error instead of the numpy inbuilt methods
Execution
```
pytest .\decision_tree.py --doctest-modules
```
---
 machine_learning/decision_tree.py | 32 +++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/machine_learning/decision_tree.py b/machine_learning/decision_tree.py
index 4f7a4d12966e..14c02b64df0c 100644
--- a/machine_learning/decision_tree.py
+++ b/machine_learning/decision_tree.py
@@ -21,6 +21,14 @@ def mean_squared_error(self, labels, prediction):
         @param labels: a one dimensional numpy array
         @param prediction: a floating point value
         return value: mean_squared_error calculates the error if prediction is used to estimate the labels
+        >>> tester = Decision_Tree()
+        >>> test_labels = np.array([1,2,3,4,5,6,7,8,9,10])
+        >>> test_prediction = np.float(6)
+        >>> assert tester.mean_squared_error(test_labels, test_prediction) == Test_Decision_Tree.helper_mean_squared_error_test(test_labels, test_prediction)
+        >>> test_labels = np.array([1,2,3])
+        >>> test_prediction = np.float(2)
+        >>> assert tester.mean_squared_error(test_labels, test_prediction) == Test_Decision_Tree.helper_mean_squared_error_test(test_labels, test_prediction)
+
         """
         if labels.ndim != 1:
             print("Error: Input labels must be one dimensional")
@@ -117,6 +125,27 @@ def predict(self, x):
             print("Error: Decision tree not yet trained")
             return None
 
+class Test_Decision_Tree:
+    """Decision Tres test class
+    """
+
+    @staticmethod
+    def helper_mean_squared_error_test(labels, prediction):
+        """
+        helper_mean_squared_error_test:
+        @param labels: a one dimensional numpy array
+        @param prediction: a floating point value
+        return value: helper_mean_squared_error_test calculates the mean squared error 
+        """
+        squared_error_sum = np.float(0)
+        for label in labels:
+            squared_error_sum += ((label-prediction) ** 2)
+
+        return np.float(squared_error_sum/labels.size)
+    
+    
+    
+
 
 def main():
     """
@@ -141,3 +170,6 @@ def main():
 
 if __name__ == "__main__":
     main()
+    import doctest
+
+    doctest.testmod(name="mean_squarred_error", verbose=True)

From a7f3851939f83b76252ec79d89cc874e8162754d Mon Sep 17 00:00:00 2001
From: Jigyasa G <jigsgandhi97@gmail.com>
Date: Fri, 18 Oct 2019 23:56:48 +0530
Subject: [PATCH 274/348] fuzzy operations added (#1310)

* fuzzy operations added

* fuzzy inference system added

* unnecessary files removed

* requirements added

* Modified requirements for travis ci

* Modified requirements for travis ci

* Add scikit-fuzzy to requirements.txt
---
 fuzzy_logic/fuzzy_operations.py | 100 ++++++++++++++++++++++++++++++++
 requirements.txt                |   1 +
 2 files changed, 101 insertions(+)
 create mode 100644 fuzzy_logic/fuzzy_operations.py

diff --git a/fuzzy_logic/fuzzy_operations.py b/fuzzy_logic/fuzzy_operations.py
new file mode 100644
index 000000000000..e497eabd1690
--- /dev/null
+++ b/fuzzy_logic/fuzzy_operations.py
@@ -0,0 +1,100 @@
+"""README, Author - Jigyasa Gandhi(mailto:jigsgandhi97@gmail.com)
+Requirements:
+  - scikit-fuzzy
+  - numpy
+  - matplotlib
+Python:
+  - 3.5
+"""
+# Create universe of discourse in python using linspace ()
+import numpy as np
+X = np.linspace(start=0, stop=75, num=75, endpoint=True, retstep=False)
+
+# Create two fuzzy sets by defining any membership function (trapmf(), gbellmf(),gaussmf(), etc).
+import skfuzzy as fuzz
+abc1=[0,25,50]
+abc2=[25,50,75]
+young = fuzz.membership.trimf(X,abc1)
+middle_aged = fuzz.membership.trimf(X,abc2)
+
+# Compute the different operations using inbuilt functions.
+one = np.ones(75)
+zero = np.zeros((75,))
+#1. Union = max(µA(x), µB(x))
+union = fuzz.fuzzy_or(X, young, X, middle_aged)[1]
+#2. Intersection = min(µA(x), µB(x))
+intersection = fuzz.fuzzy_and(X, young, X, middle_aged)[1]
+#3. Complement (A) = (1- min(µA(x))
+complement_a = fuzz.fuzzy_not(young)
+#4. Difference (A/B) = min(µA(x),(1- µB(x)))
+difference = fuzz.fuzzy_and(X, young, X, fuzz.fuzzy_not(middle_aged)[1])[1]
+#5. Algebraic Sum = [µA(x) + µB(x) – (µA(x) * µB(x))]
+alg_sum = young + middle_aged - (young*middle_aged)
+#6. Algebraic Product = (µA(x) * µB(x))
+alg_product = young*middle_aged
+#7. Bounded Sum = min[1,(µA(x), µB(x))]
+bdd_sum = fuzz.fuzzy_and(X, one, X, young+middle_aged)[1]
+#8. Bounded difference = min[0,(µA(x), µB(x))]
+bdd_difference = fuzz.fuzzy_or(X, zero, X, young-middle_aged)[1]
+
+#max-min composition
+#max-product composition
+
+
+# Plot each set A, set B and each operation result using plot() and subplot().
+import matplotlib.pyplot as plt
+
+plt.figure()
+
+plt.subplot(4,3,1)
+plt.plot(X,young)
+plt.title("Young")
+plt.grid(True)
+
+plt.subplot(4,3,2)
+plt.plot(X,middle_aged)
+plt.title("Middle aged")
+plt.grid(True)
+
+plt.subplot(4,3,3)
+plt.plot(X,union)
+plt.title("union")
+plt.grid(True)
+
+plt.subplot(4,3,4)
+plt.plot(X,intersection)
+plt.title("intersection")
+plt.grid(True)
+
+plt.subplot(4,3,5)
+plt.plot(X,complement_a)
+plt.title("complement_a")
+plt.grid(True)
+
+plt.subplot(4,3,6)
+plt.plot(X,difference)
+plt.title("difference a/b")
+plt.grid(True)
+
+plt.subplot(4,3,7)
+plt.plot(X,alg_sum)
+plt.title("alg_sum")
+plt.grid(True)
+
+plt.subplot(4,3,8)
+plt.plot(X,alg_product)
+plt.title("alg_product")
+plt.grid(True)
+
+plt.subplot(4,3,9)
+plt.plot(X,bdd_sum)
+plt.title("bdd_sum")
+plt.grid(True)
+
+plt.subplot(4,3,10)
+plt.plot(X,bdd_difference)
+plt.title("bdd_difference")
+plt.grid(True)
+
+plt.subplots_adjust(hspace = 0.5)
+plt.show()
diff --git a/requirements.txt b/requirements.txt
index f5790ad53c30..4f6ff321c268 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -8,6 +8,7 @@ pandas
 pillow
 pytest
 requests
+scikit-fuzzy
 sklearn
 sympy
 tensorflow

From 5ef5f67a51b658d768c6bf6f2f4e68c45736ca15 Mon Sep 17 00:00:00 2001
From: Jai Kumar Dewani <jai.dewani.99@gmail.com>
Date: Sat, 19 Oct 2019 00:44:01 +0530
Subject: [PATCH 275/348] Added more details about the problem statement
 (#1367)

* Update DIRECTORY

* Updated DIRECTORY

* Fixed bug in directory build and re-build the directory.md

* fixed url issue

* fixed indentation in Directory.md

* Add problem-18 of project-euler

* Delete sol1.py

* Delete files

* Added more details to question

* Added doctest in printNGE()

* Made changes to fix Travis CI build

* Remove the trailing whitespace
---
 data_structures/stacks/next_greater_element.py | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/data_structures/stacks/next_greater_element.py b/data_structures/stacks/next_greater_element.py
index 02a86196f5bf..29a039b9698b 100644
--- a/data_structures/stacks/next_greater_element.py
+++ b/data_structures/stacks/next_greater_element.py
@@ -1,6 +1,13 @@
-# Function to print element and NGE pair for all elements of list
 def printNGE(arr):
-
+    """
+    Function to print element and Next Greatest Element (NGE) pair for all elements of list
+    NGE - Maximum element present afterwards the current one which is also greater than current one
+    >>> printNGE([11,13,21,3])
+    11 -- 13
+    13 -- 21
+    21 -- -1
+    3 -- -1
+    """
     for i in range(0, len(arr), 1):
 
         next = -1

From 43f99e56c969b46d3ea65593d0a20e9d9896ed0f Mon Sep 17 00:00:00 2001
From: kunal kumar barman <kumar96kunal@gmail.com>
Date: Sat, 19 Oct 2019 03:00:52 +0530
Subject: [PATCH 276/348] Python program that surfs  3 site at a time (#1389)

* Python program that scrufs 3 site at a time

add input in the compiling time  like --  python3 project1.py (man)

* Update project1.py

* noqa: F401 and reformat with black

* Rename project1.py to web_programming/crawl_google_results.py

* Add beautifulsoup4 to requirements.txt

* Add fake_useragent to requirements.txt

* Update crawl_google_results.py

* headers={"UserAgent": UserAgent().random}

* html.parser, not lxml

* link, not links
---
 requirements.txt                        |  2 ++
 web_programming/crawl_google_results.py | 20 ++++++++++++++++++++
 2 files changed, 22 insertions(+)
 create mode 100644 web_programming/crawl_google_results.py

diff --git a/requirements.txt b/requirements.txt
index 4f6ff321c268..824f534a245f 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,4 +1,6 @@
+beautifulsoup4
 black
+fake_useragent
 flake8
 matplotlib
 mypy
diff --git a/web_programming/crawl_google_results.py b/web_programming/crawl_google_results.py
new file mode 100644
index 000000000000..c31ec1526d3e
--- /dev/null
+++ b/web_programming/crawl_google_results.py
@@ -0,0 +1,20 @@
+import sys
+import webbrowser
+
+from bs4 import BeautifulSoup
+from fake_useragent import UserAgent
+import requests
+
+print("Googling.....")
+url = "https://www.google.com/search?q=" + " ".join(sys.argv[1:])
+res = requests.get(url, headers={"UserAgent": UserAgent().random})
+# res.raise_for_status()
+with open("project1a.html", "wb") as out_file:  # only for knowing the class
+    for data in res.iter_content(10000):
+        out_file.write(data)
+soup = BeautifulSoup(res.text, "html.parser")
+links = list(soup.select(".eZt8xd"))[:5]
+
+print(len(links))
+for link in links:
+    webbrowser.open(f"http://google.com{link.get('href')}")

From 83667826884fae7aa3dfbcf3b73aedab9922a356 Mon Sep 17 00:00:00 2001
From: Swati Prajapati <42577922+swatiprajapati08@users.noreply.github.com>
Date: Sat, 19 Oct 2019 03:13:33 +0530
Subject: [PATCH 277/348] Create ActivitySelection (#1384)

* Create ActivitySelection

* Update and rename ActivitySelection to activity_selection.py

* Update activity_selection.py

* Update activity_selection.py

* Update activity_selection.py

* Update activity_selection.py

* Update activity_selection.py

* Update activity_selection.py

* Rename activity_selection.py to other/activity_selection.py

* Update activity_selection.py

* Update activity_selection.py

* Add a doctest

* print(j, end=" ")

* print(i, end=" ")

* colons

* Add trailing space
---
 other/activity_selection.py | 43 +++++++++++++++++++++++++++++++++++++
 1 file changed, 43 insertions(+)
 create mode 100644 other/activity_selection.py

diff --git a/other/activity_selection.py b/other/activity_selection.py
new file mode 100644
index 000000000000..5c14df7d6aa7
--- /dev/null
+++ b/other/activity_selection.py
@@ -0,0 +1,43 @@
+"""The following implementation assumes that the activities 
+are already sorted according to their finish time"""
+  
+"""Prints a maximum set of activities that can be done by a 
+single person, one at a time"""
+# n --> Total number of activities 
+# start[]--> An array that contains start time of all activities 
+# finish[] --> An array that contains finish time of all activities 
+  
+def printMaxActivities(start, finish):
+    """
+    >>> start = [1, 3, 0, 5, 8, 5] 
+    >>> finish = [2, 4, 6, 7, 9, 9] 
+    >>> printMaxActivities(start, finish)
+    The following activities are selected:
+    0 1 3 4 
+    """
+    n = len(finish) 
+    print("The following activities are selected:")
+  
+    # The first activity is always selected 
+    i = 0
+    print(i, end=" ")
+  
+    # Consider rest of the activities 
+    for j in range(n): 
+  
+        # If this activity has start time greater than 
+        # or equal to the finish time of previously 
+        # selected activity, then select it 
+        if start[j] >= finish[i]: 
+            print(j, end=" ")
+            i = j 
+  
+# Driver program to test above function 
+start = [1, 3, 0, 5, 8, 5] 
+finish = [2, 4, 6, 7, 9, 9] 
+printMaxActivities(start, finish) 
+
+"""
+The following activities are selected:
+0 1 3 4
+"""

From 86a2d5fd037e29613171c84576f0eb0ea6e3d1e7 Mon Sep 17 00:00:00 2001
From: Iqrar Agalosi Nureyza <misteriqrar@gmail.com>
Date: Sat, 19 Oct 2019 04:49:30 +0700
Subject: [PATCH 278/348] fixed some typos (#1392)

missing 'c' in eulidianLength and eulidian. Should be euclidianLength and euclidian.
---
 linear_algebra/src/lib.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/linear_algebra/src/lib.py b/linear_algebra/src/lib.py
index 090427d9a520..bf9e0d302a89 100644
--- a/linear_algebra/src/lib.py
+++ b/linear_algebra/src/lib.py
@@ -37,7 +37,7 @@ class Vector(object):
         __str__() : toString method
         component(i : int): gets the i-th component (start by 0)
         __len__() : gets the size of the vector (number of components)
-        euclidLength() : returns the eulidean length of the vector.
+        euclidLength() : returns the euclidean length of the vector.
         operator + : vector addition
         operator - : vector subtraction
         operator * : scalar multiplication and dot product
@@ -88,9 +88,9 @@ def __len__(self):
         """
         return len(self.__components)
 
-    def eulidLength(self):
+    def euclidLength(self):
         """
-            returns the eulidean length of the vector
+            returns the euclidean length of the vector
         """
         summe = 0
         for c in self.__components:

From e0158c2c30a8273a6780fd9f83c36be6582e9e91 Mon Sep 17 00:00:00 2001
From: Kumar Shivam <53289673+kshivi99@users.noreply.github.com>
Date: Sat, 19 Oct 2019 03:22:32 +0530
Subject: [PATCH 279/348] fixed project eular readme (#1391)

---
 project_euler/README.md | 105 +---------------------------------------
 1 file changed, 1 insertion(+), 104 deletions(-)

diff --git a/project_euler/README.md b/project_euler/README.md
index 89b6d63b5744..f80d58ea0038 100644
--- a/project_euler/README.md
+++ b/project_euler/README.md
@@ -8,107 +8,4 @@ insights to solve. Project Euler is ideal for mathematicians who are learning to
 Here the efficiency of your code is also checked.
 I've tried to provide all the best possible solutions.
 
-PROBLEMS:
-
-1. If we list all the natural numbers below 10 that are multiples of 3 or 5, we get 3,5,6 and 9. The sum of these multiples is 23.
-   Find the sum of all the multiples of 3 or 5 below N.
-
-2. Each new term in the Fibonacci sequence is generated by adding the previous two terms. By starting with 1 and 2,
-   the first 10 terms will be:
-      1,2,3,5,8,13,21,34,55,89,..
-   By considering the terms in the Fibonacci sequence whose values do not exceed n, find the sum of the even-valued terms.  
-   e.g. for n=10, we have {2,8}, sum is 10.
-
-3. The prime factors of 13195 are 5,7,13 and 29. What is the largest prime factor of a given number N?
-   e.g. for 10, largest prime factor = 5. For 17, largest prime factor = 17.
-
-4. A palindromic number reads the same both ways. The largest palindrome made from the product of two 2-digit numbers is 9009 = 91 × 99.
-   Find the largest palindrome made from the product of two 3-digit numbers which is less than N.
-
-5. 2520 is the smallest number that can be divided by each of the numbers from 1 to 10 without any remainder.
-   What is the smallest positive number that is evenly divisible(divisible with no remainder) by all of the numbers from 1 to N?
-
-6. The sum of the squares of the first ten natural numbers is,
-      1^2 + 2^2 + ... + 10^2 = 385
-   The square of the sum of the first ten natural numbers is,
-     (1 + 2 + ... + 10)^2 = 552 = 3025
-   Hence the difference between the sum of the squares of the first ten natural numbers and the square of the sum is 3025 − 385 = 2640.
-   Find the difference between the sum of the squares of the first N natural numbers and the square of the sum.
-
-7. By listing the first six prime numbers: 2, 3, 5, 7, 11, and 13, we can see that the 6th prime is 13.
-   What is the Nth prime number?
-   
-8. Find the consecutive k digits in a number N that have the largest product.
-
-9. A Pythagorean triplet is a set of three natural numbers, a < b < c, for which,
-    a^2 + b^2 = c^2
-    There exists exactly one Pythagorean triplet for which a + b + c = 1000.
-    Find the product abc.
-
-10. Find sum of all prime numbers below 2 million.
-
-11. In the given 20x20 grid, find 4 adjacent numbers (horizontally, vertically or diagonally) that have the largest product.
-
-12. The sequence of triangle numbers is generated by adding the natural numbers. So the 7th triangle number would be 1 + 2 + 3 + 4 + 5 + 6 + 7 = 28. The first ten terms would be:
-
-    1, 3, 6, 10, 15, 21, 28, 36, 45, 55, ...
-
-    Let us list the factors of the first seven triangle numbers:
-
-    1: 1
-    3: 1,3
-    6: 1,2,3,6
-    10: 1,2,5,10
-    15: 1,3,5,15
-    21: 1,3,7,21
-    28: 1,2,4,7,14,28
-    We can see that 28 is the first triangle number to have over five divisors.
-
-    What is the value of the first triangle number to have over five hundred divisors?
-    
-13. Work out the first 10 digits of the sum of the given hundred 50 digit numbers.  
-    
-14. The following iterative sequence is defined for the set of positive integers:
-    n → n/2 (n is even)
-    n → 3n + 1 (n is odd)
-    Using the rule above and starting with 13, we generate the following sequence:
-    13 → 40 → 20 → 10 → 5 → 16 → 8 → 4 → 2 → 1
-    Which starting number, under one million, produces the longest chain?
-    
-15. Starting from top left corner of a 20x20 grid how many routes are there to reach the bottom left corner?
-
-16. 2^15 = 32768 and the sum of its digits is 3 + 2 + 7 + 6 + 8 = 26.
-    What is the sum of the digits of the number 2^1000?
-    
-17. If the numbers 1 through 1000 were written in words, how many total letters would be used?
-
-18. By starting at the top of the triangle below and moving to adjacent numbers on the row below, the maximum total from top to bottom is 23.
-   3
-  7 4
- 2 4 6
-8 5 9 3
-
-That is, 3 + 7 + 4 + 9 = 23.
-
-Find the maximum total from top to bottom of the triangle below:
-
-              75
-             95 64
-            17 47 82
-           18 35 87 10
-          20 04 82 47 65
-         19 01 23 75 03 34
-        88 02 77 73 07 63 67
-       99 65 04 28 06 16 70 92
-      41 41 26 56 83 40 80 70 33
-     41 48 72 33 47 32 37 16 94 29
-    53 71 44 65 25 43 91 52 97 51 14
-   70 11 33 28 77 73 17 78 39 68 17 57
-  91 71 52 38 17 14 91 43 58 50 27 29 48
- 63 66 04 68 89 53 67 30 73 16 69 87 40 31
-04 62 98 27 23 09 70 98 73 93 38 53 60 04 23
-
-20. n! means n × (n − 1) × ... × 3 × 2 × 1
-    For example, 10! = 10 × 9 × ... × 3 × 2 × 1 = 3628800,
-    and the sum of the digits in the number 10! is 3 + 6 + 2 + 8 + 8 + 0 + 0 = 27.
-    Find the sum of the digits in the number 100!
+For description of the problem statements, kindly visit https://projecteuler.net/show=all

From acd962b2b6ddbcd5cee9b70a6feee13cbe12bcfc Mon Sep 17 00:00:00 2001
From: Sourav kumar <33771969+souravs17031999@users.noreply.github.com>
Date: Sat, 19 Oct 2019 03:32:32 +0530
Subject: [PATCH 280/348] adding program to print diamond pattern (#1338)

* adding program to print diamond pattern

Written a program to print diamond pattern with stars in python 3.7

* update - changing strings to r strings
---
 other/magicdiamondpattern.py | 53 ++++++++++++++++++++++++++++++++++++
 1 file changed, 53 insertions(+)
 create mode 100644 other/magicdiamondpattern.py

diff --git a/other/magicdiamondpattern.py b/other/magicdiamondpattern.py
new file mode 100644
index 000000000000..024fbd0f569a
--- /dev/null
+++ b/other/magicdiamondpattern.py
@@ -0,0 +1,53 @@
+# Python program for generating diamond pattern in python 3.7+
+
+# Function to print upper half of diamond (pyramid)
+def floyd(n):
+	'''
+	Parameters: 
+    n : size of pattern 
+	'''
+	for i in range(0, n):
+		for j in range(0, n-i-1): # printing spaces
+			print(" ", end = "")
+		for k in range(0, i + 1): # printing stars 
+			print("* ", end = "")
+		print()
+
+
+# Function to print lower half of diamond (pyramid)
+def reverse_floyd(n):
+	'''
+	Parameters: 
+    n : size of pattern 
+	'''
+	for i in range(n, 0, -1):
+		for j in range(i, 0, -1):  # printing stars 
+			print("* ", end = "")
+		print()
+		for k in range(n-i+1, 0, -1):  # printing spaces 
+			print(" ", end = "")
+
+# Function to print complete diamond pattern of "*"
+def pretty_print(n):
+	'''
+	Parameters: 
+    n : size of pattern 
+	'''
+	if n <= 0:
+		print("       ...       ....        nothing printing :(")
+		return 
+	floyd(n)   # upper half 
+	reverse_floyd(n) # lower half 
+
+
+if __name__ == "__main__":
+	print(r"| /\ | |- |  |-  |--| |\  /| |-")
+	print(r"|/  \| |- |_ |_  |__| | \/ | |_")
+	K = 1
+	while(K):
+		user_number = int(input("enter the number and , and see the magic : "))
+		print()
+		pretty_print(user_number)
+		K = int(input("press 0 to exit... and 1 to continue..."))
+
+	print("Good Bye...")	

From 5c351d81bf12e72030aff385275e8aa50846456d Mon Sep 17 00:00:00 2001
From: Alfin_William <alfinwilliam@gmail.com>
Date: Sat, 19 Oct 2019 09:32:38 +0530
Subject: [PATCH 281/348] Implementation of Hardy Ramanujan Algorithm in /maths
 (#1355)

* Implementation of Hardy Ramanujan Algorithm

* added docstrings

* added doctests

* Run Python black on the code

* Travis CI: Upgrade to Python 3.8

* Revert to Python 3.7
---
 .travis.yml                  |  1 -
 maths/hardy_ramanujanalgo.py | 45 ++++++++++++++++++++++++++++++++++++
 2 files changed, 45 insertions(+), 1 deletion(-)
 create mode 100644 maths/hardy_ramanujanalgo.py

diff --git a/.travis.yml b/.travis.yml
index be227df1fdbd..877dbee9ade2 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,5 +1,4 @@
 language: python
-dist: xenial  # required for Python >= 3.7
 python: 3.7
 cache: pip
 before_install: pip install --upgrade pip setuptools
diff --git a/maths/hardy_ramanujanalgo.py b/maths/hardy_ramanujanalgo.py
new file mode 100644
index 000000000000..bb31a1be49fb
--- /dev/null
+++ b/maths/hardy_ramanujanalgo.py
@@ -0,0 +1,45 @@
+# This theorem states that the number of prime factors of n
+# will be approximately log(log(n)) for most natural numbers n
+
+import math
+
+
+def exactPrimeFactorCount(n):
+    """
+    >>> exactPrimeFactorCount(51242183)
+    3
+    """
+    count = 0
+    if n % 2 == 0:
+        count += 1
+        while n % 2 == 0:
+            n = int(n / 2)
+    # the n input value must be odd so that
+    # we can skip one element (ie i += 2)
+
+    i = 3
+
+    while i <= int(math.sqrt(n)):
+        if n % i == 0:
+            count += 1
+            while n % i == 0:
+                n = int(n / i)
+        i = i + 2
+
+    # this condition checks the prime
+    # number n is greater than 2
+
+    if n > 2:
+        count += 1
+    return count
+
+
+if __name__ == "__main__":
+    n = 51242183
+    print(f"The number of distinct prime factors is/are {exactPrimeFactorCount(n)}")
+    print("The value of log(log(n)) is {0:.4f}".format(math.log(math.log(n))))
+
+    """
+    The number of distinct prime factors is/are 3
+    The value of log(log(n)) is 2.8765
+    """

From dbf904f4381132dbe8d1de349dc4f4de2a7b4342 Mon Sep 17 00:00:00 2001
From: Stephen <24819660+infrontoftheforest@users.noreply.github.com>
Date: Sat, 19 Oct 2019 09:11:05 +0000
Subject: [PATCH 282/348] added runge-kutta (#1393)

---
 maths/runge_kutta.py | 44 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 44 insertions(+)
 create mode 100644 maths/runge_kutta.py

diff --git a/maths/runge_kutta.py b/maths/runge_kutta.py
new file mode 100644
index 000000000000..b0ba9025883f
--- /dev/null
+++ b/maths/runge_kutta.py
@@ -0,0 +1,44 @@
+import numpy as np
+
+
+def runge_kutta(f, y0, x0, h, x_end):
+    """
+    Calculate the numeric solution at each step to the ODE f(x, y) using RK4
+
+    https://en.wikipedia.org/wiki/Runge-Kutta_methods
+
+    Arguments:
+    f -- The ode as a function of x and y
+    y0 -- the initial value for y
+    x0 -- the initial value for x
+    h -- the stepsize
+    x_end -- the end value for x
+
+    >>> # the exact solution is math.exp(x)
+    >>> def f(x, y):
+    ...     return y
+    >>> y0 = 1
+    >>> y = runge_kutta(f, y0, 0.0, 0.01, 5)
+    >>> y[-1]
+    148.41315904125113
+    """
+    N = int(np.ceil((x_end - x0)/h))
+    y = np.zeros((N + 1,))
+    y[0] = y0
+    x = x0
+
+    for k in range(N):
+        k1 = f(x, y[k])
+        k2 = f(x + 0.5*h, y[k] + 0.5*h*k1)
+        k3 = f(x + 0.5*h, y[k] + 0.5*h*k2)
+        k4 = f(x + h, y[k] + h * k3)
+        y[k + 1] = y[k] + (1/6)*h*(k1 + 2*k2 + 2*k3 + k4)
+        x += h
+
+    return y
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()

From ab65a3915c063bfc31102512bb3c9a755bef7ed0 Mon Sep 17 00:00:00 2001
From: ayush246 <37112252+ayush246@users.noreply.github.com>
Date: Sat, 19 Oct 2019 16:08:15 +0530
Subject: [PATCH 283/348] Double sort (Added with required updates) (#1399)

* Added with required updates

* Updated

* required updates

* Update double_sort.py

* Update double_sort.py
---
 sorts/double_sort.py | 34 ++++++++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 sorts/double_sort.py

diff --git a/sorts/double_sort.py b/sorts/double_sort.py
new file mode 100644
index 000000000000..011e17d8f035
--- /dev/null
+++ b/sorts/double_sort.py
@@ -0,0 +1,34 @@
+def double_sort(lst): 
+    """this sorting algorithm sorts an array using the principle of bubble sort , 
+    but does it both from left to right and right to left , 
+    hence i decided to call it "double sort"
+    :param collection: mutable ordered sequence of elements
+    :return: the same collection in ascending order
+    Examples:
+    >>> double_sort([-1 ,-2 ,-3 ,-4 ,-5 ,-6 ,-7])
+    [-7, -6, -5, -4, -3, -2, -1]
+    >>> double_sort([])
+    []
+    >>> double_sort([-1 ,-2 ,-3 ,-4 ,-5 ,-6])
+    [-6, -5, -4, -3, -2, -1]
+    >>> double_sort([-3, 10, 16, -42, 29]) == sorted([-3, 10, 16, -42, 29])
+    True
+    """
+    no_of_elements=len(lst)
+    for i in range(0,int(((no_of_elements-1)/2)+1)): # we dont need to traverse to end of list as
+        for j in range(0,no_of_elements-1):
+            if (lst[j+1]<lst[j]): # applying bubble sort algorithm from left to right (or forwards)
+                temp=lst[j+1]
+                lst[j+1]=lst[j]
+                lst[j]=temp
+            if (lst[no_of_elements-1-j]<lst[no_of_elements-2-j]): # applying bubble sort algorithm from right to left (or backwards)
+                temp=lst[no_of_elements-1-j]
+                lst[no_of_elements-1-j]=lst[no_of_elements-2-j]
+                lst[no_of_elements-2-j]=temp
+    return lst
+if __name__ == "__main__":
+    print("enter the list to be sorted")
+    lst = [int(x) for x in input().split()] # inputing elements of the list in one line
+    sorted_lst=double_sort(lst)
+    print("the sorted list is")
+    print(sorted_lst)

From cd10c944d15c3490abbfbb5e2e4bf8c100a54045 Mon Sep 17 00:00:00 2001
From: Manu M Bhat <46175054+ManuMBhat@users.noreply.github.com>
Date: Sat, 19 Oct 2019 23:44:37 +0530
Subject: [PATCH 284/348] Issue #1397 (#1403)

---
 .../linked_list/singly_linked_list.py         | 58 +++++++++----------
 1 file changed, 29 insertions(+), 29 deletions(-)

diff --git a/data_structures/linked_list/singly_linked_list.py b/data_structures/linked_list/singly_linked_list.py
index 16436ff90274..73b982316e76 100644
--- a/data_structures/linked_list/singly_linked_list.py
+++ b/data_structures/linked_list/singly_linked_list.py
@@ -6,56 +6,56 @@ def __init__(self, data):
 
 class Linked_List:
     def __init__(self):
-        self.Head = None  # Initialize Head to None
+        self.head = None  # Initialize head to None
 
     def insert_tail(self, data):
-        if self.Head is None:
+        if self.head is None:
             self.insert_head(data)  # If this is first node, call insert_head
         else:
-            temp = self.Head
+            temp = self.head
             while temp.next != None:  # traverse to last node
                 temp = temp.next
             temp.next = Node(data)  # create node & link to tail
 
     def insert_head(self, data):
         newNod = Node(data)  # create a new node
-        if self.Head != None:
-            newNod.next = self.Head  # link newNode to head
-        self.Head = newNod  # make NewNode as Head
+        if self.head != None:
+            newNod.next = self.head  # link newNode to head
+        self.head = newNod  # make NewNode as head
 
     def printList(self):  # print every node data
-        tamp = self.Head
-        while tamp is not None:
-            print(tamp.data)
-            tamp = tamp.next
+        temp = self.head
+        while temp is not None:
+            print(temp.data)
+            temp = temp.next
 
     def delete_head(self):  # delete from head
-        temp = self.Head
-        if self.Head != None:
-            self.Head = self.Head.next
+        temp = self.head
+        if self.head != None:
+            self.head = self.head.next
             temp.next = None
         return temp
 
     def delete_tail(self):  # delete from tail
-        tamp = self.Head
-        if self.Head != None:
-            if self.Head.next is None:  # if Head is the only Node in the Linked List
-                self.Head = None
+        temp = self.head
+        if self.head != None:
+            if self.head.next is None:  # if head is the only Node in the Linked List
+                self.head = None
             else:
-                while tamp.next.next is not None:  # find the 2nd last element
-                    tamp = tamp.next
-                tamp.next, tamp = (
+                while temp.next.next is not None:  # find the 2nd last element
+                    temp = temp.next
+                temp.next, temp = (
                     None,
-                    tamp.next,
-                )  # (2nd last element).next = None and tamp = last element
-        return tamp
+                    temp.next,
+                )  # (2nd last element).next = None and temp = last element
+        return temp
 
     def isEmpty(self):
-        return self.Head is None  # Return if Head is none
+        return self.head is None  # Return if head is none
 
     def reverse(self):
         prev = None
-        current = self.Head
+        current = self.head
 
         while current:
             # Store the current node's next node.
@@ -67,15 +67,15 @@ def reverse(self):
             # Make the current node the next node (to progress iteration)
             current = next_node
         # Return prev in order to put the head at the end
-        self.Head = prev
+        self.head = prev
 
 
 def main():
     A = Linked_List()
-    print("Inserting 1st at Head")
+    print("Inserting 1st at head")
     a1 = input()
     A.insert_head(a1)
-    print("Inserting 2nd at Head")
+    print("Inserting 2nd at head")
     a2 = input()
     A.insert_head(a2)
     print("\nPrint List : ")
@@ -88,7 +88,7 @@ def main():
     A.insert_tail(a4)
     print("\nPrint List : ")
     A.printList()
-    print("\nDelete Head")
+    print("\nDelete head")
     A.delete_head()
     print("Delete Tail")
     A.delete_tail()

From 38d7e7073affe758557636ea201615d17d24fa97 Mon Sep 17 00:00:00 2001
From: Sujitkumar Singh <37760194+SinghSujitkumar@users.noreply.github.com>
Date: Sun, 20 Oct 2019 01:42:54 +0530
Subject: [PATCH 285/348] The time complexity of every algorithms make its
 value  (#1401)

* added timer in bubble sort

* Updated time of execution

* import time in main only

* Update bubble_sort.py

* start = time.process_time()
---
 sorts/bubble_sort.py | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/sorts/bubble_sort.py b/sorts/bubble_sort.py
index ccd8a2e11ee1..4faa40da1d8e 100644
--- a/sorts/bubble_sort.py
+++ b/sorts/bubble_sort.py
@@ -6,13 +6,13 @@ def bubble_sort(collection):
     :return: the same collection ordered by ascending
 
     Examples:
-    >>> bubble_sort([0, 5, 3, 2, 2])
+    >>> bubble_sort([0, 5, 2, 3, 2])
     [0, 2, 2, 3, 5]
 
     >>> bubble_sort([])
     []
 
-    >>> bubble_sort([-2, -5, -45])
+    >>> bubble_sort([-2, -45, -5])
     [-45, -5, -2]
 
     >>> bubble_sort([-23, 0, 6, -4, 34])
@@ -29,11 +29,14 @@ def bubble_sort(collection):
                 swapped = True
                 collection[j], collection[j + 1] = collection[j + 1], collection[j]
         if not swapped:
-            break  # Stop iteration if the collection is sorted.
+            break  # Stop iteration if the collection is sorted.    
     return collection
 
 
 if __name__ == "__main__":
+    import time
     user_input = input("Enter numbers separated by a comma:").strip()
     unsorted = [int(item) for item in user_input.split(",")]
+    start = time.process_time()
     print(*bubble_sort(unsorted), sep=",")
+    print(f"Processing time: {time.process_time() - start}")

From 313a043107bc4882623ad5524a96fbb099d0d161 Mon Sep 17 00:00:00 2001
From: Archana Prabhu <prabhuarc27@gmail.com>
Date: Sun, 20 Oct 2019 14:10:40 +0530
Subject: [PATCH 286/348] Create autocomplete_using_trie.py (#1406)

* Create autocomplete_using_trie.py

The program aims to design a trie implementation for autocomplete which is easy to understand and ready to run.

* Removed unused import

* Updated the list value

* Update autocomplete_using_trie.py

* Run the code through Black and add doctest
---
 other/autocomplete_using_trie.py | 64 ++++++++++++++++++++++++++++++++
 1 file changed, 64 insertions(+)
 create mode 100644 other/autocomplete_using_trie.py

diff --git a/other/autocomplete_using_trie.py b/other/autocomplete_using_trie.py
new file mode 100644
index 000000000000..eb906f8efa9a
--- /dev/null
+++ b/other/autocomplete_using_trie.py
@@ -0,0 +1,64 @@
+END = "#"
+
+
+class Trie:
+    def __init__(self):
+        self._trie = {}
+
+    def insert_word(self, text):
+        trie = self._trie
+        for char in text:
+            if char not in trie:
+                trie[char] = {}
+            trie = trie[char]
+        trie[END] = True
+
+    def find_word(self, prefix):
+        trie = self._trie
+        for char in prefix:
+            if char in trie:
+                trie = trie[char]
+            else:
+                return []
+        return self._elements(trie)
+
+    def _elements(self, d):
+        result = []
+        for c, v in d.items():
+            if c == END:
+                subresult = [" "]
+            else:
+                subresult = [c + s for s in self._elements(v)]
+            result.extend(subresult)
+        return tuple(result)
+
+
+trie = Trie()
+words = ("depart", "detergent", "daring", "dog", "deer", "deal")
+for word in words:
+    trie.insert_word(word)
+
+
+def autocomplete_using_trie(s):
+    """
+    >>> trie = Trie()
+    >>> for word in words:
+    ...     trie.insert_word(word)
+    ...
+    >>> matches = autocomplete_using_trie("de")
+
+    "detergent " in matches
+    True
+    "dog " in matches
+    False
+    """
+    suffixes = trie.find_word(s)
+    return tuple(s + w for w in suffixes)
+
+
+def main():
+    print(autocomplete_using_trie("de"))
+
+
+if __name__ == "__main__":
+    main()

From afeb13bbc8a43bfb427cb6f730e014b1ca1f7a6d Mon Sep 17 00:00:00 2001
From: Stephen <24819660+infrontoftheforest@users.noreply.github.com>
Date: Mon, 21 Oct 2019 17:19:43 +0000
Subject: [PATCH 287/348] added explicit euler's method (#1394)

* added explicit euler's method

* update explicit_euler.py variable names
---
 maths/explicit_euler.py | 41 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 41 insertions(+)
 create mode 100644 maths/explicit_euler.py

diff --git a/maths/explicit_euler.py b/maths/explicit_euler.py
new file mode 100644
index 000000000000..9fce4e4185a6
--- /dev/null
+++ b/maths/explicit_euler.py
@@ -0,0 +1,41 @@
+import numpy as np
+
+
+def explicit_euler(ode_func, y0, x0, stepsize, x_end):
+    """
+    Calculate numeric solution at each step to an ODE using Euler's Method
+
+    https://en.wikipedia.org/wiki/Euler_method
+
+    Arguments:
+    ode_func -- The ode as a function of x and y
+    y0 -- the initial value for y
+    x0 -- the initial value for x
+    stepsize -- the increment value for x
+    x_end -- the end value for x
+
+    >>> # the exact solution is math.exp(x)
+    >>> def f(x, y):
+    ...     return y
+    >>> y0 = 1
+    >>> y = explicit_euler(f, y0, 0.0, 0.01, 5)
+    >>> y[-1]
+    144.77277243257308
+    """
+    N = int(np.ceil((x_end - x0)/stepsize))
+    y = np.zeros((N + 1,))
+    y[0] = y0
+    x = x0
+
+    for k in range(N):
+        y[k + 1] = y[k] + stepsize*ode_func(x, y[k])
+        x += stepsize
+
+    return y
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()
+

From a06995a686c0509f50a481e7d7d41bb35ffe8f19 Mon Sep 17 00:00:00 2001
From: Shubham Lad <30789414+ShuLaPy@users.noreply.github.com>
Date: Mon, 21 Oct 2019 23:40:19 +0530
Subject: [PATCH 288/348] add simple improved Sieve Of Eratosthenes Algorithm
 (#1412)

* add simple improved Sieve Of Eratosthenes Algorithm

* added doctests

* name changed
---
 maths/prime_sieve_eratosthenes.py | 41 +++++++++++++++++++++++++++++++
 1 file changed, 41 insertions(+)
 create mode 100644 maths/prime_sieve_eratosthenes.py

diff --git a/maths/prime_sieve_eratosthenes.py b/maths/prime_sieve_eratosthenes.py
new file mode 100644
index 000000000000..7d039aaadd7d
--- /dev/null
+++ b/maths/prime_sieve_eratosthenes.py
@@ -0,0 +1,41 @@
+'''
+Sieve of Eratosthenes
+
+Input : n =10
+Output : 2 3 5 7 
+
+Input : n = 20 
+Output: 2 3 5 7 11 13 17 19
+
+you can read in detail about this at 
+https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes
+'''
+
+def prime_sieve_eratosthenes(num):
+    """
+    print the prime numbers upto n
+    
+    >>> prime_sieve_eratosthenes(10)
+    2 3 5 7 
+    >>> prime_sieve_eratosthenes(20)
+    2 3 5 7 11 13 17 19 
+    """
+    
+    
+    primes = [True for i in range(num + 1)]
+    p = 2
+    
+    while p * p <= num:
+        if primes[p] == True:
+            for i in range(p*p, num+1, p):
+                primes[i] = False
+        p+=1
+
+    for prime in range(2, num+1):
+        if primes[prime]:
+            print(prime, end=" ")
+
+if __name__ == "__main__":
+    num = int(input())
+    
+    prime_sieve_eratosthenes(num)

From 67aa3cfb4dd50e1d6feff6a36f630b374e2ab922 Mon Sep 17 00:00:00 2001
From: akankshamahajan99 <47140026+akankshamahajan99@users.noreply.github.com>
Date: Tue, 22 Oct 2019 01:35:12 +0530
Subject: [PATCH 289/348] Added alternative way to generate password in
 password_generator.py (#1415)

---
 other/password_generator.py | 21 ++++++++++++++++++---
 1 file changed, 18 insertions(+), 3 deletions(-)

diff --git a/other/password_generator.py b/other/password_generator.py
index f72686bfb1c0..b4c7999ca44a 100644
--- a/other/password_generator.py
+++ b/other/password_generator.py
@@ -1,5 +1,5 @@
 """Password generator allows you to generate a random password of length N."""
-from random import choice
+from random import choice, shuffle
 from string import ascii_letters, digits, punctuation
 
 
@@ -26,9 +26,22 @@ def password_generator(length=8):
 def alternative_password_generator(ctbi, i):
     # Password generator = full boot with random_number, random_letters, and
     # random_character FUNCTIONS
-    pass  # Put your code here...
-
+    # Put your code here...
+	i = i - len(ctbi)
+	quotient = int(i / 3)
+	remainder = i % 3
+	#chars = ctbi + random_letters(ascii_letters, i / 3 + remainder) + random_number(digits, i / 3) + random_characters(punctuation, i / 3)
+	chars = ctbi + random(ascii_letters, quotient + remainder) + random(digits, quotient) + random(punctuation, quotient)
+	chars = list(chars)
+	shuffle(chars)
+	return "".join(chars)
 
+	
+	#random is a generalised function for letters, characters and numbers
+def random(ctbi, i):
+	return "".join(choice(ctbi) for x in range(i))
+	
+	
 def random_number(ctbi, i):
     pass  # Put your code here...
 
@@ -43,7 +56,9 @@ def random_characters(ctbi, i):
 
 def main():
     length = int(input("Please indicate the max length of your password: ").strip())
+    ctbi = input("Please indicate the characters that must be in your password: ").strip()
     print("Password generated:", password_generator(length))
+    print("Alternative Password generated:", alternative_password_generator(ctbi, length))
     print("[If you are thinking of using this passsword, You better save it.]")
 
 

From f93cce66a634746839a78624af4d7b8aab205808 Mon Sep 17 00:00:00 2001
From: moita69 <fmj1988@gmail.com>
Date: Mon, 21 Oct 2019 17:36:33 -0300
Subject: [PATCH 290/348] some pytest on math folder (#1405)

* some pytest on math folder

* Run the test function via a doctest

Also format the code with psf/black as discussed in CONTRIBUTING.md

* Update abs.py

* Update average_mean.py
---
 maths/3n+1.py         | 19 ++++++++++---------
 maths/abs.py          | 20 +++++++++++++-------
 maths/average_mean.py | 16 ++++++++++------
 3 files changed, 33 insertions(+), 22 deletions(-)

diff --git a/maths/3n+1.py b/maths/3n+1.py
index 6b2dfc785794..ff769550297c 100644
--- a/maths/3n+1.py
+++ b/maths/3n+1.py
@@ -23,15 +23,16 @@ def n31(a: int) -> Tuple[List[int], int]:
     return path, len(path)
 
 
-def main():
-    num = 4
-    path, length = n31(num)
-    print(
-        "The Collatz sequence of {0} took {1} steps. \nPath: {2}".format(
-            num, length, path
-        )
-    )
+def test_n31():
+    """
+    >>> test_n31()
+    """
+    assert n31(4) == ([4, 2, 1], 3)
+    assert n31(11) == ([11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1], 15)
+    assert n31(31) == ([31, 94, 47, 142, 71, 214, 107, 322, 161, 484, 242, 121, 364, 182, 91, 274, 137, 412, 206, 103, 310, 155, 466, 233, 700, 350, 175, 526, 263, 790, 395, 1186, 593, 1780, 890, 445, 1336, 668, 334, 167, 502, 251, 754, 377, 1132, 566, 283, 850, 425, 1276, 638, 319, 958, 479, 1438, 719, 2158, 1079, 3238, 1619, 4858, 2429, 7288, 3644, 1822, 911, 2734, 1367, 4102, 2051, 6154, 3077, 9232, 4616, 2308, 1154, 577, 1732, 866, 433, 1300, 650, 325, 976, 488, 244, 122, 61, 184, 92, 46, 23, 70, 35, 106, 53, 160, 80, 40, 20, 10, 5, 16, 8, 4, 2, 1], 107)
 
 
 if __name__ == "__main__":
-    main()
+    num = 4
+    path, length = n31(num)
+    print(f"The Collatz sequence of {num} took {length} steps. \nPath: {path}")
diff --git a/maths/abs.py b/maths/abs.py
index 7509c5c20a22..68c99a1d51d8 100644
--- a/maths/abs.py
+++ b/maths/abs.py
@@ -5,18 +5,24 @@ def abs_val(num):
     """
     Find the absolute value of a number.
 
-    >>abs_val(-5)
-    5
-    >>abs_val(0)
+    >>> abs_val(-5.1)
+    5.1
+    >>> abs_val(-5) == abs_val(5)
+    True
+    >>> abs_val(0)
     0
     """
     return -num if num < 0 else num
 
 
-def main():
-    """Print absolute value of -34."""
-    print(abs_val(-34))  # = 34
+def test_abs_val():
+    """
+    >>> test_abs_val()
+    """
+    assert 0 == abs_val(0)
+    assert 34 == abs_val(34)
+    assert 100000000000 == abs_val(-100000000000)
 
 
 if __name__ == "__main__":
-    main()
+    print(abs_val(-34))  # --> 34
diff --git a/maths/average_mean.py b/maths/average_mean.py
index 77464ef5d9f7..4beca1f741a0 100644
--- a/maths/average_mean.py
+++ b/maths/average_mean.py
@@ -3,14 +3,18 @@
 
 def average(nums):
     """Find mean of a list of numbers."""
-    avg = sum(nums) / len(nums)
-    return avg
+    return sum(nums) / len(nums)
 
 
-def main():
-    """Call average module to find mean of a specific list of numbers."""
-    print(average([2, 4, 6, 8, 20, 50, 70]))
+def test_average():
+    """
+    >>> test_average()
+    """
+    assert 12.0 == average([3, 6, 9, 12, 15, 18, 21])
+    assert 20 == average([5, 10, 15, 20, 25, 30, 35])
+    assert 4.5 == average([1, 2, 3, 4, 5, 6, 7, 8])
 
 
 if __name__ == "__main__":
-    main()
+    """Call average module to find mean of a specific list of numbers."""
+    print(average([2, 4, 6, 8, 20, 50, 70]))

From 4531ea425e911a84a4fa507633fc5b566832e4b2 Mon Sep 17 00:00:00 2001
From: Christian Clauss <cclauss@me.com>
Date: Tue, 22 Oct 2019 08:45:03 +0200
Subject: [PATCH 291/348] Transfer .ipynb files to TheAlgorithms/Jupyter
 (#1414)

---
 machine_learning/dbscan/dbscan.ipynb          |  376 ----
 machine_learning/dbscan/dbscan.py             |  271 ---
 machine_learning/naive_bayes.ipynb            | 1659 -----------------
 .../Social_Network_Ads.csv                    |  401 ----
 .../random_forest_classification.py           |  103 -
 .../random_forest_classifier.ipynb            |  196 --
 .../Position_Salaries.csv                     |   11 -
 .../random_forest_regression.ipynb            |  147 --
 .../random_forest_regression.py               |   44 -
 .../reuters_one_vs_rest_classifier.ipynb      |  405 ----
 .../fully_connected_neural_network.ipynb      |  327 ----
 11 files changed, 3940 deletions(-)
 delete mode 100644 machine_learning/dbscan/dbscan.ipynb
 delete mode 100644 machine_learning/dbscan/dbscan.py
 delete mode 100644 machine_learning/naive_bayes.ipynb
 delete mode 100644 machine_learning/random_forest_classification/Social_Network_Ads.csv
 delete mode 100644 machine_learning/random_forest_classification/random_forest_classification.py
 delete mode 100644 machine_learning/random_forest_classification/random_forest_classifier.ipynb
 delete mode 100644 machine_learning/random_forest_regression/Position_Salaries.csv
 delete mode 100644 machine_learning/random_forest_regression/random_forest_regression.ipynb
 delete mode 100644 machine_learning/random_forest_regression/random_forest_regression.py
 delete mode 100644 machine_learning/reuters_one_vs_rest_classifier.ipynb
 delete mode 100644 neural_network/fully_connected_neural_network.ipynb

diff --git a/machine_learning/dbscan/dbscan.ipynb b/machine_learning/dbscan/dbscan.ipynb
deleted file mode 100644
index 603a4cd405b9..000000000000
--- a/machine_learning/dbscan/dbscan.ipynb
+++ /dev/null
@@ -1,376 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## DBSCAN\n",
-    "This implementation and notebook is inspired from the original DBSCAN algorithm and article as given in \n",
-    "[DBSCAN Wikipedia](https://en.wikipedia.org/wiki/DBSCAN).\n",
-    "\n",
-    "Stands for __Density-based spatial clustering of applications with noise__ . \n",
-    "\n",
-    "DBSCAN is clustering algorithm that tries to captures the intuition that if two points belong to the same cluster they should be close to one another. It does so by finding regions that are densely packed together, i.e, the points that have many close neighbours.\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### When to use ?\n",
-    "\n",
-    "1. You need a robust clustering algorithm.\n",
-    "2. You don't know how many clusters there are in the dataset\n",
-    "3. You find it difficult to guess the number of clusters there are just by eyeballing the dataset.\n",
-    "4. The clusters are of arbitrary shapes.\n",
-    "5. You want to detect outliers/noise."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Why DBSCAN ? \n",
-    "\n",
-    "This algorithm is way better than other clustering algorithms such as [k-means](https://en.wikipedia.org/wiki/K-means_clustering) whose only job is to find circular blobs. It is smart enough to figure out the number of clusters in the dataset on its own, unlike k-means where you need to specify 'k'.  It can also find clusters of arbitrary shapes, not just circular blobs.  Its too robust to be affected by outliers (the noise points) and isn't fooled by them, unlike k-means where the entire centroid get pulled thanks to pesky outliers. Plus, you can fine-tune its parameters depending on what you are clustering.\n",
-    "\n",
-    "#### Have a look at these [neat animations](https://www.naftaliharris.com/blog/visualizing-dbscan-clustering/) of DBSCAN to see for yourself."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import matplotlib.pyplot as plt\n",
-    "import numpy as np\n",
-    "\n",
-    "%matplotlib inline"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## First lets grab a dataset\n",
-    "We will take the moons dataset which is pretty good at showing the power of DBSCAN. \n",
-    "\n",
-    "Lets generate 200 random points in the shape of two moons"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from sklearn.datasets import make_moons\n",
-    "\n",
-    "x, label = make_moons(n_samples=200, noise=0.1, random_state=19)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Visualize the dataset using matplotlib\n",
-    "You will observe that the points are in the shape of two crescent moons. \n",
-    "\n",
-    "The challenge here is to cluster the two moons. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {
-    "scrolled": false
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x11a00e588>]"
-      ]
-     },
-     "execution_count": 3,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plt.plot(x[:,0], x[:,1],'ro')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Abstract of the Algorithm\n",
-    "The DBSCAN algorithm can be abstracted into the following steps:\n",
-    "\n",
-    "- Find the points in the $ε$ (eps) neighborhood of every point, and identify the core points with more than <b>min_pts</b> neighbors.\n",
-    "- Find the connected components of core points on the neighbor graph, ignoring all non-core points.\n",
-    "- Assign each non-core point to a nearby cluster if the cluster is an $ε$ (eps) neighbor, otherwise assign it to noise.\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Preparing the points\n",
-    "Initially we label all the points in the dataset as __undefined__ .\n",
-    "\n",
-    "__points__ is our database of all points in the dataset."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "points = { (point[0],point[1]):{'label':'undefined'} for point in x }"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Helper functions"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def euclidean_distance(q, p):\n",
-    "    \"\"\"\n",
-    "        Calculates the Euclidean distance\n",
-    "        between points P and Q\n",
-    "    \"\"\"\n",
-    "    a = pow((q[0] - p[0]), 2)\n",
-    "    b = pow((q[1] - p[1]), 2)\n",
-    "    return pow((a + b), 0.5)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def find_neighbors(db, q, eps):\n",
-    "    \"\"\"\n",
-    "        Finds all points in the DB that\n",
-    "        are within a distance of eps from Q\n",
-    "    \"\"\"\n",
-    "    return [p for p in db if euclidean_distance(q, p) <= eps]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def plot_cluster(db, clusters):\n",
-    "    \"\"\"\n",
-    "        Extracts all the points in the DB and puts them together\n",
-    "        as seperate clusters and finally plots them\n",
-    "    \"\"\"\n",
-    "    temp = []\n",
-    "    noise = []\n",
-    "    for i in clusters:\n",
-    "        stack = []\n",
-    "        for k, v in db.items():\n",
-    "            if v[\"label\"] == i:\n",
-    "                stack.append(k)\n",
-    "            elif v[\"label\"] == \"noise\":\n",
-    "                noise.append(k)\n",
-    "        temp.append(stack)\n",
-    "\n",
-    "    color = iter(plt.cm.rainbow(np.linspace(0, 1, len(clusters))))\n",
-    "    for i in range(0, len(temp)):\n",
-    "        c = next(color)\n",
-    "        x = [l[0] for l in temp[i]]\n",
-    "        y = [l[1] for l in temp[i]]\n",
-    "        plt.plot(x, y, \"ro\", c=c)\n",
-    "\n",
-    "    x = [l[0] for l in noise]\n",
-    "    y = [l[1] for l in noise]\n",
-    "    plt.plot(x, y, \"ro\", c=\"0\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Implementation of DBSCAN\n",
-    "\n",
-    "Initialize an empty list, clusters = $[ ]$ and cluster identifier, c = 0\n",
-    "\n",
-    "1. For each point  p in our database/dict  db :\n",
-    "\n",
-    "    1.1 Check if p is already labelled. If it's already labelled (means it already been associated to a cluster), continue to the next point,i.e, go to step 1\n",
-    "    \n",
-    "    1.2. Find the list of neighbors of p , i.e, points that are within a distance of eps from p\n",
-    "    \n",
-    "    1.3. If p does not have atleast min_pts neighbours, we label it as noise and go back to step 1\n",
-    "    \n",
-    "    1.4. Initialize the cluster, by incrementing c by 1\n",
-    "    \n",
-    "    1.5. Append the cluster identifier c to clusters\n",
-    "    \n",
-    "    1.6. Label p with the cluster identifier c\n",
-    "    \n",
-    "    1.7 Remove p from the list of neighbors (p will be detected as its own neighbor because it is within eps of itself)\n",
-    "    \n",
-    "    1.8. Initialize the seed_set as a copy of neighbors\n",
-    "   \n",
-    "    1.9. While the seed_set is not empty:\n",
-    "        1.9.1. Removing the 1st point from seed_set and initialise it as q\n",
-    "        1.9.2. If it's label is noise, label it with c\n",
-    "        1.9.3. If it's not unlabelled, go back to step 1.9\n",
-    "        1.9.4. Label q with c\n",
-    "        1.9.5. Find the neighbours of q \n",
-    "        1.9.6. If there are atleast min_pts neighbors, append them to the seed_set"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def dbscan(db,eps,min_pts):\n",
-    "    '''\n",
-    "        Implementation of the DBSCAN algorithm\n",
-    "    '''\n",
-    "    clusters = []\n",
-    "    c = 0\n",
-    "    for p in db:\n",
-    "        if db[p][\"label\"] != \"undefined\":\n",
-    "            continue\n",
-    "        neighbors = find_neighbors(db, p, eps)\n",
-    "        if len(neighbors) < min_pts:\n",
-    "            db[p][\"label\"] = \"noise\"\n",
-    "            continue\n",
-    "        c += 1\n",
-    "        clusters.append(c)\n",
-    "        db[p][\"label\"] = c\n",
-    "        neighbors.remove(p)\n",
-    "        seed_set = neighbors.copy()\n",
-    "        while seed_set != []:\n",
-    "            q = seed_set.pop(0)\n",
-    "            if db[q][\"label\"] == \"noise\":\n",
-    "                db[q][\"label\"] = c\n",
-    "            if db[q][\"label\"] != \"undefined\":\n",
-    "                continue\n",
-    "            db[q][\"label\"] = c\n",
-    "            neighbors_n = find_neighbors(db, q, eps)\n",
-    "            if len(neighbors_n) >= min_pts:\n",
-    "                seed_set = seed_set + neighbors_n\n",
-    "    return db, clusters\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Lets run it!"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "eps = 0.25\n",
-    "min_pts = 12\n",
-    "\n",
-    "db,clusters = dbscan(points,eps,min_pts)\n",
-    "\n",
-    "plot_cluster(db,clusters)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "I encourage you to try with different datasets and playing with the values of eps and min_pts.\n",
-    "\n",
-    "Also, try kmeans on this dataset and see how it compares to dbscan. "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "I hope by now you are convinced about about how cool dbscan is. But it has its pitfalls.\n",
-    "### When NOT to use ?\n",
-    "\n",
-    "1. You have a high dimentional dataset. Euclidean distance will fail thanks to '[curse of dimentionality](https://en.wikipedia.org/wiki/Curse_of_dimensionality#Distance_functions)'.\n",
-    "2. We have used a dict to store the points. So we can't do anything about the order in which the points will be processed. So it's not entirely deterministic.\n",
-    "3. Won't work well if there are large differences in density. Finding the min_pts and $ε$ combination will be difficult.\n",
-    "4. Choosing the $ε$ without understanding the data and its scale, might result is poor clustering performance."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.7.0"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/machine_learning/dbscan/dbscan.py b/machine_learning/dbscan/dbscan.py
deleted file mode 100644
index 04fb5f0186e1..000000000000
--- a/machine_learning/dbscan/dbscan.py
+++ /dev/null
@@ -1,271 +0,0 @@
-import matplotlib.pyplot as plt
-import numpy as np
-from sklearn.datasets import make_moons
-import warnings
-
-
-def euclidean_distance(q, p):
-    """
-        Calculates the Euclidean distance
-        between points q and p
-
-        Distance can only be calculated between numeric values
-        >>> euclidean_distance([1,'a'],[1,2])
-        Traceback (most recent call last):
-        ...
-        ValueError: Non-numeric input detected
-
-        The dimentions of both the points must be the same
-        >>> euclidean_distance([1,1,1],[1,2])
-        Traceback (most recent call last):
-        ...
-        ValueError: expected dimensions to be 2-d, instead got p:3 and q:2
-
-        Supports only two dimentional points
-        >>> euclidean_distance([1,1,1],[1,2])
-        Traceback (most recent call last):
-        ...
-        ValueError: expected dimensions to be 2-d, instead got p:3 and q:2
-
-        Input should be in the format [x,y] or (x,y)
-        >>> euclidean_distance(1,2)
-        Traceback (most recent call last):
-        ...
-        TypeError: inputs must be iterable, either list [x,y] or tuple (x,y)
-    """
-    if not hasattr(q, "__iter__") or not hasattr(p, "__iter__"):
-        raise TypeError("inputs must be iterable, either list [x,y] or tuple (x,y)")
-
-    if isinstance(q, str) or isinstance(p, str):
-        raise TypeError("inputs cannot be str")
-
-    if len(q) != 2 or len(p) != 2:
-        raise ValueError(
-            "expected dimensions to be 2-d, instead got p:{} and q:{}".format(
-                len(q), len(p)
-            )
-        )
-
-    for num in q + p:
-        try:
-            num = int(num)
-        except:
-            raise ValueError("Non-numeric input detected")
-
-    a = pow((q[0] - p[0]), 2)
-    b = pow((q[1] - p[1]), 2)
-    return pow((a + b), 0.5)
-
-
-def find_neighbors(db, q, eps):
-    """
-        Finds all points in the db that
-        are within a distance of eps from Q
-
-        eps value should be a number
-        >>> find_neighbors({ (1,2):{'label':'undefined'}, (2,3):{'label':'undefined'}}, (2,5),'a')
-        Traceback (most recent call last):
-        ...
-        ValueError: eps should be either int or float
-
-        Q must be a 2-d point as list or tuple
-        >>> find_neighbors({ (1,2):{'label':'undefined'}, (2,3):{'label':'undefined'}}, 2, 0.5)
-        Traceback (most recent call last):
-        ...
-        TypeError: Q must a 2-dimentional point in the format (x,y) or [x,y]
-
-        Points must be in correct format
-        >>> find_neighbors([], (2,2) ,0.4)
-        Traceback (most recent call last):
-        ...
-        TypeError: db must be a dict of points in the format {(x,y):{'label':'boolean/undefined'}}
-    """
-
-    if not isinstance(eps, (int, float)):
-        raise ValueError("eps should be either int or float")
-
-    if not hasattr(q, "__iter__"):
-        raise TypeError("Q must a 2-dimentional point in the format (x,y) or [x,y]")
-
-    if not isinstance(db, dict):
-        raise TypeError(
-            "db must be a dict of points in the format {(x,y):{'label':'boolean/undefined'}}"
-        )
-
-    return [p for p in db if euclidean_distance(q, p) <= eps]
-
-
-def plot_cluster(db, clusters, ax):
-    """
-        Extracts all the points in the db and puts them together
-        as seperate clusters and finally plots them
-
-        db cannot be empty
-        >>> fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(7, 5))
-        >>> plot_cluster({},[1,2], axes[1] )
-        Traceback (most recent call last):
-        ...
-        Exception: db is empty. No points to cluster
-
-        clusters cannot be empty
-        >>> fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(7, 5))
-        >>> plot_cluster({ (1,2):{'label':'undefined'}, (2,3):{'label':'undefined'}},[],axes[1] )
-        Traceback (most recent call last):
-        ...
-        Exception: nothing to cluster. Empty clusters
-
-        clusters cannot be empty
-        >>> fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(7, 5))
-        >>> plot_cluster({ (1,2):{'label':'undefined'}, (2,3):{'label':'undefined'}},[],axes[1] )
-        Traceback (most recent call last):
-        ...
-        Exception: nothing to cluster. Empty clusters
-
-        ax must be a plotable
-        >>> plot_cluster({ (1,2):{'label':'1'}, (2,3):{'label':'2'}},[1,2], [] )
-        Traceback (most recent call last):
-        ...
-        TypeError: ax must be an slot in a matplotlib figure
-    """
-    if len(db) == 0:
-        raise Exception("db is empty. No points to cluster")
-
-    if len(clusters) == 0:
-        raise Exception("nothing to cluster. Empty clusters")
-
-    if not hasattr(ax, "plot"):
-        raise TypeError("ax must be an slot in a matplotlib figure")
-
-    temp = []
-    noise = []
-    for i in clusters:
-        stack = []
-        for k, v in db.items():
-            if v["label"] == i:
-                stack.append(k)
-            elif v["label"] == "noise":
-                noise.append(k)
-        temp.append(stack)
-
-    color = iter(plt.cm.rainbow(np.linspace(0, 1, len(clusters))))
-    for i in range(0, len(temp)):
-        c = next(color)
-        x = [l[0] for l in temp[i]]
-        y = [l[1] for l in temp[i]]
-        ax.plot(x, y, "ro", c=c)
-
-    x = [l[0] for l in noise]
-    y = [l[1] for l in noise]
-    ax.plot(x, y, "ro", c="0")
-
-
-def dbscan(db, eps, min_pts):
-    """
-        Implementation of the DBSCAN algorithm
-
-        Points must be in correct format
-        >>> dbscan([], (2,2) ,0.4)
-        Traceback (most recent call last):
-        ...
-        TypeError: db must be a dict of points in the format {(x,y):{'label':'boolean/undefined'}}
-
-        eps value should be a number
-        >>> dbscan({ (1,2):{'label':'undefined'}, (2,3):{'label':'undefined'}},'a',20 )
-        Traceback (most recent call last):
-        ...
-        ValueError: eps should be either int or float
-
-        min_pts value should be an integer
-        >>> dbscan({ (1,2):{'label':'undefined'}, (2,3):{'label':'undefined'}},0.4,20.0 )
-        Traceback (most recent call last):
-        ...
-        ValueError: min_pts should be int
-
-        db cannot be empty
-        >>> dbscan({},0.4,20.0 )
-        Traceback (most recent call last):
-        ...
-        Exception: db is empty, nothing to cluster
-
-        min_pts cannot be negative
-        >>> dbscan({ (1,2):{'label':'undefined'}, (2,3):{'label':'undefined'}}, 0.4, -20)
-        Traceback (most recent call last):
-        ...
-        ValueError: min_pts or eps cannot be negative
-
-        eps cannot be negative
-        >>> dbscan({ (1,2):{'label':'undefined'}, (2,3):{'label':'undefined'}},-0.4, 20)
-        Traceback (most recent call last):
-        ...
-        ValueError: min_pts or eps cannot be negative
-
-    """
-    if not isinstance(db, dict):
-        raise TypeError(
-            "db must be a dict of points in the format {(x,y):{'label':'boolean/undefined'}}"
-        )
-
-    if len(db) == 0:
-        raise Exception("db is empty, nothing to cluster")
-
-    if not isinstance(eps, (int, float)):
-        raise ValueError("eps should be either int or float")
-
-    if not isinstance(min_pts, int):
-        raise ValueError("min_pts should be int")
-
-    if min_pts < 0 or eps < 0:
-        raise ValueError("min_pts or eps cannot be negative")
-
-    if min_pts == 0:
-        warnings.warn("min_pts is 0. Are you sure you want this ?")
-
-    if eps == 0:
-        warnings.warn("eps is 0. Are you sure you want this ?")
-
-    clusters = []
-    c = 0
-    for p in db:
-        if db[p]["label"] != "undefined":
-            continue
-        neighbors = find_neighbors(db, p, eps)
-        if len(neighbors) < min_pts:
-            db[p]["label"] = "noise"
-            continue
-        c += 1
-        clusters.append(c)
-        db[p]["label"] = c
-        neighbors.remove(p)
-        seed_set = neighbors.copy()
-        while seed_set != []:
-            q = seed_set.pop(0)
-            if db[q]["label"] == "noise":
-                db[q]["label"] = c
-            if db[q]["label"] != "undefined":
-                continue
-            db[q]["label"] = c
-            neighbors_n = find_neighbors(db, q, eps)
-            if len(neighbors_n) >= min_pts:
-                seed_set = seed_set + neighbors_n
-    return db, clusters
-
-
-if __name__ == "__main__":
-
-    fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(7, 5))
-
-    x, label = make_moons(n_samples=200, noise=0.1, random_state=19)
-
-    axes[0].plot(x[:, 0], x[:, 1], "ro")
-
-    points = {(point[0], point[1]): {"label": "undefined"} for point in x}
-
-    eps = 0.25
-
-    min_pts = 12
-
-    db, clusters = dbscan(points, eps, min_pts)
-
-    plot_cluster(db, clusters, axes[1])
-
-    plt.show()
diff --git a/machine_learning/naive_bayes.ipynb b/machine_learning/naive_bayes.ipynb
deleted file mode 100644
index 5a427c5cb965..000000000000
--- a/machine_learning/naive_bayes.ipynb
+++ /dev/null
@@ -1,1659 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [],
-   "source": [
-    "from sklearn import datasets\n",
-    "import pandas as pd"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [],
-   "source": [
-    "iris = datasets.load_iris()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [],
-   "source": [
-    "df = pd.DataFrame(iris.data)\n",
-    "df.columns = [\"sl\", \"sw\", 'pl', 'pw']"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [],
-   "source": [
-    "def abc(k, *val):\n",
-    "    if k < val[0]:\n",
-    "        return 0\n",
-    "    else:\n",
-    "        return 1"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "0      1\n",
-       "1      0\n",
-       "2      0\n",
-       "3      0\n",
-       "4      1\n",
-       "5      1\n",
-       "6      0\n",
-       "7      1\n",
-       "8      0\n",
-       "9      0\n",
-       "10     1\n",
-       "11     0\n",
-       "12     0\n",
-       "13     0\n",
-       "14     1\n",
-       "15     1\n",
-       "16     1\n",
-       "17     1\n",
-       "18     1\n",
-       "19     1\n",
-       "20     1\n",
-       "21     1\n",
-       "22     0\n",
-       "23     1\n",
-       "24     0\n",
-       "25     1\n",
-       "26     1\n",
-       "27     1\n",
-       "28     1\n",
-       "29     0\n",
-       "      ..\n",
-       "120    1\n",
-       "121    1\n",
-       "122    1\n",
-       "123    1\n",
-       "124    1\n",
-       "125    1\n",
-       "126    1\n",
-       "127    1\n",
-       "128    1\n",
-       "129    1\n",
-       "130    1\n",
-       "131    1\n",
-       "132    1\n",
-       "133    1\n",
-       "134    1\n",
-       "135    1\n",
-       "136    1\n",
-       "137    1\n",
-       "138    1\n",
-       "139    1\n",
-       "140    1\n",
-       "141    1\n",
-       "142    1\n",
-       "143    1\n",
-       "144    1\n",
-       "145    1\n",
-       "146    1\n",
-       "147    1\n",
-       "148    1\n",
-       "149    1\n",
-       "Name: sl, dtype: int64"
-      ]
-     },
-     "execution_count": 5,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "df.sl.apply(abc, args=(5,))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def label(val, *boundaries):\n",
-    "    if (val < boundaries[0]):\n",
-    "        return 'a'\n",
-    "    elif (val < boundaries[1]):\n",
-    "        return 'b'\n",
-    "    elif (val < boundaries[2]):\n",
-    "        return 'c'\n",
-    "    else:\n",
-    "        return 'd'\n",
-    "\n",
-    "def toLabel(df, old_feature_name):\n",
-    "    second = df[old_feature_name].mean()\n",
-    "    minimum = df[old_feature_name].min()\n",
-    "    first = (minimum + second)/2\n",
-    "    maximum = df[old_feature_name].max()\n",
-    "    third = (maximum + second)/2\n",
-    "    return df[old_feature_name].apply(label, args= (first, second, third))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<div>\n",
-       "<table border=\"1\" class=\"dataframe\">\n",
-       "  <thead>\n",
-       "    <tr style=\"text-align: right;\">\n",
-       "      <th></th>\n",
-       "      <th>sl</th>\n",
-       "      <th>sw</th>\n",
-       "      <th>pl</th>\n",
-       "      <th>pw</th>\n",
-       "      <th>sl_labeled</th>\n",
-       "      <th>sw_labeled</th>\n",
-       "      <th>pl_labeled</th>\n",
-       "      <th>pw_labeled</th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <th>0</th>\n",
-       "      <td>5.1</td>\n",
-       "      <td>3.5</td>\n",
-       "      <td>1.4</td>\n",
-       "      <td>0.2</td>\n",
-       "      <td>b</td>\n",
-       "      <td>c</td>\n",
-       "      <td>a</td>\n",
-       "      <td>a</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>1</th>\n",
-       "      <td>4.9</td>\n",
-       "      <td>3.0</td>\n",
-       "      <td>1.4</td>\n",
-       "      <td>0.2</td>\n",
-       "      <td>a</td>\n",
-       "      <td>b</td>\n",
-       "      <td>a</td>\n",
-       "      <td>a</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2</th>\n",
-       "      <td>4.7</td>\n",
-       "      <td>3.2</td>\n",
-       "      <td>1.3</td>\n",
-       "      <td>0.2</td>\n",
-       "      <td>a</td>\n",
-       "      <td>c</td>\n",
-       "      <td>a</td>\n",
-       "      <td>a</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>3</th>\n",
-       "      <td>4.6</td>\n",
-       "      <td>3.1</td>\n",
-       "      <td>1.5</td>\n",
-       "      <td>0.2</td>\n",
-       "      <td>a</td>\n",
-       "      <td>c</td>\n",
-       "      <td>a</td>\n",
-       "      <td>a</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>4</th>\n",
-       "      <td>5.0</td>\n",
-       "      <td>3.6</td>\n",
-       "      <td>1.4</td>\n",
-       "      <td>0.2</td>\n",
-       "      <td>a</td>\n",
-       "      <td>c</td>\n",
-       "      <td>a</td>\n",
-       "      <td>a</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>5</th>\n",
-       "      <td>5.4</td>\n",
-       "      <td>3.9</td>\n",
-       "      <td>1.7</td>\n",
-       "      <td>0.4</td>\n",
-       "      <td>b</td>\n",
-       "      <td>d</td>\n",
-       "      <td>a</td>\n",
-       "      <td>a</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>6</th>\n",
-       "      <td>4.6</td>\n",
-       "      <td>3.4</td>\n",
-       "      <td>1.4</td>\n",
-       "      <td>0.3</td>\n",
-       "      <td>a</td>\n",
-       "      <td>c</td>\n",
-       "      <td>a</td>\n",
-       "      <td>a</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>7</th>\n",
-       "      <td>5.0</td>\n",
-       "      <td>3.4</td>\n",
-       "      <td>1.5</td>\n",
-       "      <td>0.2</td>\n",
-       "      <td>a</td>\n",
-       "      <td>c</td>\n",
-       "      <td>a</td>\n",
-       "      <td>a</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>8</th>\n",
-       "      <td>4.4</td>\n",
-       "      <td>2.9</td>\n",
-       "      <td>1.4</td>\n",
-       "      <td>0.2</td>\n",
-       "      <td>a</td>\n",
-       "      <td>b</td>\n",
-       "      <td>a</td>\n",
-       "      <td>a</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>9</th>\n",
-       "      <td>4.9</td>\n",
-       "      <td>3.1</td>\n",
-       "      <td>1.5</td>\n",
-       "      <td>0.1</td>\n",
-       "      <td>a</td>\n",
-       "      <td>c</td>\n",
-       "      <td>a</td>\n",
-       "      <td>a</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>10</th>\n",
-       "      <td>5.4</td>\n",
-       "      <td>3.7</td>\n",
-       "      <td>1.5</td>\n",
-       "      <td>0.2</td>\n",
-       "      <td>b</td>\n",
-       "      <td>c</td>\n",
-       "      <td>a</td>\n",
-       "      <td>a</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>11</th>\n",
-       "      <td>4.8</td>\n",
-       "      <td>3.4</td>\n",
-       "      <td>1.6</td>\n",
-       "      <td>0.2</td>\n",
-       "      <td>a</td>\n",
-       "      <td>c</td>\n",
-       "      <td>a</td>\n",
-       "      <td>a</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>12</th>\n",
-       "      <td>4.8</td>\n",
-       "      <td>3.0</td>\n",
-       "      <td>1.4</td>\n",
-       "      <td>0.1</td>\n",
-       "      <td>a</td>\n",
-       "      <td>b</td>\n",
-       "      <td>a</td>\n",
-       "      <td>a</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>13</th>\n",
-       "      <td>4.3</td>\n",
-       "      <td>3.0</td>\n",
-       "      <td>1.1</td>\n",
-       "      <td>0.1</td>\n",
-       "      <td>a</td>\n",
-       "      <td>b</td>\n",
-       "      <td>a</td>\n",
-       "      <td>a</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>14</th>\n",
-       "      <td>5.8</td>\n",
-       "      <td>4.0</td>\n",
-       "      <td>1.2</td>\n",
-       "      <td>0.2</td>\n",
-       "      <td>b</td>\n",
-       "      <td>d</td>\n",
-       "      <td>a</td>\n",
-       "      <td>a</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>15</th>\n",
-       "      <td>5.7</td>\n",
-       "      <td>4.4</td>\n",
-       "      <td>1.5</td>\n",
-       "      <td>0.4</td>\n",
-       "      <td>b</td>\n",
-       "      <td>d</td>\n",
-       "      <td>a</td>\n",
-       "      <td>a</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>16</th>\n",
-       "      <td>5.4</td>\n",
-       "      <td>3.9</td>\n",
-       "      <td>1.3</td>\n",
-       "      <td>0.4</td>\n",
-       "      <td>b</td>\n",
-       "      <td>d</td>\n",
-       "      <td>a</td>\n",
-       "      <td>a</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>17</th>\n",
-       "      <td>5.1</td>\n",
-       "      <td>3.5</td>\n",
-       "      <td>1.4</td>\n",
-       "      <td>0.3</td>\n",
-       "      <td>b</td>\n",
-       "      <td>c</td>\n",
-       "      <td>a</td>\n",
-       "      <td>a</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>18</th>\n",
-       "      <td>5.7</td>\n",
-       "      <td>3.8</td>\n",
-       "      <td>1.7</td>\n",
-       "      <td>0.3</td>\n",
-       "      <td>b</td>\n",
-       "      <td>d</td>\n",
-       "      <td>a</td>\n",
-       "      <td>a</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>19</th>\n",
-       "      <td>5.1</td>\n",
-       "      <td>3.8</td>\n",
-       "      <td>1.5</td>\n",
-       "      <td>0.3</td>\n",
-       "      <td>b</td>\n",
-       "      <td>d</td>\n",
-       "      <td>a</td>\n",
-       "      <td>a</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>20</th>\n",
-       "      <td>5.4</td>\n",
-       "      <td>3.4</td>\n",
-       "      <td>1.7</td>\n",
-       "      <td>0.2</td>\n",
-       "      <td>b</td>\n",
-       "      <td>c</td>\n",
-       "      <td>a</td>\n",
-       "      <td>a</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>21</th>\n",
-       "      <td>5.1</td>\n",
-       "      <td>3.7</td>\n",
-       "      <td>1.5</td>\n",
-       "      <td>0.4</td>\n",
-       "      <td>b</td>\n",
-       "      <td>c</td>\n",
-       "      <td>a</td>\n",
-       "      <td>a</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>22</th>\n",
-       "      <td>4.6</td>\n",
-       "      <td>3.6</td>\n",
-       "      <td>1.0</td>\n",
-       "      <td>0.2</td>\n",
-       "      <td>a</td>\n",
-       "      <td>c</td>\n",
-       "      <td>a</td>\n",
-       "      <td>a</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>23</th>\n",
-       "      <td>5.1</td>\n",
-       "      <td>3.3</td>\n",
-       "      <td>1.7</td>\n",
-       "      <td>0.5</td>\n",
-       "      <td>b</td>\n",
-       "      <td>c</td>\n",
-       "      <td>a</td>\n",
-       "      <td>a</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>24</th>\n",
-       "      <td>4.8</td>\n",
-       "      <td>3.4</td>\n",
-       "      <td>1.9</td>\n",
-       "      <td>0.2</td>\n",
-       "      <td>a</td>\n",
-       "      <td>c</td>\n",
-       "      <td>a</td>\n",
-       "      <td>a</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>25</th>\n",
-       "      <td>5.0</td>\n",
-       "      <td>3.0</td>\n",
-       "      <td>1.6</td>\n",
-       "      <td>0.2</td>\n",
-       "      <td>a</td>\n",
-       "      <td>b</td>\n",
-       "      <td>a</td>\n",
-       "      <td>a</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>26</th>\n",
-       "      <td>5.0</td>\n",
-       "      <td>3.4</td>\n",
-       "      <td>1.6</td>\n",
-       "      <td>0.4</td>\n",
-       "      <td>a</td>\n",
-       "      <td>c</td>\n",
-       "      <td>a</td>\n",
-       "      <td>a</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>27</th>\n",
-       "      <td>5.2</td>\n",
-       "      <td>3.5</td>\n",
-       "      <td>1.5</td>\n",
-       "      <td>0.2</td>\n",
-       "      <td>b</td>\n",
-       "      <td>c</td>\n",
-       "      <td>a</td>\n",
-       "      <td>a</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>28</th>\n",
-       "      <td>5.2</td>\n",
-       "      <td>3.4</td>\n",
-       "      <td>1.4</td>\n",
-       "      <td>0.2</td>\n",
-       "      <td>b</td>\n",
-       "      <td>c</td>\n",
-       "      <td>a</td>\n",
-       "      <td>a</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>29</th>\n",
-       "      <td>4.7</td>\n",
-       "      <td>3.2</td>\n",
-       "      <td>1.6</td>\n",
-       "      <td>0.2</td>\n",
-       "      <td>a</td>\n",
-       "      <td>c</td>\n",
-       "      <td>a</td>\n",
-       "      <td>a</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>...</th>\n",
-       "      <td>...</td>\n",
-       "      <td>...</td>\n",
-       "      <td>...</td>\n",
-       "      <td>...</td>\n",
-       "      <td>...</td>\n",
-       "      <td>...</td>\n",
-       "      <td>...</td>\n",
-       "      <td>...</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>120</th>\n",
-       "      <td>6.9</td>\n",
-       "      <td>3.2</td>\n",
-       "      <td>5.7</td>\n",
-       "      <td>2.3</td>\n",
-       "      <td>d</td>\n",
-       "      <td>c</td>\n",
-       "      <td>d</td>\n",
-       "      <td>d</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>121</th>\n",
-       "      <td>5.6</td>\n",
-       "      <td>2.8</td>\n",
-       "      <td>4.9</td>\n",
-       "      <td>2.0</td>\n",
-       "      <td>b</td>\n",
-       "      <td>b</td>\n",
-       "      <td>c</td>\n",
-       "      <td>d</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>122</th>\n",
-       "      <td>7.7</td>\n",
-       "      <td>2.8</td>\n",
-       "      <td>6.7</td>\n",
-       "      <td>2.0</td>\n",
-       "      <td>d</td>\n",
-       "      <td>b</td>\n",
-       "      <td>d</td>\n",
-       "      <td>d</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>123</th>\n",
-       "      <td>6.3</td>\n",
-       "      <td>2.7</td>\n",
-       "      <td>4.9</td>\n",
-       "      <td>1.8</td>\n",
-       "      <td>c</td>\n",
-       "      <td>b</td>\n",
-       "      <td>c</td>\n",
-       "      <td>c</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>124</th>\n",
-       "      <td>6.7</td>\n",
-       "      <td>3.3</td>\n",
-       "      <td>5.7</td>\n",
-       "      <td>2.1</td>\n",
-       "      <td>c</td>\n",
-       "      <td>c</td>\n",
-       "      <td>d</td>\n",
-       "      <td>d</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>125</th>\n",
-       "      <td>7.2</td>\n",
-       "      <td>3.2</td>\n",
-       "      <td>6.0</td>\n",
-       "      <td>1.8</td>\n",
-       "      <td>d</td>\n",
-       "      <td>c</td>\n",
-       "      <td>d</td>\n",
-       "      <td>c</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>126</th>\n",
-       "      <td>6.2</td>\n",
-       "      <td>2.8</td>\n",
-       "      <td>4.8</td>\n",
-       "      <td>1.8</td>\n",
-       "      <td>c</td>\n",
-       "      <td>b</td>\n",
-       "      <td>c</td>\n",
-       "      <td>c</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>127</th>\n",
-       "      <td>6.1</td>\n",
-       "      <td>3.0</td>\n",
-       "      <td>4.9</td>\n",
-       "      <td>1.8</td>\n",
-       "      <td>c</td>\n",
-       "      <td>b</td>\n",
-       "      <td>c</td>\n",
-       "      <td>c</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>128</th>\n",
-       "      <td>6.4</td>\n",
-       "      <td>2.8</td>\n",
-       "      <td>5.6</td>\n",
-       "      <td>2.1</td>\n",
-       "      <td>c</td>\n",
-       "      <td>b</td>\n",
-       "      <td>d</td>\n",
-       "      <td>d</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>129</th>\n",
-       "      <td>7.2</td>\n",
-       "      <td>3.0</td>\n",
-       "      <td>5.8</td>\n",
-       "      <td>1.6</td>\n",
-       "      <td>d</td>\n",
-       "      <td>b</td>\n",
-       "      <td>d</td>\n",
-       "      <td>c</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>130</th>\n",
-       "      <td>7.4</td>\n",
-       "      <td>2.8</td>\n",
-       "      <td>6.1</td>\n",
-       "      <td>1.9</td>\n",
-       "      <td>d</td>\n",
-       "      <td>b</td>\n",
-       "      <td>d</td>\n",
-       "      <td>d</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>131</th>\n",
-       "      <td>7.9</td>\n",
-       "      <td>3.8</td>\n",
-       "      <td>6.4</td>\n",
-       "      <td>2.0</td>\n",
-       "      <td>d</td>\n",
-       "      <td>d</td>\n",
-       "      <td>d</td>\n",
-       "      <td>d</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>132</th>\n",
-       "      <td>6.4</td>\n",
-       "      <td>2.8</td>\n",
-       "      <td>5.6</td>\n",
-       "      <td>2.2</td>\n",
-       "      <td>c</td>\n",
-       "      <td>b</td>\n",
-       "      <td>d</td>\n",
-       "      <td>d</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>133</th>\n",
-       "      <td>6.3</td>\n",
-       "      <td>2.8</td>\n",
-       "      <td>5.1</td>\n",
-       "      <td>1.5</td>\n",
-       "      <td>c</td>\n",
-       "      <td>b</td>\n",
-       "      <td>c</td>\n",
-       "      <td>c</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>134</th>\n",
-       "      <td>6.1</td>\n",
-       "      <td>2.6</td>\n",
-       "      <td>5.6</td>\n",
-       "      <td>1.4</td>\n",
-       "      <td>c</td>\n",
-       "      <td>b</td>\n",
-       "      <td>d</td>\n",
-       "      <td>c</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>135</th>\n",
-       "      <td>7.7</td>\n",
-       "      <td>3.0</td>\n",
-       "      <td>6.1</td>\n",
-       "      <td>2.3</td>\n",
-       "      <td>d</td>\n",
-       "      <td>b</td>\n",
-       "      <td>d</td>\n",
-       "      <td>d</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>136</th>\n",
-       "      <td>6.3</td>\n",
-       "      <td>3.4</td>\n",
-       "      <td>5.6</td>\n",
-       "      <td>2.4</td>\n",
-       "      <td>c</td>\n",
-       "      <td>c</td>\n",
-       "      <td>d</td>\n",
-       "      <td>d</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>137</th>\n",
-       "      <td>6.4</td>\n",
-       "      <td>3.1</td>\n",
-       "      <td>5.5</td>\n",
-       "      <td>1.8</td>\n",
-       "      <td>c</td>\n",
-       "      <td>c</td>\n",
-       "      <td>d</td>\n",
-       "      <td>c</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>138</th>\n",
-       "      <td>6.0</td>\n",
-       "      <td>3.0</td>\n",
-       "      <td>4.8</td>\n",
-       "      <td>1.8</td>\n",
-       "      <td>c</td>\n",
-       "      <td>b</td>\n",
-       "      <td>c</td>\n",
-       "      <td>c</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>139</th>\n",
-       "      <td>6.9</td>\n",
-       "      <td>3.1</td>\n",
-       "      <td>5.4</td>\n",
-       "      <td>2.1</td>\n",
-       "      <td>d</td>\n",
-       "      <td>c</td>\n",
-       "      <td>d</td>\n",
-       "      <td>d</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>140</th>\n",
-       "      <td>6.7</td>\n",
-       "      <td>3.1</td>\n",
-       "      <td>5.6</td>\n",
-       "      <td>2.4</td>\n",
-       "      <td>c</td>\n",
-       "      <td>c</td>\n",
-       "      <td>d</td>\n",
-       "      <td>d</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>141</th>\n",
-       "      <td>6.9</td>\n",
-       "      <td>3.1</td>\n",
-       "      <td>5.1</td>\n",
-       "      <td>2.3</td>\n",
-       "      <td>d</td>\n",
-       "      <td>c</td>\n",
-       "      <td>c</td>\n",
-       "      <td>d</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>142</th>\n",
-       "      <td>5.8</td>\n",
-       "      <td>2.7</td>\n",
-       "      <td>5.1</td>\n",
-       "      <td>1.9</td>\n",
-       "      <td>b</td>\n",
-       "      <td>b</td>\n",
-       "      <td>c</td>\n",
-       "      <td>d</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>143</th>\n",
-       "      <td>6.8</td>\n",
-       "      <td>3.2</td>\n",
-       "      <td>5.9</td>\n",
-       "      <td>2.3</td>\n",
-       "      <td>c</td>\n",
-       "      <td>c</td>\n",
-       "      <td>d</td>\n",
-       "      <td>d</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>144</th>\n",
-       "      <td>6.7</td>\n",
-       "      <td>3.3</td>\n",
-       "      <td>5.7</td>\n",
-       "      <td>2.5</td>\n",
-       "      <td>c</td>\n",
-       "      <td>c</td>\n",
-       "      <td>d</td>\n",
-       "      <td>d</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>145</th>\n",
-       "      <td>6.7</td>\n",
-       "      <td>3.0</td>\n",
-       "      <td>5.2</td>\n",
-       "      <td>2.3</td>\n",
-       "      <td>c</td>\n",
-       "      <td>b</td>\n",
-       "      <td>c</td>\n",
-       "      <td>d</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>146</th>\n",
-       "      <td>6.3</td>\n",
-       "      <td>2.5</td>\n",
-       "      <td>5.0</td>\n",
-       "      <td>1.9</td>\n",
-       "      <td>c</td>\n",
-       "      <td>a</td>\n",
-       "      <td>c</td>\n",
-       "      <td>d</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>147</th>\n",
-       "      <td>6.5</td>\n",
-       "      <td>3.0</td>\n",
-       "      <td>5.2</td>\n",
-       "      <td>2.0</td>\n",
-       "      <td>c</td>\n",
-       "      <td>b</td>\n",
-       "      <td>c</td>\n",
-       "      <td>d</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>148</th>\n",
-       "      <td>6.2</td>\n",
-       "      <td>3.4</td>\n",
-       "      <td>5.4</td>\n",
-       "      <td>2.3</td>\n",
-       "      <td>c</td>\n",
-       "      <td>c</td>\n",
-       "      <td>d</td>\n",
-       "      <td>d</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>149</th>\n",
-       "      <td>5.9</td>\n",
-       "      <td>3.0</td>\n",
-       "      <td>5.1</td>\n",
-       "      <td>1.8</td>\n",
-       "      <td>c</td>\n",
-       "      <td>b</td>\n",
-       "      <td>c</td>\n",
-       "      <td>c</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>\n",
-       "<p>150 rows × 8 columns</p>\n",
-       "</div>"
-      ],
-      "text/plain": [
-       "      sl   sw   pl   pw sl_labeled sw_labeled pl_labeled pw_labeled\n",
-       "0    5.1  3.5  1.4  0.2          b          c          a          a\n",
-       "1    4.9  3.0  1.4  0.2          a          b          a          a\n",
-       "2    4.7  3.2  1.3  0.2          a          c          a          a\n",
-       "3    4.6  3.1  1.5  0.2          a          c          a          a\n",
-       "4    5.0  3.6  1.4  0.2          a          c          a          a\n",
-       "5    5.4  3.9  1.7  0.4          b          d          a          a\n",
-       "6    4.6  3.4  1.4  0.3          a          c          a          a\n",
-       "7    5.0  3.4  1.5  0.2          a          c          a          a\n",
-       "8    4.4  2.9  1.4  0.2          a          b          a          a\n",
-       "9    4.9  3.1  1.5  0.1          a          c          a          a\n",
-       "10   5.4  3.7  1.5  0.2          b          c          a          a\n",
-       "11   4.8  3.4  1.6  0.2          a          c          a          a\n",
-       "12   4.8  3.0  1.4  0.1          a          b          a          a\n",
-       "13   4.3  3.0  1.1  0.1          a          b          a          a\n",
-       "14   5.8  4.0  1.2  0.2          b          d          a          a\n",
-       "15   5.7  4.4  1.5  0.4          b          d          a          a\n",
-       "16   5.4  3.9  1.3  0.4          b          d          a          a\n",
-       "17   5.1  3.5  1.4  0.3          b          c          a          a\n",
-       "18   5.7  3.8  1.7  0.3          b          d          a          a\n",
-       "19   5.1  3.8  1.5  0.3          b          d          a          a\n",
-       "20   5.4  3.4  1.7  0.2          b          c          a          a\n",
-       "21   5.1  3.7  1.5  0.4          b          c          a          a\n",
-       "22   4.6  3.6  1.0  0.2          a          c          a          a\n",
-       "23   5.1  3.3  1.7  0.5          b          c          a          a\n",
-       "24   4.8  3.4  1.9  0.2          a          c          a          a\n",
-       "25   5.0  3.0  1.6  0.2          a          b          a          a\n",
-       "26   5.0  3.4  1.6  0.4          a          c          a          a\n",
-       "27   5.2  3.5  1.5  0.2          b          c          a          a\n",
-       "28   5.2  3.4  1.4  0.2          b          c          a          a\n",
-       "29   4.7  3.2  1.6  0.2          a          c          a          a\n",
-       "..   ...  ...  ...  ...        ...        ...        ...        ...\n",
-       "120  6.9  3.2  5.7  2.3          d          c          d          d\n",
-       "121  5.6  2.8  4.9  2.0          b          b          c          d\n",
-       "122  7.7  2.8  6.7  2.0          d          b          d          d\n",
-       "123  6.3  2.7  4.9  1.8          c          b          c          c\n",
-       "124  6.7  3.3  5.7  2.1          c          c          d          d\n",
-       "125  7.2  3.2  6.0  1.8          d          c          d          c\n",
-       "126  6.2  2.8  4.8  1.8          c          b          c          c\n",
-       "127  6.1  3.0  4.9  1.8          c          b          c          c\n",
-       "128  6.4  2.8  5.6  2.1          c          b          d          d\n",
-       "129  7.2  3.0  5.8  1.6          d          b          d          c\n",
-       "130  7.4  2.8  6.1  1.9          d          b          d          d\n",
-       "131  7.9  3.8  6.4  2.0          d          d          d          d\n",
-       "132  6.4  2.8  5.6  2.2          c          b          d          d\n",
-       "133  6.3  2.8  5.1  1.5          c          b          c          c\n",
-       "134  6.1  2.6  5.6  1.4          c          b          d          c\n",
-       "135  7.7  3.0  6.1  2.3          d          b          d          d\n",
-       "136  6.3  3.4  5.6  2.4          c          c          d          d\n",
-       "137  6.4  3.1  5.5  1.8          c          c          d          c\n",
-       "138  6.0  3.0  4.8  1.8          c          b          c          c\n",
-       "139  6.9  3.1  5.4  2.1          d          c          d          d\n",
-       "140  6.7  3.1  5.6  2.4          c          c          d          d\n",
-       "141  6.9  3.1  5.1  2.3          d          c          c          d\n",
-       "142  5.8  2.7  5.1  1.9          b          b          c          d\n",
-       "143  6.8  3.2  5.9  2.3          c          c          d          d\n",
-       "144  6.7  3.3  5.7  2.5          c          c          d          d\n",
-       "145  6.7  3.0  5.2  2.3          c          b          c          d\n",
-       "146  6.3  2.5  5.0  1.9          c          a          c          d\n",
-       "147  6.5  3.0  5.2  2.0          c          b          c          d\n",
-       "148  6.2  3.4  5.4  2.3          c          c          d          d\n",
-       "149  5.9  3.0  5.1  1.8          c          b          c          c\n",
-       "\n",
-       "[150 rows x 8 columns]"
-      ]
-     },
-     "execution_count": 7,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "df['sl_labeled'] = toLabel(df, 'sl')\n",
-    "df['sw_labeled'] = toLabel(df, 'sw')\n",
-    "df['pl_labeled'] = toLabel(df, 'pl')\n",
-    "df['pw_labeled'] = toLabel(df, 'pw')\n",
-    "df"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "df.drop(['sl', 'sw', 'pl', 'pw'], axis = 1, inplace = True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'a', 'b', 'c', 'd'}"
-      ]
-     },
-     "execution_count": 9,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "set(df['sl_labeled'])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "df[\"output\"] = iris.target"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<div>\n",
-       "<table border=\"1\" class=\"dataframe\">\n",
-       "  <thead>\n",
-       "    <tr style=\"text-align: right;\">\n",
-       "      <th></th>\n",
-       "      <th>sl_labeled</th>\n",
-       "      <th>sw_labeled</th>\n",
-       "      <th>pl_labeled</th>\n",
-       "      <th>pw_labeled</th>\n",
-       "      <th>output</th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <th>0</th>\n",
-       "      <td>b</td>\n",
-       "      <td>c</td>\n",
-       "      <td>a</td>\n",
-       "      <td>a</td>\n",
-       "      <td>0</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>1</th>\n",
-       "      <td>a</td>\n",
-       "      <td>b</td>\n",
-       "      <td>a</td>\n",
-       "      <td>a</td>\n",
-       "      <td>0</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>2</th>\n",
-       "      <td>a</td>\n",
-       "      <td>c</td>\n",
-       "      <td>a</td>\n",
-       "      <td>a</td>\n",
-       "      <td>0</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>3</th>\n",
-       "      <td>a</td>\n",
-       "      <td>c</td>\n",
-       "      <td>a</td>\n",
-       "      <td>a</td>\n",
-       "      <td>0</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>4</th>\n",
-       "      <td>a</td>\n",
-       "      <td>c</td>\n",
-       "      <td>a</td>\n",
-       "      <td>a</td>\n",
-       "      <td>0</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>5</th>\n",
-       "      <td>b</td>\n",
-       "      <td>d</td>\n",
-       "      <td>a</td>\n",
-       "      <td>a</td>\n",
-       "      <td>0</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>6</th>\n",
-       "      <td>a</td>\n",
-       "      <td>c</td>\n",
-       "      <td>a</td>\n",
-       "      <td>a</td>\n",
-       "      <td>0</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>7</th>\n",
-       "      <td>a</td>\n",
-       "      <td>c</td>\n",
-       "      <td>a</td>\n",
-       "      <td>a</td>\n",
-       "      <td>0</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>8</th>\n",
-       "      <td>a</td>\n",
-       "      <td>b</td>\n",
-       "      <td>a</td>\n",
-       "      <td>a</td>\n",
-       "      <td>0</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>9</th>\n",
-       "      <td>a</td>\n",
-       "      <td>c</td>\n",
-       "      <td>a</td>\n",
-       "      <td>a</td>\n",
-       "      <td>0</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>10</th>\n",
-       "      <td>b</td>\n",
-       "      <td>c</td>\n",
-       "      <td>a</td>\n",
-       "      <td>a</td>\n",
-       "      <td>0</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>11</th>\n",
-       "      <td>a</td>\n",
-       "      <td>c</td>\n",
-       "      <td>a</td>\n",
-       "      <td>a</td>\n",
-       "      <td>0</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>12</th>\n",
-       "      <td>a</td>\n",
-       "      <td>b</td>\n",
-       "      <td>a</td>\n",
-       "      <td>a</td>\n",
-       "      <td>0</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>13</th>\n",
-       "      <td>a</td>\n",
-       "      <td>b</td>\n",
-       "      <td>a</td>\n",
-       "      <td>a</td>\n",
-       "      <td>0</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>14</th>\n",
-       "      <td>b</td>\n",
-       "      <td>d</td>\n",
-       "      <td>a</td>\n",
-       "      <td>a</td>\n",
-       "      <td>0</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>15</th>\n",
-       "      <td>b</td>\n",
-       "      <td>d</td>\n",
-       "      <td>a</td>\n",
-       "      <td>a</td>\n",
-       "      <td>0</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>16</th>\n",
-       "      <td>b</td>\n",
-       "      <td>d</td>\n",
-       "      <td>a</td>\n",
-       "      <td>a</td>\n",
-       "      <td>0</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>17</th>\n",
-       "      <td>b</td>\n",
-       "      <td>c</td>\n",
-       "      <td>a</td>\n",
-       "      <td>a</td>\n",
-       "      <td>0</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>18</th>\n",
-       "      <td>b</td>\n",
-       "      <td>d</td>\n",
-       "      <td>a</td>\n",
-       "      <td>a</td>\n",
-       "      <td>0</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>19</th>\n",
-       "      <td>b</td>\n",
-       "      <td>d</td>\n",
-       "      <td>a</td>\n",
-       "      <td>a</td>\n",
-       "      <td>0</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>20</th>\n",
-       "      <td>b</td>\n",
-       "      <td>c</td>\n",
-       "      <td>a</td>\n",
-       "      <td>a</td>\n",
-       "      <td>0</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>21</th>\n",
-       "      <td>b</td>\n",
-       "      <td>c</td>\n",
-       "      <td>a</td>\n",
-       "      <td>a</td>\n",
-       "      <td>0</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>22</th>\n",
-       "      <td>a</td>\n",
-       "      <td>c</td>\n",
-       "      <td>a</td>\n",
-       "      <td>a</td>\n",
-       "      <td>0</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>23</th>\n",
-       "      <td>b</td>\n",
-       "      <td>c</td>\n",
-       "      <td>a</td>\n",
-       "      <td>a</td>\n",
-       "      <td>0</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>24</th>\n",
-       "      <td>a</td>\n",
-       "      <td>c</td>\n",
-       "      <td>a</td>\n",
-       "      <td>a</td>\n",
-       "      <td>0</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>25</th>\n",
-       "      <td>a</td>\n",
-       "      <td>b</td>\n",
-       "      <td>a</td>\n",
-       "      <td>a</td>\n",
-       "      <td>0</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>26</th>\n",
-       "      <td>a</td>\n",
-       "      <td>c</td>\n",
-       "      <td>a</td>\n",
-       "      <td>a</td>\n",
-       "      <td>0</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>27</th>\n",
-       "      <td>b</td>\n",
-       "      <td>c</td>\n",
-       "      <td>a</td>\n",
-       "      <td>a</td>\n",
-       "      <td>0</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>28</th>\n",
-       "      <td>b</td>\n",
-       "      <td>c</td>\n",
-       "      <td>a</td>\n",
-       "      <td>a</td>\n",
-       "      <td>0</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>29</th>\n",
-       "      <td>a</td>\n",
-       "      <td>c</td>\n",
-       "      <td>a</td>\n",
-       "      <td>a</td>\n",
-       "      <td>0</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>...</th>\n",
-       "      <td>...</td>\n",
-       "      <td>...</td>\n",
-       "      <td>...</td>\n",
-       "      <td>...</td>\n",
-       "      <td>...</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>120</th>\n",
-       "      <td>d</td>\n",
-       "      <td>c</td>\n",
-       "      <td>d</td>\n",
-       "      <td>d</td>\n",
-       "      <td>2</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>121</th>\n",
-       "      <td>b</td>\n",
-       "      <td>b</td>\n",
-       "      <td>c</td>\n",
-       "      <td>d</td>\n",
-       "      <td>2</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>122</th>\n",
-       "      <td>d</td>\n",
-       "      <td>b</td>\n",
-       "      <td>d</td>\n",
-       "      <td>d</td>\n",
-       "      <td>2</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>123</th>\n",
-       "      <td>c</td>\n",
-       "      <td>b</td>\n",
-       "      <td>c</td>\n",
-       "      <td>c</td>\n",
-       "      <td>2</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>124</th>\n",
-       "      <td>c</td>\n",
-       "      <td>c</td>\n",
-       "      <td>d</td>\n",
-       "      <td>d</td>\n",
-       "      <td>2</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>125</th>\n",
-       "      <td>d</td>\n",
-       "      <td>c</td>\n",
-       "      <td>d</td>\n",
-       "      <td>c</td>\n",
-       "      <td>2</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>126</th>\n",
-       "      <td>c</td>\n",
-       "      <td>b</td>\n",
-       "      <td>c</td>\n",
-       "      <td>c</td>\n",
-       "      <td>2</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>127</th>\n",
-       "      <td>c</td>\n",
-       "      <td>b</td>\n",
-       "      <td>c</td>\n",
-       "      <td>c</td>\n",
-       "      <td>2</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>128</th>\n",
-       "      <td>c</td>\n",
-       "      <td>b</td>\n",
-       "      <td>d</td>\n",
-       "      <td>d</td>\n",
-       "      <td>2</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>129</th>\n",
-       "      <td>d</td>\n",
-       "      <td>b</td>\n",
-       "      <td>d</td>\n",
-       "      <td>c</td>\n",
-       "      <td>2</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>130</th>\n",
-       "      <td>d</td>\n",
-       "      <td>b</td>\n",
-       "      <td>d</td>\n",
-       "      <td>d</td>\n",
-       "      <td>2</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>131</th>\n",
-       "      <td>d</td>\n",
-       "      <td>d</td>\n",
-       "      <td>d</td>\n",
-       "      <td>d</td>\n",
-       "      <td>2</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>132</th>\n",
-       "      <td>c</td>\n",
-       "      <td>b</td>\n",
-       "      <td>d</td>\n",
-       "      <td>d</td>\n",
-       "      <td>2</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>133</th>\n",
-       "      <td>c</td>\n",
-       "      <td>b</td>\n",
-       "      <td>c</td>\n",
-       "      <td>c</td>\n",
-       "      <td>2</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>134</th>\n",
-       "      <td>c</td>\n",
-       "      <td>b</td>\n",
-       "      <td>d</td>\n",
-       "      <td>c</td>\n",
-       "      <td>2</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>135</th>\n",
-       "      <td>d</td>\n",
-       "      <td>b</td>\n",
-       "      <td>d</td>\n",
-       "      <td>d</td>\n",
-       "      <td>2</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>136</th>\n",
-       "      <td>c</td>\n",
-       "      <td>c</td>\n",
-       "      <td>d</td>\n",
-       "      <td>d</td>\n",
-       "      <td>2</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>137</th>\n",
-       "      <td>c</td>\n",
-       "      <td>c</td>\n",
-       "      <td>d</td>\n",
-       "      <td>c</td>\n",
-       "      <td>2</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>138</th>\n",
-       "      <td>c</td>\n",
-       "      <td>b</td>\n",
-       "      <td>c</td>\n",
-       "      <td>c</td>\n",
-       "      <td>2</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>139</th>\n",
-       "      <td>d</td>\n",
-       "      <td>c</td>\n",
-       "      <td>d</td>\n",
-       "      <td>d</td>\n",
-       "      <td>2</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>140</th>\n",
-       "      <td>c</td>\n",
-       "      <td>c</td>\n",
-       "      <td>d</td>\n",
-       "      <td>d</td>\n",
-       "      <td>2</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>141</th>\n",
-       "      <td>d</td>\n",
-       "      <td>c</td>\n",
-       "      <td>c</td>\n",
-       "      <td>d</td>\n",
-       "      <td>2</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>142</th>\n",
-       "      <td>b</td>\n",
-       "      <td>b</td>\n",
-       "      <td>c</td>\n",
-       "      <td>d</td>\n",
-       "      <td>2</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>143</th>\n",
-       "      <td>c</td>\n",
-       "      <td>c</td>\n",
-       "      <td>d</td>\n",
-       "      <td>d</td>\n",
-       "      <td>2</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>144</th>\n",
-       "      <td>c</td>\n",
-       "      <td>c</td>\n",
-       "      <td>d</td>\n",
-       "      <td>d</td>\n",
-       "      <td>2</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>145</th>\n",
-       "      <td>c</td>\n",
-       "      <td>b</td>\n",
-       "      <td>c</td>\n",
-       "      <td>d</td>\n",
-       "      <td>2</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>146</th>\n",
-       "      <td>c</td>\n",
-       "      <td>a</td>\n",
-       "      <td>c</td>\n",
-       "      <td>d</td>\n",
-       "      <td>2</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>147</th>\n",
-       "      <td>c</td>\n",
-       "      <td>b</td>\n",
-       "      <td>c</td>\n",
-       "      <td>d</td>\n",
-       "      <td>2</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>148</th>\n",
-       "      <td>c</td>\n",
-       "      <td>c</td>\n",
-       "      <td>d</td>\n",
-       "      <td>d</td>\n",
-       "      <td>2</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>149</th>\n",
-       "      <td>c</td>\n",
-       "      <td>b</td>\n",
-       "      <td>c</td>\n",
-       "      <td>c</td>\n",
-       "      <td>2</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>\n",
-       "<p>150 rows × 5 columns</p>\n",
-       "</div>"
-      ],
-      "text/plain": [
-       "    sl_labeled sw_labeled pl_labeled pw_labeled  output\n",
-       "0            b          c          a          a       0\n",
-       "1            a          b          a          a       0\n",
-       "2            a          c          a          a       0\n",
-       "3            a          c          a          a       0\n",
-       "4            a          c          a          a       0\n",
-       "5            b          d          a          a       0\n",
-       "6            a          c          a          a       0\n",
-       "7            a          c          a          a       0\n",
-       "8            a          b          a          a       0\n",
-       "9            a          c          a          a       0\n",
-       "10           b          c          a          a       0\n",
-       "11           a          c          a          a       0\n",
-       "12           a          b          a          a       0\n",
-       "13           a          b          a          a       0\n",
-       "14           b          d          a          a       0\n",
-       "15           b          d          a          a       0\n",
-       "16           b          d          a          a       0\n",
-       "17           b          c          a          a       0\n",
-       "18           b          d          a          a       0\n",
-       "19           b          d          a          a       0\n",
-       "20           b          c          a          a       0\n",
-       "21           b          c          a          a       0\n",
-       "22           a          c          a          a       0\n",
-       "23           b          c          a          a       0\n",
-       "24           a          c          a          a       0\n",
-       "25           a          b          a          a       0\n",
-       "26           a          c          a          a       0\n",
-       "27           b          c          a          a       0\n",
-       "28           b          c          a          a       0\n",
-       "29           a          c          a          a       0\n",
-       "..         ...        ...        ...        ...     ...\n",
-       "120          d          c          d          d       2\n",
-       "121          b          b          c          d       2\n",
-       "122          d          b          d          d       2\n",
-       "123          c          b          c          c       2\n",
-       "124          c          c          d          d       2\n",
-       "125          d          c          d          c       2\n",
-       "126          c          b          c          c       2\n",
-       "127          c          b          c          c       2\n",
-       "128          c          b          d          d       2\n",
-       "129          d          b          d          c       2\n",
-       "130          d          b          d          d       2\n",
-       "131          d          d          d          d       2\n",
-       "132          c          b          d          d       2\n",
-       "133          c          b          c          c       2\n",
-       "134          c          b          d          c       2\n",
-       "135          d          b          d          d       2\n",
-       "136          c          c          d          d       2\n",
-       "137          c          c          d          c       2\n",
-       "138          c          b          c          c       2\n",
-       "139          d          c          d          d       2\n",
-       "140          c          c          d          d       2\n",
-       "141          d          c          c          d       2\n",
-       "142          b          b          c          d       2\n",
-       "143          c          c          d          d       2\n",
-       "144          c          c          d          d       2\n",
-       "145          c          b          c          d       2\n",
-       "146          c          a          c          d       2\n",
-       "147          c          b          c          d       2\n",
-       "148          c          c          d          d       2\n",
-       "149          c          b          c          c       2\n",
-       "\n",
-       "[150 rows x 5 columns]"
-      ]
-     },
-     "execution_count": 13,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "df"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [],
-   "source": [
-    "def fit(data):\n",
-    "    output_name = data.columns[-1]\n",
-    "    features = data.columns[0:-1]\n",
-    "    counts = {}\n",
-    "    possible_outputs = set(data[output_name])\n",
-    "    for output in possible_outputs:\n",
-    "        counts[output] = {}\n",
-    "        smallData = data[data[output_name] == output]\n",
-    "        counts[output][\"total_count\"] = len(smallData)\n",
-    "        for f in features:\n",
-    "            counts[output][f] = {}\n",
-    "            possible_values = set(smallData[f])\n",
-    "            for value in possible_values:\n",
-    "                val_count = len(smallData[smallData[f] == value])\n",
-    "                counts[output][f][value] = val_count\n",
-    "    return counts"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{0: {'pl_labeled': {'a': 50},\n",
-       "  'pw_labeled': {'a': 50},\n",
-       "  'sl_labeled': {'a': 28, 'b': 22},\n",
-       "  'sw_labeled': {'a': 1, 'b': 7, 'c': 32, 'd': 10},\n",
-       "  'total_count': 50},\n",
-       " 1: {'pl_labeled': {'b': 7, 'c': 43},\n",
-       "  'pw_labeled': {'b': 10, 'c': 40},\n",
-       "  'sl_labeled': {'a': 3, 'b': 21, 'c': 24, 'd': 2},\n",
-       "  'sw_labeled': {'a': 13, 'b': 29, 'c': 8},\n",
-       "  'total_count': 50},\n",
-       " 2: {'pl_labeled': {'c': 20, 'd': 30},\n",
-       "  'pw_labeled': {'c': 16, 'd': 34},\n",
-       "  'sl_labeled': {'a': 1, 'b': 5, 'c': 29, 'd': 15},\n",
-       "  'sw_labeled': {'a': 5, 'b': 28, 'c': 15, 'd': 2},\n",
-       "  'total_count': 50}}"
-      ]
-     },
-     "execution_count": 15,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "fit(df)"
-   ]
-  }
- ],
- "metadata": {
-  "anaconda-cloud": {},
-  "kernelspec": {
-   "display_name": "Python [default]",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.6.5"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 1
-}
diff --git a/machine_learning/random_forest_classification/Social_Network_Ads.csv b/machine_learning/random_forest_classification/Social_Network_Ads.csv
deleted file mode 100644
index 4a53849c2baf..000000000000
--- a/machine_learning/random_forest_classification/Social_Network_Ads.csv
+++ /dev/null
@@ -1,401 +0,0 @@
-User ID,Gender,Age,EstimatedSalary,Purchased
-15624510,Male,19,19000,0
-15810944,Male,35,20000,0
-15668575,Female,26,43000,0
-15603246,Female,27,57000,0
-15804002,Male,19,76000,0
-15728773,Male,27,58000,0
-15598044,Female,27,84000,0
-15694829,Female,32,150000,1
-15600575,Male,25,33000,0
-15727311,Female,35,65000,0
-15570769,Female,26,80000,0
-15606274,Female,26,52000,0
-15746139,Male,20,86000,0
-15704987,Male,32,18000,0
-15628972,Male,18,82000,0
-15697686,Male,29,80000,0
-15733883,Male,47,25000,1
-15617482,Male,45,26000,1
-15704583,Male,46,28000,1
-15621083,Female,48,29000,1
-15649487,Male,45,22000,1
-15736760,Female,47,49000,1
-15714658,Male,48,41000,1
-15599081,Female,45,22000,1
-15705113,Male,46,23000,1
-15631159,Male,47,20000,1
-15792818,Male,49,28000,1
-15633531,Female,47,30000,1
-15744529,Male,29,43000,0
-15669656,Male,31,18000,0
-15581198,Male,31,74000,0
-15729054,Female,27,137000,1
-15573452,Female,21,16000,0
-15776733,Female,28,44000,0
-15724858,Male,27,90000,0
-15713144,Male,35,27000,0
-15690188,Female,33,28000,0
-15689425,Male,30,49000,0
-15671766,Female,26,72000,0
-15782806,Female,27,31000,0
-15764419,Female,27,17000,0
-15591915,Female,33,51000,0
-15772798,Male,35,108000,0
-15792008,Male,30,15000,0
-15715541,Female,28,84000,0
-15639277,Male,23,20000,0
-15798850,Male,25,79000,0
-15776348,Female,27,54000,0
-15727696,Male,30,135000,1
-15793813,Female,31,89000,0
-15694395,Female,24,32000,0
-15764195,Female,18,44000,0
-15744919,Female,29,83000,0
-15671655,Female,35,23000,0
-15654901,Female,27,58000,0
-15649136,Female,24,55000,0
-15775562,Female,23,48000,0
-15807481,Male,28,79000,0
-15642885,Male,22,18000,0
-15789109,Female,32,117000,0
-15814004,Male,27,20000,0
-15673619,Male,25,87000,0
-15595135,Female,23,66000,0
-15583681,Male,32,120000,1
-15605000,Female,59,83000,0
-15718071,Male,24,58000,0
-15679760,Male,24,19000,0
-15654574,Female,23,82000,0
-15577178,Female,22,63000,0
-15595324,Female,31,68000,0
-15756932,Male,25,80000,0
-15726358,Female,24,27000,0
-15595228,Female,20,23000,0
-15782530,Female,33,113000,0
-15592877,Male,32,18000,0
-15651983,Male,34,112000,1
-15746737,Male,18,52000,0
-15774179,Female,22,27000,0
-15667265,Female,28,87000,0
-15655123,Female,26,17000,0
-15595917,Male,30,80000,0
-15668385,Male,39,42000,0
-15709476,Male,20,49000,0
-15711218,Male,35,88000,0
-15798659,Female,30,62000,0
-15663939,Female,31,118000,1
-15694946,Male,24,55000,0
-15631912,Female,28,85000,0
-15768816,Male,26,81000,0
-15682268,Male,35,50000,0
-15684801,Male,22,81000,0
-15636428,Female,30,116000,0
-15809823,Male,26,15000,0
-15699284,Female,29,28000,0
-15786993,Female,29,83000,0
-15709441,Female,35,44000,0
-15710257,Female,35,25000,0
-15582492,Male,28,123000,1
-15575694,Male,35,73000,0
-15756820,Female,28,37000,0
-15766289,Male,27,88000,0
-15593014,Male,28,59000,0
-15584545,Female,32,86000,0
-15675949,Female,33,149000,1
-15672091,Female,19,21000,0
-15801658,Male,21,72000,0
-15706185,Female,26,35000,0
-15789863,Male,27,89000,0
-15720943,Male,26,86000,0
-15697997,Female,38,80000,0
-15665416,Female,39,71000,0
-15660200,Female,37,71000,0
-15619653,Male,38,61000,0
-15773447,Male,37,55000,0
-15739160,Male,42,80000,0
-15689237,Male,40,57000,0
-15679297,Male,35,75000,0
-15591433,Male,36,52000,0
-15642725,Male,40,59000,0
-15701962,Male,41,59000,0
-15811613,Female,36,75000,0
-15741049,Male,37,72000,0
-15724423,Female,40,75000,0
-15574305,Male,35,53000,0
-15678168,Female,41,51000,0
-15697020,Female,39,61000,0
-15610801,Male,42,65000,0
-15745232,Male,26,32000,0
-15722758,Male,30,17000,0
-15792102,Female,26,84000,0
-15675185,Male,31,58000,0
-15801247,Male,33,31000,0
-15725660,Male,30,87000,0
-15638963,Female,21,68000,0
-15800061,Female,28,55000,0
-15578006,Male,23,63000,0
-15668504,Female,20,82000,0
-15687491,Male,30,107000,1
-15610403,Female,28,59000,0
-15741094,Male,19,25000,0
-15807909,Male,19,85000,0
-15666141,Female,18,68000,0
-15617134,Male,35,59000,0
-15783029,Male,30,89000,0
-15622833,Female,34,25000,0
-15746422,Female,24,89000,0
-15750839,Female,27,96000,1
-15749130,Female,41,30000,0
-15779862,Male,29,61000,0
-15767871,Male,20,74000,0
-15679651,Female,26,15000,0
-15576219,Male,41,45000,0
-15699247,Male,31,76000,0
-15619087,Female,36,50000,0
-15605327,Male,40,47000,0
-15610140,Female,31,15000,0
-15791174,Male,46,59000,0
-15602373,Male,29,75000,0
-15762605,Male,26,30000,0
-15598840,Female,32,135000,1
-15744279,Male,32,100000,1
-15670619,Male,25,90000,0
-15599533,Female,37,33000,0
-15757837,Male,35,38000,0
-15697574,Female,33,69000,0
-15578738,Female,18,86000,0
-15762228,Female,22,55000,0
-15614827,Female,35,71000,0
-15789815,Male,29,148000,1
-15579781,Female,29,47000,0
-15587013,Male,21,88000,0
-15570932,Male,34,115000,0
-15794661,Female,26,118000,0
-15581654,Female,34,43000,0
-15644296,Female,34,72000,0
-15614420,Female,23,28000,0
-15609653,Female,35,47000,0
-15594577,Male,25,22000,0
-15584114,Male,24,23000,0
-15673367,Female,31,34000,0
-15685576,Male,26,16000,0
-15774727,Female,31,71000,0
-15694288,Female,32,117000,1
-15603319,Male,33,43000,0
-15759066,Female,33,60000,0
-15814816,Male,31,66000,0
-15724402,Female,20,82000,0
-15571059,Female,33,41000,0
-15674206,Male,35,72000,0
-15715160,Male,28,32000,0
-15730448,Male,24,84000,0
-15662067,Female,19,26000,0
-15779581,Male,29,43000,0
-15662901,Male,19,70000,0
-15689751,Male,28,89000,0
-15667742,Male,34,43000,0
-15738448,Female,30,79000,0
-15680243,Female,20,36000,0
-15745083,Male,26,80000,0
-15708228,Male,35,22000,0
-15628523,Male,35,39000,0
-15708196,Male,49,74000,0
-15735549,Female,39,134000,1
-15809347,Female,41,71000,0
-15660866,Female,58,101000,1
-15766609,Female,47,47000,0
-15654230,Female,55,130000,1
-15794566,Female,52,114000,0
-15800890,Female,40,142000,1
-15697424,Female,46,22000,0
-15724536,Female,48,96000,1
-15735878,Male,52,150000,1
-15707596,Female,59,42000,0
-15657163,Male,35,58000,0
-15622478,Male,47,43000,0
-15779529,Female,60,108000,1
-15636023,Male,49,65000,0
-15582066,Male,40,78000,0
-15666675,Female,46,96000,0
-15732987,Male,59,143000,1
-15789432,Female,41,80000,0
-15663161,Male,35,91000,1
-15694879,Male,37,144000,1
-15593715,Male,60,102000,1
-15575002,Female,35,60000,0
-15622171,Male,37,53000,0
-15795224,Female,36,126000,1
-15685346,Male,56,133000,1
-15691808,Female,40,72000,0
-15721007,Female,42,80000,1
-15794253,Female,35,147000,1
-15694453,Male,39,42000,0
-15813113,Male,40,107000,1
-15614187,Male,49,86000,1
-15619407,Female,38,112000,0
-15646227,Male,46,79000,1
-15660541,Male,40,57000,0
-15753874,Female,37,80000,0
-15617877,Female,46,82000,0
-15772073,Female,53,143000,1
-15701537,Male,42,149000,1
-15736228,Male,38,59000,0
-15780572,Female,50,88000,1
-15769596,Female,56,104000,1
-15586996,Female,41,72000,0
-15722061,Female,51,146000,1
-15638003,Female,35,50000,0
-15775590,Female,57,122000,1
-15730688,Male,41,52000,0
-15753102,Female,35,97000,1
-15810075,Female,44,39000,0
-15723373,Male,37,52000,0
-15795298,Female,48,134000,1
-15584320,Female,37,146000,1
-15724161,Female,50,44000,0
-15750056,Female,52,90000,1
-15609637,Female,41,72000,0
-15794493,Male,40,57000,0
-15569641,Female,58,95000,1
-15815236,Female,45,131000,1
-15811177,Female,35,77000,0
-15680587,Male,36,144000,1
-15672821,Female,55,125000,1
-15767681,Female,35,72000,0
-15600379,Male,48,90000,1
-15801336,Female,42,108000,1
-15721592,Male,40,75000,0
-15581282,Male,37,74000,0
-15746203,Female,47,144000,1
-15583137,Male,40,61000,0
-15680752,Female,43,133000,0
-15688172,Female,59,76000,1
-15791373,Male,60,42000,1
-15589449,Male,39,106000,1
-15692819,Female,57,26000,1
-15727467,Male,57,74000,1
-15734312,Male,38,71000,0
-15764604,Male,49,88000,1
-15613014,Female,52,38000,1
-15759684,Female,50,36000,1
-15609669,Female,59,88000,1
-15685536,Male,35,61000,0
-15750447,Male,37,70000,1
-15663249,Female,52,21000,1
-15638646,Male,48,141000,0
-15734161,Female,37,93000,1
-15631070,Female,37,62000,0
-15761950,Female,48,138000,1
-15649668,Male,41,79000,0
-15713912,Female,37,78000,1
-15586757,Male,39,134000,1
-15596522,Male,49,89000,1
-15625395,Male,55,39000,1
-15760570,Male,37,77000,0
-15566689,Female,35,57000,0
-15725794,Female,36,63000,0
-15673539,Male,42,73000,1
-15705298,Female,43,112000,1
-15675791,Male,45,79000,0
-15747043,Male,46,117000,1
-15736397,Female,58,38000,1
-15678201,Male,48,74000,1
-15720745,Female,37,137000,1
-15637593,Male,37,79000,1
-15598070,Female,40,60000,0
-15787550,Male,42,54000,0
-15603942,Female,51,134000,0
-15733973,Female,47,113000,1
-15596761,Male,36,125000,1
-15652400,Female,38,50000,0
-15717893,Female,42,70000,0
-15622585,Male,39,96000,1
-15733964,Female,38,50000,0
-15753861,Female,49,141000,1
-15747097,Female,39,79000,0
-15594762,Female,39,75000,1
-15667417,Female,54,104000,1
-15684861,Male,35,55000,0
-15742204,Male,45,32000,1
-15623502,Male,36,60000,0
-15774872,Female,52,138000,1
-15611191,Female,53,82000,1
-15674331,Male,41,52000,0
-15619465,Female,48,30000,1
-15575247,Female,48,131000,1
-15695679,Female,41,60000,0
-15713463,Male,41,72000,0
-15785170,Female,42,75000,0
-15796351,Male,36,118000,1
-15639576,Female,47,107000,1
-15693264,Male,38,51000,0
-15589715,Female,48,119000,1
-15769902,Male,42,65000,0
-15587177,Male,40,65000,0
-15814553,Male,57,60000,1
-15601550,Female,36,54000,0
-15664907,Male,58,144000,1
-15612465,Male,35,79000,0
-15810800,Female,38,55000,0
-15665760,Male,39,122000,1
-15588080,Female,53,104000,1
-15776844,Male,35,75000,0
-15717560,Female,38,65000,0
-15629739,Female,47,51000,1
-15729908,Male,47,105000,1
-15716781,Female,41,63000,0
-15646936,Male,53,72000,1
-15768151,Female,54,108000,1
-15579212,Male,39,77000,0
-15721835,Male,38,61000,0
-15800515,Female,38,113000,1
-15591279,Male,37,75000,0
-15587419,Female,42,90000,1
-15750335,Female,37,57000,0
-15699619,Male,36,99000,1
-15606472,Male,60,34000,1
-15778368,Male,54,70000,1
-15671387,Female,41,72000,0
-15573926,Male,40,71000,1
-15709183,Male,42,54000,0
-15577514,Male,43,129000,1
-15778830,Female,53,34000,1
-15768072,Female,47,50000,1
-15768293,Female,42,79000,0
-15654456,Male,42,104000,1
-15807525,Female,59,29000,1
-15574372,Female,58,47000,1
-15671249,Male,46,88000,1
-15779744,Male,38,71000,0
-15624755,Female,54,26000,1
-15611430,Female,60,46000,1
-15774744,Male,60,83000,1
-15629885,Female,39,73000,0
-15708791,Male,59,130000,1
-15793890,Female,37,80000,0
-15646091,Female,46,32000,1
-15596984,Female,46,74000,0
-15800215,Female,42,53000,0
-15577806,Male,41,87000,1
-15749381,Female,58,23000,1
-15683758,Male,42,64000,0
-15670615,Male,48,33000,1
-15715622,Female,44,139000,1
-15707634,Male,49,28000,1
-15806901,Female,57,33000,1
-15775335,Male,56,60000,1
-15724150,Female,49,39000,1
-15627220,Male,39,71000,0
-15672330,Male,47,34000,1
-15668521,Female,48,35000,1
-15807837,Male,48,33000,1
-15592570,Male,47,23000,1
-15748589,Female,45,45000,1
-15635893,Male,60,42000,1
-15757632,Female,39,59000,0
-15691863,Female,46,41000,1
-15706071,Male,51,23000,1
-15654296,Female,50,20000,1
-15755018,Male,36,33000,0
-15594041,Female,49,36000,1
\ No newline at end of file
diff --git a/machine_learning/random_forest_classification/random_forest_classification.py b/machine_learning/random_forest_classification/random_forest_classification.py
deleted file mode 100644
index 6aed4e6e66de..000000000000
--- a/machine_learning/random_forest_classification/random_forest_classification.py
+++ /dev/null
@@ -1,103 +0,0 @@
-# Random Forest Classification
-
-# Importing the libraries
-import os
-import numpy as np
-import matplotlib.pyplot as plt
-import pandas as pd
-
-# Importing the dataset
-script_dir = os.path.dirname(os.path.realpath(__file__))
-dataset = pd.read_csv(os.path.join(script_dir, "Social_Network_Ads.csv"))
-X = dataset.iloc[:, [2, 3]].values
-y = dataset.iloc[:, 4].values
-
-# Splitting the dataset into the Training set and Test set
-from sklearn.model_selection import train_test_split
-
-X_train, X_test, y_train, y_test = train_test_split(
-    X, y, test_size=0.25, random_state=0
-)
-
-# Feature Scaling
-from sklearn.preprocessing import StandardScaler
-
-sc = StandardScaler()
-X_train = sc.fit_transform(X_train)
-X_test = sc.transform(X_test)
-
-# Fitting Random Forest Classification to the Training set
-from sklearn.ensemble import RandomForestClassifier
-
-classifier = RandomForestClassifier(
-    n_estimators=10, criterion="entropy", random_state=0
-)
-classifier.fit(X_train, y_train)
-
-# Predicting the Test set results
-y_pred = classifier.predict(X_test)
-
-# Making the Confusion Matrix
-from sklearn.metrics import confusion_matrix
-
-cm = confusion_matrix(y_test, y_pred)
-
-# Visualising the Training set results
-from matplotlib.colors import ListedColormap
-
-X_set, y_set = X_train, y_train
-X1, X2 = np.meshgrid(
-    np.arange(start=X_set[:, 0].min() - 1, stop=X_set[:, 0].max() + 1, step=0.01),
-    np.arange(start=X_set[:, 1].min() - 1, stop=X_set[:, 1].max() + 1, step=0.01),
-)
-plt.contourf(
-    X1,
-    X2,
-    classifier.predict(np.array([X1.ravel(), X2.ravel()]).T).reshape(X1.shape),
-    alpha=0.75,
-    cmap=ListedColormap(("red", "green")),
-)
-plt.xlim(X1.min(), X1.max())
-plt.ylim(X2.min(), X2.max())
-for i, j in enumerate(np.unique(y_set)):
-    plt.scatter(
-        X_set[y_set == j, 0],
-        X_set[y_set == j, 1],
-        c=ListedColormap(("red", "green"))(i),
-        label=j,
-    )
-plt.title("Random Forest Classification (Training set)")
-plt.xlabel("Age")
-plt.ylabel("Estimated Salary")
-plt.legend()
-plt.show()
-
-# Visualising the Test set results
-from matplotlib.colors import ListedColormap
-
-X_set, y_set = X_test, y_test
-X1, X2 = np.meshgrid(
-    np.arange(start=X_set[:, 0].min() - 1, stop=X_set[:, 0].max() + 1, step=0.01),
-    np.arange(start=X_set[:, 1].min() - 1, stop=X_set[:, 1].max() + 1, step=0.01),
-)
-plt.contourf(
-    X1,
-    X2,
-    classifier.predict(np.array([X1.ravel(), X2.ravel()]).T).reshape(X1.shape),
-    alpha=0.75,
-    cmap=ListedColormap(("red", "green")),
-)
-plt.xlim(X1.min(), X1.max())
-plt.ylim(X2.min(), X2.max())
-for i, j in enumerate(np.unique(y_set)):
-    plt.scatter(
-        X_set[y_set == j, 0],
-        X_set[y_set == j, 1],
-        c=ListedColormap(("red", "green"))(i),
-        label=j,
-    )
-plt.title("Random Forest Classification (Test set)")
-plt.xlabel("Age")
-plt.ylabel("Estimated Salary")
-plt.legend()
-plt.show()
diff --git a/machine_learning/random_forest_classification/random_forest_classifier.ipynb b/machine_learning/random_forest_classification/random_forest_classifier.ipynb
deleted file mode 100644
index 7ee66124c371..000000000000
--- a/machine_learning/random_forest_classification/random_forest_classifier.ipynb
+++ /dev/null
@@ -1,196 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "C:\\Users\\Satyam\\AppData\\Roaming\\Python\\Python35\\site-packages\\sklearn\\ensemble\\weight_boosting.py:29: DeprecationWarning: numpy.core.umath_tests is an internal NumPy module and should not be imported. It will be removed in a future NumPy release.\n",
-      "  from numpy.core.umath_tests import inner1d\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Importing the libraries\n",
-    "import numpy as np\n",
-    "import matplotlib.pyplot as plt\n",
-    "import pandas as pd\n",
-    "from sklearn.model_selection import train_test_split\n",
-    "from sklearn.preprocessing import StandardScaler\n",
-    "from sklearn.metrics import confusion_matrix\n",
-    "from matplotlib.colors import ListedColormap\n",
-    "from sklearn.ensemble import RandomForestClassifier"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [],
-   "source": [
-    "# Importing the dataset\n",
-    "dataset = pd.read_csv('Social_Network_Ads.csv')\n",
-    "X = dataset.iloc[:, [2, 3]].values\n",
-    "y = dataset.iloc[:, 4].values"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [],
-   "source": [
-    "# Splitting the dataset into the Training set and Test set\n",
-    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25, random_state = 0)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "C:\\Users\\Satyam\\AppData\\Roaming\\Python\\Python35\\site-packages\\sklearn\\utils\\validation.py:475: DataConversionWarning: Data with input dtype int64 was converted to float64 by StandardScaler.\n",
-      "  warnings.warn(msg, DataConversionWarning)\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Feature Scaling\n",
-    "sc = StandardScaler()\n",
-    "X_train = sc.fit_transform(X_train)\n",
-    "X_test = sc.transform(X_test)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[[63  5]\n",
-      " [ 3 29]]\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Fitting classifier to the Training set\n",
-    "# Create your classifier here\n",
-    "classifier = RandomForestClassifier(n_estimators=10,criterion='entropy',random_state=0)\n",
-    "classifier.fit(X_train,y_train)\n",
-    "# Predicting the Test set results\n",
-    "y_pred = classifier.predict(X_test)\n",
-    "\n",
-    "# Making the Confusion Matrix\n",
-    "cm = confusion_matrix(y_test, y_pred)\n",
-    "print(cm)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYQAAAEWCAYAAABmE+CbAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAfyzKuSV3NT5AAAAAElFTkSuQmCC\n",
-      "text/plain": [
-       "<matplotlib.figure.Figure at 0x14150b50>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYQAAAEWCAYAAABmE+CbAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAABJRU5ErkJggg==\n",
-      "text/plain": [
-       "<matplotlib.figure.Figure at 0x14717ff0>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# Visualising the Training set results\n",
-    "X_set, y_set = X_train, y_train\n",
-    "X1, X2 = np.meshgrid(np.arange(start = X_set[:, 0].min() - 1, stop = X_set[:, 0].max() + 1, step = 0.01),\n",
-    "                     np.arange(start = X_set[:, 1].min() - 1, stop = X_set[:, 1].max() + 1, step = 0.01))\n",
-    "plt.contourf(X1, X2, classifier.predict(np.array([X1.ravel(), X2.ravel()]).T).reshape(X1.shape),\n",
-    "             alpha = 0.75, cmap = ListedColormap(('red', 'green')))\n",
-    "plt.xlim(X1.min(), X1.max())\n",
-    "plt.ylim(X2.min(), X2.max())\n",
-    "for i, j in enumerate(np.unique(y_set)):\n",
-    "    plt.scatter(X_set[y_set == j, 0], X_set[y_set == j, 1],\n",
-    "                c = ListedColormap(('red', 'green'))(i), label = j)\n",
-    "plt.title('Random Forest Classifier (Training set)')\n",
-    "plt.xlabel('Age')\n",
-    "plt.ylabel('Estimated Salary')\n",
-    "plt.legend()\n",
-    "plt.show()\n",
-    "\n",
-    "# Visualising the Test set results\n",
-    "X_set, y_set = X_test, y_test\n",
-    "X1, X2 = np.meshgrid(np.arange(start = X_set[:, 0].min() - 1, stop = X_set[:, 0].max() + 1, step = 0.01),\n",
-    "                     np.arange(start = X_set[:, 1].min() - 1, stop = X_set[:, 1].max() + 1, step = 0.01))\n",
-    "plt.contourf(X1, X2, classifier.predict(np.array([X1.ravel(), X2.ravel()]).T).reshape(X1.shape),\n",
-    "             alpha = 0.75, cmap = ListedColormap(('red', 'green')))\n",
-    "plt.xlim(X1.min(), X1.max())\n",
-    "plt.ylim(X2.min(), X2.max())\n",
-    "for i, j in enumerate(np.unique(y_set)):\n",
-    "    plt.scatter(X_set[y_set == j, 0], X_set[y_set == j, 1],\n",
-    "                c = ListedColormap(('red', 'green'))(i), label = j)\n",
-    "plt.title('Random Forest Classifier (Test set)')\n",
-    "plt.xlabel('Age')\n",
-    "plt.ylabel('Estimated Salary')\n",
-    "plt.legend()\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.5.1"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/machine_learning/random_forest_regression/Position_Salaries.csv b/machine_learning/random_forest_regression/Position_Salaries.csv
deleted file mode 100644
index 0c752c72a1d1..000000000000
--- a/machine_learning/random_forest_regression/Position_Salaries.csv
+++ /dev/null
@@ -1,11 +0,0 @@
-Position,Level,Salary
-Business Analyst,1,45000
-Junior Consultant,2,50000
-Senior Consultant,3,60000
-Manager,4,80000
-Country Manager,5,110000
-Region Manager,6,150000
-Partner,7,200000
-Senior Partner,8,300000
-C-level,9,500000
-CEO,10,1000000
\ No newline at end of file
diff --git a/machine_learning/random_forest_regression/random_forest_regression.ipynb b/machine_learning/random_forest_regression/random_forest_regression.ipynb
deleted file mode 100644
index 17f4d42bfb0d..000000000000
--- a/machine_learning/random_forest_regression/random_forest_regression.ipynb
+++ /dev/null
@@ -1,147 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [],
-   "source": [
-    "# Importing the libraries\n",
-    "import numpy as np\n",
-    "import matplotlib.pyplot as plt\n",
-    "import pandas as pd\n",
-    "from sklearn.ensemble import RandomForestRegressor"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [],
-   "source": [
-    "# Importing the dataset\n",
-    "dataset = pd.read_csv('Position_Salaries.csv')\n",
-    "X = dataset.iloc[:, 1:2].values\n",
-    "y = dataset.iloc[:, 2].values"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "RandomForestRegressor(bootstrap=True, criterion='mse', max_depth=None,\n",
-       "           max_features='auto', max_leaf_nodes=None,\n",
-       "           min_impurity_split=1e-07, min_samples_leaf=1,\n",
-       "           min_samples_split=2, min_weight_fraction_leaf=0.0,\n",
-       "           n_estimators=300, n_jobs=1, oob_score=False, random_state=0,\n",
-       "           verbose=0, warm_start=False)"
-      ]
-     },
-     "execution_count": 3,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# Fitting Random Forest Regression to the dataset\n",
-    "regressor = RandomForestRegressor(n_estimators = 300, random_state = 0)\n",
-    "regressor.fit(X, y)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [],
-   "source": [
-    "# Predicting a new result\n",
-    "y_pred = regressor.predict(6.5)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[ 160333.33333333]\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(y_pred)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaEAAAEWCAYAAADPZygPAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAIABJREFUeJzt3XmcXFWd9/HPNx1ICAgJkGHJziSKcUGgBwPMuABCADE4\nIuBEySCYUWEE0UeB+MgaxEEFHBl4MgGBsU1YlYisg7KNsiSIQECGGMiCBALZIB2SdOf3/HFPm0pT\nvVSlum5X6vt+vepVt85dzu/e6q5fnXtPnauIwMzMLA998g7AzMzql5OQmZnlxknIzMxy4yRkZma5\ncRIyM7PcOAmZmVlunISsS5JGS+o1ffklHSLppRKWP1XSa5LekrSDpH+QNC+9/mQH61wi6dSKBV0C\nST+TdG4edVvlSZou6ewKbOfTkpoqEVNv4iRU49IHadtjg6Q1Ba8nlrnNxZI+VuFQS6n/QknrC/bj\nWUlHl7mt/sAPgI9HxHYRsRK4ELg0vb69yDq7Ap8DpqfXh6Rj+5akNyX9SdIJ5e9h7yDpZEmt7f6G\nLqtyDJ0mXEl9JYWk1Sm+xekLQs18dkXEyRFxUQU29UtgH0nvq8C2eo2aeSOtuPRBul1EbAcsBI4q\nKHvHtyZJfasfZcc6iaepYL++CcyQtHMZVewK9IuIuQVlI4C5HSwPcCLwq4h4u6BsYYple+D/ANdI\nGl1GPL3NQ4V/QxFxeqkbqNLf1PvS8T8I+AIwqdIVSOrTm5NbZCMLzAS+lHcsldRrD7hVRmpV3CBp\nhqQ3gc+3//ZZeHpL0gxgd+DO9M3zjILlTkjfRJdKOrOTOgemOpZKeknSWZKU5p0s6UFJP5a0DPhO\nV/sQEXcAa4A9itTV9k15ZEHZzySdK+m9pGST9uWetJ/DC/avoUiVhwMPdBBLRMSvgFXABwrq/Ek6\nNqskPS7pgIJ5F6bj/7PUknpG0j4F8/eV9GSaNwPo124fv5xOH74h6ZeSdmu371+R9Oe0/jmSxkh6\nJMUyQ9JWXRzidyjnPUzlf5K0XNKdkoal8j5p2dckrZT0lKSxkr4KHAecnd6LX3QVV0T8L/A74EPt\nYv2ppFfSe3B+WzKR1CDpsnTs5kv6VxWcWpb0sKQLJP0eWA0M72J77077vlLS65J+3tk+pnnt/9+6\nej//Jc1fLunH7Q7B/cCRJbyVvZ6TUH34NPBzYAfghs4WjIjPAX8BDk/fjH9UMPsAYDRwGHCepDEd\nbOY/gAFkSeMg4CSg8PTVAcBzwGDg+53Fo8ynAAF/6mzZIvvyHLBXmt4uIg6NiJHt9q+1yKofAJ7v\nIJ4+kj4NDALmFcx6FPggsCNwM3CTpMJkcjTwX8BA4E7gx2l7/YDbgGvSurelZdvqOxQ4HzgGGJJi\nb9/C/QTZh/KBwBSy4388WYtvb+DYogeocyW9h5I+Q9ZCnJDKHiX7m4MsqY8DxpAdt+OBZRHxH2R/\njxel9+LTXQWVvlgcyKbH/r/IvqT8LbAv2Yf0iWneV4BDyN6bRuAfi2z2C8AXyVq5i7vY3lTg12k/\nhgJXdLaPReLvzvt5RKp3b7IvjYcUzHsOGC1pQJH9qE0R4ccW8gBeAg5pV3Yh8Jt2ZT8Dzi14fQjw\nUsHrxcDHCl6PBgLYtaDsCeCYIjFsBbQA7y4oOwX47zR9MjC/i/24EFgHrACagVbgG8XiBfqm2EYW\n27+22Nttf5P9K1L/BmB0u/o2pHjWpnhO7WR9AW+SnUJq25+7CuZ/EHgrTR8ELAJUMP+xgvivI/uQ\nbpu3fap/aMG+f7hg/h/bHavLgR90EOfJ6b1aUfBoLOc9BO4FJhW87puO1RDgULIvEB8G+nT2t1gk\nxrZ9XEXWUom0ztZp/hCyhNGvYJ0vAPem6QeBkwrmjS/8ewAeBr5b8Lqr7f0cuBIY0i7Obu1jN9/P\ncQXzbwW+WfB6m7TM7uV8RvTGh1tC9WFRJTYSEUsKXjYD2xVZ7G+ABmBBQdkCsn/uUuL5eUQMjIgB\nZN8uT5Z0Uokhl2sF8K52ZQsjYiDZh8YVwMGFMyV9K52KWgksB7YFCq9htT9226bp3YHFkT5hksJj\nt3vh64hYlbZfeDxfLZheU+R1sfepzcPpOLc9ZlPeezgCuELSCkkrgNfJEvfQiLgHuIrsw/tVSVdJ\nan98u/JBsvfkn4D92Xj8RpCdvny1oO4rgF3S/N3bxVrsb6+wrKvtfYMsSc+W9LSkSQAl7GN33s/O\n/s/atrmiyLZrkpNQfWjfvXo12amWNrt2sXwpXiP7ZjeioGw48HK524+I+cBdwFFF5rWQfePubH9K\n9RTw7g5iWUt22mkfpe7dkj4OnAF8hux02yDgLbIWUVdeIfsWXGh4wfRfKDiW6YNtEJsez0or5z1c\nRNbiKExo20TEowARcVlE7AO8HxhLdryKbadDEbEhImYAs8lOO7bV2wzsWFDv9hHxwTS//fEdVmzT\n7fajw+1FxCuR9Xbbjax1OE3SqC72sdDmvp/vBeZFRHM3l+/1nITq05PAkZIGpYuiX2s3/1WKdALo\njohYT3ZN5CJJ26V/0K+TnZIoS7rAfRgd92j7IzAxXYQ+Evj7cutK7gA+2tHMlIguBb6bit5Fdvrq\ndbJvyeey8Zt6Vx4G+ij7LVNfSccC+xTMnwGcJOmD6frR98h6tC0uYX9KUuZ7eBUwJV2zaesscEya\n3i89+pJ9AVpH1kqC8v7WLga+LGlwRCwi60TyA0nbp2t2oyV9JC17I3C6pN0lDSL7AtHZvne6PUnH\nSmprtawgS2CtXexjoc19Pz9Kdk1xi+EkVJ+uJbvAuYCshTGz3fyLyDoerJBUcpdd4Ktk/4Qvkf1D\nXwdcX+I2JqYeU2+RXeS+n+zaSjFfI+t8sQL4LDCr9JA3cR1wVLuOBe1NJ7tAfDhZ0vpv4AWyfV5F\n9g28SymhfZqs2+3yNP3Lgvl3kV3I/kXa5nCgrN9/laik9zAibgJ+RNYhYxVZa/KwNHsgcDXZ+/MS\n2X60dXiZDuyVeoLd3J3AIuIPwO/Juu4DfJ4s6T9LdgxvYmNr+Eqyv52ngTlknQrWdVFFZ9v7MPC4\npNVk12tOiYiFXexjYexlv5+SRNbhYVp3lq8V2vRUtJkBSPo3sutAP8k7FqscSUcBl0XE3+YdS6lS\nr8zPRsQ/5R1LJTkJmdkWS9K2wD+QtVR3JWuBPBAR3+x0RasaJyEz22JJ2o7sdOJ7yK7V3A6cHhFv\n5hqY/ZWTkJmZ5cYdE8zMLDe9ajDL3mjnnXeOkSNH5h2GmVlNmTNnzusRMbir5ZyEujBy5Ehmz56d\ndxhmZjVF0oKul/LpODMzy5GTkJmZ5cZJyMzMcuMkZGZmuXESMjOz3PRYEpJ0TbrV7TMFZTtKulfS\nC+l5UCpXujXuvHRb3MJbH09Ky7/Qdu+OVL5vup/HvLSuyq3DzMySpiYYORL69Mmem9rf+LWyerIl\ndC3ZXQwLnQncFxFjgPvSa8hujTsmPSaTjXyLpB2Bc8hGrt0POKctqaRlvlSw3vhy6jAzs6SpCSZP\nhgULICJ7njy5RxNRjyWhiHiQd95jfQLZkPCk56MLyq+PzCPAwHSfm8PIbqu7LCKWk91CeHyat31E\nPJLuSHl9u22VUoeZmQFMmQLN7e6X19yclfeQal8T2iUi2u6zsoSNt8wdwqa32F2cyjorX1ykvJw6\n3kHSZEmzJc1eunRpN3fNzKzGLVxYWnkF5NYxIbVgenT01HLriIhpEdEYEY2DB3c56oSZ2ZZh+PDS\nyiug2kno1bZTYOn5tVT+Mpve+31oKuusfGiR8nLqMDMzgKlTYcCATcsGDMjKe0i1k9AsoK2H2yTg\ntoLyE1IPtnHAynRK7W7gUEmDUoeEQ4G707xVksalXnEntNtWKXWYmRnAxIkwbRqMGAFS9jxtWlbe\nQ3psAFNJM4CPATtLWkzWy+1i4EZJJwELgGPT4ncARwDzgGbgRICIWCbpAuDxtNz5EdHW2eGrZD3w\ntgHuTA9KrcPMzApMnNijSac939SuC42NjeFRtM3MSiNpTkQ0drWcR0wwM7PcOAmZmVlunITMzCw3\nTkJmZpYbJyEzM8uNk5CZmeXGScjMzHLjJGRmZrlxEjIzs9w4CZmZWW6chMzMLDdOQmZmlhsnITMz\ny42TkJmZ5cZJyMzMcuMkZGZmuXESMjOz3DgJmZlZbpyEzMwsN05CZmaWGychMzPLjZOQmZnlxknI\nzMxy4yRkZma5cRIyM7PcOAmZmVlunITMzCw3TkJmZpYbJyEzM8uNk5CZmeXGScjMzHLjJGRmZrnJ\nJQlJ+rqkuZKekTRDUn9JoyQ9KmmepBskbZ2W7Zdez0vzRxZs56xU/rykwwrKx6eyeZLOLCgvWoeZ\nmeWjb7UrlDQE+BowNiLWSLoROB44Arg0ImZKugo4CbgyPS+PiNGSjge+DxwnaWxa733A7sB/S3p3\nquYK4BPAYuBxSbMi4tm0brE6zMy2GLfdBk89tXnbGDYM/vmfKxJOp6qehArq3UbSemAA8ApwEPBP\naf51wLlkCWJCmga4GfiJJKXymRGxFnhR0jxgv7TcvIiYDyBpJjBB0nOd1GFmtsX44hdh2bLN28aB\nB1YnCVX9dFxEvAz8AFhIlnxWAnOAFRHRkhZbDAxJ00OARWndlrT8ToXl7dbpqHynTuowM9tirF8P\np58OLS3lPx54oDqx5nE6bhBZK2YUsAK4CRhf7Tg6I2kyMBlg+PDhOUdjZlaaDRugb19oaMg7kq7l\n0THhEODFiFgaEeuBW4EDgYGS2pLiUODlNP0yMAwgzd8BeKOwvN06HZW/0Ukdm4iIaRHRGBGNgwcP\n3px9NTOrutZW6FMjfZ/zCHMhME7SgHRt52DgWeC3wDFpmUnAbWl6VnpNmv+biIhUfnzqPTcKGAM8\nBjwOjEk94bYm67wwK63TUR1mZluMDRuchDoUEY+SdTB4Ang6xTAN+DZwRupgsBNwdVrlamCnVH4G\ncGbazlzgRrIEdhdwSkS0pms+pwJ3A88BN6Zl6aQOM7MtRi0lIWUNBOtIY2NjzJ49O+8wzMy6raEB\nzj4bLrggvxgkzYmIxq6Wq5FcaWZm3VVLLaEaCdPMzLqj7eSWk5CZmVVda2v2XAvds8FJyMxsi7Jh\nQ/bslpCZmVWdk5CZmeXGScjMzHLjJGRmZrlxEjIzs9y09Y5zEjIzs6prawm5i7aZmVWdT8eZmVlu\nnITMzCw3TkJmZpYbJyEzM8uNe8eZmVlu3BIyM7PcuIu2mZnlxi0hMzPLjZOQmZnlxknIzMxy495x\nZmaWG7eEzMwsN05CZmaWG3fRNjOz3LglZGZmuXESMjOz3Lh3nJmZ5cYtITMzy42TkJmZ5cZJyMzM\ncuMkZGZmuam13wn1zTsAMzPb6OGH4aGHyl9/3rzsuVZaQrkkIUkDgenA+4EAvgg8D9wAjAReAo6N\niOWSBFwOHAE0A/8cEU+k7UwCvpM2e2FEXJfK9wWuBbYB7gBOi4iQtGOxOnp2b83Muu+00+CJJzZv\nG9tsA0OGVCaenpZXrrwcuCsi9gT2Ap4DzgTui4gxwH3pNcDhwJj0mAxcCZASyjnAh4H9gHMkDUrr\nXAl8qWC98am8ozrMzHqFtWthwgR4++3yH6tWwahRee9J91Q9CUnaAfgIcDVARKyLiBXABOC6tNh1\nwNFpegJwfWQeAQZK2g04DLg3Ipal1sy9wPg0b/uIeCQiAri+3baK1WFm1iu0tsLWW0O/fuU/+tbQ\nhZY8WkKjgKXATyX9QdJ0SdsCu0TEK2mZJcAuaXoIsKhg/cWprLPyxUXK6aSOTUiaLGm2pNlLly4t\nZx/NzMrS2lo7nQoqIY8k1BfYB7gyIvYGVtPutFhqwURPBtFZHRExLSIaI6Jx8ODBPRmGmdkmnIR6\n3mJgcUQ8ml7fTJaUXk2n0kjPr6X5LwPDCtYfmso6Kx9apJxO6jAz6xWchIqQVLFDEhFLgEWS3pOK\nDgaeBWYBk1LZJOC2ND0LOEGZccDKdErtbuBQSYNSh4RDgbvTvFWSxqWedSe021axOszMeoV6S0Ld\nvXz1gqRbgJ9GxLMVqPdfgSZJWwPzgRPJEuKNkk4CFgDHpmXvIOuePY+si/aJABGxTNIFwONpufMj\nYlma/iobu2jfmR4AF3dQh5lZr9DSUlsdCzZXd3d1L+B4YLqkPsA1wMyIWFVOpRHxJNBYZNbBRZYN\n4JQOtnNNiqV9+Wyy3yC1L3+jWB1mZr1FvbWEunU6LiLejIj/jIgDgG+T/T7nFUnXSRrdoxGamdUR\nJ6EiJDVI+pSkXwCXAT8E9gB+RXa6zMzMKqDeklC3rwkBvwUuiYjfFZTfLOkjlQ/LzKw+OQm1k3rG\nXRsR5xebHxFfq3hUZmZ1qt6SUJen4yKiFfh4FWIxM6t7ra3uHVfM7yT9hGwE6tVthW2jWZuZWWW0\ntNRXS6i7SeiA9Fx4Si6AgyobjplZ/YrIbkrnJNRORPh0nJlZD6u1u6JWQrfPPEo6Engf0L+trKPO\nCmZmVrrW1uy5npJQd38ndBVwHNlwOwI+C4zowbjMzOpOWxKqp44J3R1F+4CIOAFYHhHnAfuz6QjW\nZma2mdwS6tia9NwsaXdgPdnN6czMrEKchDp2u6SBwCXAE8BLwMyeCsrMrB61zLgJgIYzToORI6Gp\nKd+AqqC7veMuSJO3SLod6B8RK3suLDOzOtPUROsZU4DP0kALLFgAkydn8yZOzDW0ntRpEpL0j53M\nIyJurXxIZmZ1aMoUWtesBaCBdF6uuRmmTKnfJAQc1cm8AJyEzMwqYeFCWtkdgL60bFK+Jes0CUXE\nidUKxMysrg0fTuuCAApaQql8S+Yfq5qZ9QZTp9J68kXwdkESGjAApk7NN64e1q0klH6sOoBsNO3p\nwDHAYz0Yl5lZzbnwQrjkknLXnkhrHAvAVrTAiBFZAtqCrwdBCQOYRsQHJT0VEedJ+iG+HmRmtonH\nHoN+/TYnb2xF//5w6Dd/DjtVMrLeq7tJqP2PVZfhH6uamW2ipSX7ec+ll+YdSe3obhJq+7HqvwFz\nUtn0ngnJzKw21dtdUSuhq98J/R2wqO3HqpK2A54G/gQ415uZFWhpqa/BRyuhq2F7/h+wDkDSR4CL\nU9lKYFrPhmZmVlvq7a6oldBVzm6IiGVp+jhgWkTcQjZ8z5M9G5qZWW1pbYX+/btezjbqqiXUIKkt\nUR0M/KZgnhudZmYFfDqudF0drhnAA5JeJ+sh9xCApNFkp+TMzCxxx4TSdTVsz1RJ9wG7AfdERKRZ\nfcjusmpmZolbQqXr8nBFxCNFyv63Z8IxM6td7phQuu7e1M7MzLrQ2uqWUKmchMzMKsSn40rnJGRm\nViHumFC63JKQpAZJf0i3C0fSKEmPSpon6QZJW6fyfun1vDR/ZME2zkrlz0s6rKB8fCqbJ+nMgvKi\ndZiZVYJbQqXLsyV0GvBcwevvA5dGxGhgOXBSKj8JWJ7KL03LIWkscDzZPY7GA/+RElsDcAVwODAW\n+FxatrM6zMw2m1tCpcslCUkaChxJGgRVkoCDgJvTItcBR6fpCek1af7BafkJwMyIWBsRLwLzgP3S\nY15EzI+IdcBMYEIXdZiZbTa3hEqXV0voMuBbwIb0eidgRUS03Vh9MTAkTQ8BFgGk+SvT8n8tb7dO\nR+Wd1bEJSZMlzZY0e+nSpeXuo5nVGXfRLl3Vk5CkTwKvRcScLhfOSURMi4jGiGgcPHhw3uGYWY1w\nF+3S5XG4DgQ+JekIoD+wPXA5MFBS39RSGQq8nJZ/GRgGLE7j2O0AvFFQ3qZwnWLlb3RSh5nZZvPp\nuNJVvSUUEWdFxNCIGEnWseA3ETER+C1wTFpsEnBbmp6VXpPm/yYNHzQLOD71nhsFjAEeAx4HxqSe\ncFunOmaldTqqw8xss7ljQul60++Evg2cIWke2fWbq1P51cBOqfwM4EyAiJgL3Ag8C9wFnBIRramV\ncypwN1nvuxvTsp3VYWa22dwSKl2uhysi7gfuT9PzyXq2tV/mbeCzHaw/FZhapPwO4I4i5UXrMDOr\nBHdMKF1vagmZmdWsDRsgwi2hUvlwmZkBv/41nHdelkjK0baeW0KlcRIyMwPuuguefBI+8Ynyt3HU\nUXDkkZWLqR44CZmZAevWwU47ZS0iqx5fEzIzI0tCW3tI46pzEjIzA9avdxLKg5OQmRluCeXFScjM\nDCehvDgJmZmRJaGttso7ivrjJGRmhltCeXESMjPDSSgvTkJmZjgJ5cVJyMysqYn1f3iare+eBSNH\nQlNT3hHVDSchM6tvTU0weXLWEmIdLFgAkyc7EVWJk5CZ1bcpU6C5mXVsnSUhgObmrNx6nMeOM7Mt\nwptvZnc2LdmClcAOvE1/tmL9xvKFCysVmnXCScjMat4tt8Axx5S79vK/Tg2geWPx8OGbFZN1j5OQ\nmdW8P/85e/7+98vo4TZnNtxwI1q/lgnclpUNGABT33HTZusBTkJmVvPWpUs5Z5xRzp1NG2H889k1\noIULYfiILAFNnFjpMK0IJyEzq3lr10KfPptxa+2JE510cuLecWZW89auhX798o7CyuEkZGY1z0mo\ndjkJmVnNW7vWQ+7UKichM6t5bgnVLichM6t5TkK1y0nIzGreunVOQrXKScjMap6vCdUuJyEzq3k+\nHVe7/GNVM8vV+vXwq1/BmjXlb2PRIthll8rFZNXjJGRmubr3XvjMZzZ/Ox/60OZvw6rPScjMcrU8\nDWJ9zz3ZTU3LNWJERcKxKnMSMrNcrV6dPY8dC0OG5BuLVZ87JphZrprTLXy23TbfOCwfVU9CkoZJ\n+q2kZyXNlXRaKt9R0r2SXkjPg1K5JP1Y0jxJT0nap2Bbk9LyL0iaVFC+r6Sn0zo/lqTO6jCznDQ1\n0XzevwEwYK8x0NSUc0BWbXm0hFqAb0TEWGAccIqkscCZwH0RMQa4L70GOBwYkx6TgSshSyjAOcCH\ngf2AcwqSypXAlwrWG5/KO6rDzKqtqQkmT2b1ivU00MJWC+fB5MlORHWm6kkoIl6JiCfS9JvAc8AQ\nYAJwXVrsOuDoND0BuD4yjwADJe0GHAbcGxHLImI5cC8wPs3bPiIeiYgArm+3rWJ1mFm1TZkCzc00\nM4BtWY0gOzc3ZUrekVkV5XpNSNJIYG/gUWCXiHglzVoCtPX6HwIsKlhtcSrrrHxxkXI6qaN9XJMl\nzZY0e+nSpaXvmJl1beFCAJoZwACa31Fu9SG33nGStgNuAU6PiFXpsg0AERGSoifr76yOiJgGTANo\nbGzs0TjMatmSJVmvthUrylg5WrIn+jCaFzaWDx9emeCsJuSShCRtRZaAmiLi1lT8qqTdIuKVdErt\ntVT+MjCsYPWhqexl4GPtyu9P5UOLLN9ZHWZWhvnzs9/5fP7zMGpUiSs/PRduvx1a1rM/v8/KBgyA\nqVMrHqf1XlVPQqmn2tXAcxHxo4JZs4BJwMXp+baC8lMlzSTrhLAyJZG7gYsKOiMcCpwVEcskrZI0\njuw03wnAv3dRh5mVYdWq7PmUU2DcuFLX/gA0PZVdA1q4EIaPyBLQxImVDtN6sTxaQgcCXwCelvRk\nKjubLDHcKOkkYAFwbJp3B3AEMA9oBk4ESMnmAuDxtNz5EbEsTX8VuBbYBrgzPeikDjMrQ1sSete7\nytzAxIlOOnWu6kkoIh4G1MHsg4ssH8ApHWzrGuCaIuWzgfcXKX+jWB1mVp62JLT99vnGYbXLIyaY\nWdmchGxzeew4s3rU1MSGs7/DKQu/zcJt3g3vfk9ZA7fNm5c9b7ddheOzuuEkZFZv0kgFf2kexFV8\nmZFrXmTnp5fAqv6w004lbWr77eHEE6GhoYditS2ek5BZvUkjFbzKngBcytc5esNtsGEEPP5SvrFZ\n3fE1IbN6k0YkeI2/AWAXXt2k3Kya3BIyq1ETJsCjj5axol6FaOVt+gMFScgjFVgOnITMatCGDdlg\nA3vvDY2NJa78wgp48AFoaWE3XmEUL3qkAsuNk5BZDVq5MktEEyfC179e6tpjoOkxj1RgvYKTkFkN\nev317HnnncvcgEcqsF7CScis2pqaeOKbP+exJcNhxx2zizv77VfSJhYsyJ5L7FFt1us4CZlVU/qN\nzgnNjzKX98My4KfpUaKGBhg9utIBmlWXk5BZNU2ZQjQ3M589+DJXcg7nZeVDh8Hjj3e+bjvbbAM7\n7NADMZpVkZOQWYluvz1r0JRlwfdooS9rGMBYnmXXtu7RL78Gu1YsRLOa4SRkVqLLL4f/+R8YNqzr\nZd+h737Q0sIHeIqPcf/Gcv9Gx+qUk5BZiV59FQ49FH75yzJWbnoEJk+G5uaNZf6NjtUxD9tjVqIl\nS2CXXcpceeJEmDYNRowAKXueNs3dpa1uuSVk9aOpif/82tN8Y9nZhPpAv37Qd6uSN/PWW7Dr5ly/\n8W90zP7KScjqQ+oafU/ztfRjLSfE9dCyFXz8E/De95a0qYaG7PYFZrb5nISsZixbBjNnQktLGSuf\n+wI0n8RsGmlkNj/km9ACPDsC7nipwpGaWXc5CVnNmDYNzjqr3LXP/evUCVy/sdi3LzDLlZOQ9bym\nJpgyhdULXmf9sD3gO9+BY48teTNz52bXYubOLSOGvfaCxYsQwUBWbCx312izXDkJWc9K12Lub/47\nDmI+sagP/AvZowwf/Wg23FrJLv6Wu0ab9UJOQluy1ALJhusfXvZw/UuXwic/md0+oGR/Hgctc3iD\nnejP20xlCiJg0I7w3e+WvLmDDy4jBti43xU4HmZWOYqIvGPo1RobG2P27Nmlr1ihBNDSAqtXl149\nN94Ip53GhjVvM52TWczQrDvyQQfBnnuWtKn587Ohaj71qWy8spLcMPOvkx/lAb7CVdkLKbshjplt\nkSTNiYgub7noJNSFspJQUxN/Ofm7nPV2wTf9hr6w//6wxx7d3syGDXDnnfDGG6VVX0xf1rMdb0Gf\nPrB96aNejh0LDz2UrV6SkSM33neg0IgR8NJLJcdhZrWhu0nIp+N6wpQprHm7gQf5yMayVuD3fWFx\naZsaOhROOQUGDiwxhjPOALIvGMNYxGe4BQGEYHkVWyBTp/pajJl1yEmoJyxcyN8SvEi7Vs8GwYtV\nSgCX31rGX8C+AAAGXUlEQVS8BVLt3mC+FmNmnfDYcT2how/6aiaAqVOzFkehvFogEydmp942bMie\nnYDMLHES6gm9IQF4oEwzqwE+HdcTesspKA+UaWa9nJNQT3ECMDPrkk/HmZlZbuouCUkaL+l5SfMk\nnZl3PGZm9ayukpCkBuAK4HBgLPA5SWPzjcrMrH7VVRIC9gPmRcT8iFgHzAQm5ByTmVndqrckNARY\nVPB6cSrbhKTJkmZLmr106dKqBWdmVm/cO66IiJgGTAOQtFRSkaEHasrOwOt5B9GL+Hhs5GOxKR+P\njTb3WIzozkL1loReBoYVvB6ayjoUEYN7NKIqkDS7OwMJ1gsfj418LDbl47FRtY5FvZ2OexwYI2mU\npK2B44FZOcdkZla36qolFBEtkk4F7gYagGsiopybRZuZWQXUVRICiIg7gDvyjqPKpuUdQC/j47GR\nj8WmfDw2qsqx8E3tzMwsN/V2TcjMzHoRJyEzM8uNk9AWTNIwSb+V9KykuZJOyzumvElqkPQHSbfn\nHUveJA2UdLOkP0l6TtL+eceUF0lfT/8jz0iaIal/3jFVk6RrJL0m6ZmCsh0l3SvphfQ8qCfqdhLa\nsrUA34iIscA44BSPlcdpwHN5B9FLXA7cFRF7AntRp8dF0hDga0BjRLyfrOfs8flGVXXXAuPblZ0J\n3BcRY4D70uuKcxLagkXEKxHxRJp+k+xD5h3DFNULSUOBI4HpeceSN0k7AB8BrgaIiHURsSLfqHLV\nF9hGUl9gAPCXnOOpqoh4EFjWrngCcF2avg44uifqdhKqE5JGAnsDj+YbSa4uA74FbMg7kF5gFLAU\n+Gk6PTld0rZ5B5WHiHgZ+AGwEHgFWBkR9+QbVa+wS0S8kqaXALv0RCVOQnVA0nbALcDpEbEq73jy\nIOmTwGsRMSfvWHqJvsA+wJURsTewmh463dLbpWsdE8gS8+7AtpI+n29UvUtkv+Xpkd/zOAlt4SRt\nRZaAmiLi1rzjydGBwKckvUR2C4+DJP0s35BytRhYHBFtLeObyZJSPToEeDEilkbEeuBW4ICcY+oN\nXpW0G0B6fq0nKnES2oJJEtk5/+ci4kd5x5OniDgrIoZGxEiyi86/iYi6/bYbEUuARZLek4oOBp7N\nMaQ8LQTGSRqQ/mcOpk47abQzC5iUpicBt/VEJU5CW7YDgS+Qfet/Mj2OyDso6zX+FWiS9BTwIeCi\nnOPJRWoN3gw8ATxN9rlYV8P3SJoB/B54j6TFkk4CLgY+IekFstbixT1St4ftMTOzvLglZGZmuXES\nMjOz3DgJmZlZbpyEzMwsN05CZmaWGychszJJak3d3p+RdJOkAWVsY3rboLKSzm4373cVivNaScdU\nYls9uU2rT05CZuVbExEfSiMvrwO+XOoGIuLkiGj7kejZ7eb5V/u2xXMSMquMh4DRAJLOSK2jZySd\nnsq2lfRrSX9M5cel8vslNUq6mGwU5yclNaV5b6VnSbokrfd0wbofS+u33ROoKf3iv0OS9pX0gKQ5\nku6WtJukPSU9VrDMSElPd7R85Q+d1bO+eQdgVuvS8P+HA3dJ2hc4EfgwIOBRSQ8AewB/iYgj0zo7\nFG4jIs6UdGpEfKhIFf9INqLBXsDOwOOSHkzz9gbeR3brgf8hGyXj4Q7i3Ar4d2BCRCxNyWxqRHxR\n0taSRkXEi8BxwA0dLQ98sZzjZFaMk5BZ+baR9GSafohsnL6vAL+IiNUAkm4F/gG4C/ihpO8Dt0fE\nQyXU8/fAjIhoJRtU8gHg74BVwGMRsTjV9SQwkg6SEPAe4P3AvanB1EB26wKAG8mSz8Xp+bguljer\nCCchs/Ktad9y6ehsWET8r6R9gCOA70m6JyLOr0AMawumW+n8f1rA3IgodhvvG4CbUtKMiHhB0gc6\nWd6sInxNyKyyHgKOTiMybwt8GnhI0u5Ac0T8jOwGasVum7A+nQIrts3jJDVIGkx2R9THiizXleeB\nwZL2h+z0nKT3AUTEn8mS2P8lS0idLm9WKW4JmVVQRDwh6Vo2JonpEfEHSYcBl0jaAKwnO23X3jTg\nKUlPRMTEgvJfAPsDfyS7sdi3ImKJpD1LjG1d6lb943RNqi/Z3WbnpkVuAC4hu7lbd5Y322weRdvM\nzHLj03FmZpYbJyEzM8uNk5CZmeXGScjMzHLjJGRmZrlxEjIzs9w4CZmZWW7+P0PNi1lCP0XzAAAA\nAElFTkSuQmCC\n",
-      "text/plain": [
-       "<matplotlib.figure.Figure at 0xa760ed0>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# Visualising the Random Forest Regression results (higher resolution)\n",
-    "X_grid = np.arange(min(X), max(X), 0.01)\n",
-    "X_grid = X_grid.reshape((len(X_grid), 1))\n",
-    "plt.scatter(X, y, color = 'red')\n",
-    "plt.plot(X_grid, regressor.predict(X_grid), color = 'blue')\n",
-    "plt.title('Truth or Bluff (Random Forest Regression)')\n",
-    "plt.xlabel('Position level')\n",
-    "plt.ylabel('Salary')\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.5.1"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/machine_learning/random_forest_regression/random_forest_regression.py b/machine_learning/random_forest_regression/random_forest_regression.py
deleted file mode 100644
index 2599e97e957e..000000000000
--- a/machine_learning/random_forest_regression/random_forest_regression.py
+++ /dev/null
@@ -1,44 +0,0 @@
-# Random Forest Regression
-
-# Importing the libraries
-import os
-import numpy as np
-import matplotlib.pyplot as plt
-import pandas as pd
-
-# Importing the dataset
-script_dir = os.path.dirname(os.path.realpath(__file__))
-dataset = pd.read_csv(os.path.join(script_dir, "Position_Salaries.csv"))
-X = dataset.iloc[:, 1:2].values
-y = dataset.iloc[:, 2].values
-
-# Splitting the dataset into the Training set and Test set
-"""from sklearn.cross_validation import train_test_split
-X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 0)"""
-
-# Feature Scaling
-"""from sklearn.preprocessing import StandardScaler
-sc_X = StandardScaler()
-X_train = sc_X.fit_transform(X_train)
-X_test = sc_X.transform(X_test)
-sc_y = StandardScaler()
-y_train = sc_y.fit_transform(y_train)"""
-
-# Fitting Random Forest Regression to the dataset
-from sklearn.ensemble import RandomForestRegressor
-
-regressor = RandomForestRegressor(n_estimators=10, random_state=0)
-regressor.fit(X, y)
-
-# Predicting a new result
-y_pred = regressor.predict([[6.5]])
-
-# Visualising the Random Forest Regression results (higher resolution)
-X_grid = np.arange(min(X), max(X), 0.01)
-X_grid = X_grid.reshape((len(X_grid), 1))
-plt.scatter(X, y, color="red")
-plt.plot(X_grid, regressor.predict(X_grid), color="blue")
-plt.title("Truth or Bluff (Random Forest Regression)")
-plt.xlabel("Position level")
-plt.ylabel("Salary")
-plt.show()
diff --git a/machine_learning/reuters_one_vs_rest_classifier.ipynb b/machine_learning/reuters_one_vs_rest_classifier.ipynb
deleted file mode 100644
index 968130a6053a..000000000000
--- a/machine_learning/reuters_one_vs_rest_classifier.ipynb
+++ /dev/null
@@ -1,405 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "try:\n",
-    "    import nltk\n",
-    "except ModuleNotFoundError:\n",
-    "    !pip install nltk"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "## This code downloads the required packages.\n",
-    "## You can run `nltk.download('all')` to download everything.\n",
-    "\n",
-    "nltk_packages = [\n",
-    "    (\"reuters\", \"corpora/reuters.zip\")\n",
-    "]\n",
-    "\n",
-    "for pid, fid in nltk_packages:\n",
-    "    try:\n",
-    "        nltk.data.find(fid)\n",
-    "    except LookupError:\n",
-    "        nltk.download(pid)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Setting up corpus"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from nltk.corpus import reuters"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Setting up train/test data"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "train_documents, train_categories = zip(*[(reuters.raw(i), reuters.categories(i)) for i in reuters.fileids() if i.startswith('training/')])\n",
-    "test_documents, test_categories = zip(*[(reuters.raw(i), reuters.categories(i)) for i in reuters.fileids() if i.startswith('test/')])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "all_categories = sorted(list(set(reuters.categories())))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "The following cell defines a function **tokenize** that performs following actions:\n",
-    "- Receive a document as an argument to the function\n",
-    "- Tokenize the document using `nltk.word_tokenize()`\n",
-    "- Use `PorterStemmer` provided by the `nltk` to remove morphological affixes from each token\n",
-    "- Append stemmed token to an already defined list `stems`\n",
-    "- Return the list `stems`"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from nltk.stem.porter import PorterStemmer\n",
-    "def tokenize(text):\n",
-    "    tokens = nltk.word_tokenize(text)\n",
-    "    stems = []\n",
-    "    for item in tokens:\n",
-    "        stems.append(PorterStemmer().stem(item))\n",
-    "    return stems"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "To begin, I first used TF-IDF for feature selection on both train as well as test data using `TfidfVectorizer`.\n",
-    "\n",
-    "But first, What `TfidfVectorizer` actually does?\n",
-    "- `TfidfVectorizer` converts a collection of raw documents to a matrix of **TF-IDF** features.\n",
-    "\n",
-    "**TF-IDF**?\n",
-    "- TFIDF (abbreviation of the term *frequency–inverse document frequency*) is a numerical statistic that is intended to reflect how important a word is to a document in a collection or corpus. [tf–idf](https://en.wikipedia.org/wiki/Tf%E2%80%93idf)\n",
-    "\n",
-    "**Why `TfidfVectorizer`**?\n",
-    "- `TfidfVectorizer` scale down the impact of tokens that occur very frequently (e.g., “a”, “the”, and “of”) in a given corpus. [Feature Extraction and Transformation](https://spark.apache.org/docs/latest/mllib-feature-extraction.html#tf-idf)\n",
-    "\n",
-    "I gave following two arguments to `TfidfVectorizer`:\n",
-    "- tokenizer: `tokenize` function\n",
-    "- stop_words\n",
-    "\n",
-    "Then I used `fit_transform` and `transform` on the train and test documents repectively.\n",
-    "\n",
-    "**Why `fit_transform` for training data while `transform` for test data**?\n",
-    "\n",
-    "To avoid data leakage during cross-validation, imputer computes the statistic on the train data during the `fit`, **stores it** and uses the same on the test data, during the `transform`. This also prevents the test data from appearing in `fit` operation."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
-    "\n",
-    "vectorizer = TfidfVectorizer(tokenizer = tokenize, stop_words = 'english')\n",
-    "\n",
-    "vectorised_train_documents = vectorizer.fit_transform(train_documents)\n",
-    "vectorised_test_documents = vectorizer.transform(test_documents)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "For the **efficient implementation** of machine learning algorithms, many machine learning algorithms **requires all input variables and output variables to be numeric**. This means that categorical data must be converted to a numerical form.\n",
-    "\n",
-    "For this purpose, I used `MultiLabelBinarizer` from `sklearn.preprocessing`."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from sklearn.preprocessing import MultiLabelBinarizer\n",
-    "\n",
-    "mlb = MultiLabelBinarizer()\n",
-    "train_labels = mlb.fit_transform(train_categories)\n",
-    "test_labels = mlb.transform(test_categories)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Now, To **train** the classifier, I used `LinearSVC` in combination with the `OneVsRestClassifier` function in the scikit-learn package.\n",
-    "\n",
-    "The strategy of `OneVsRestClassifier` is of **fitting one classifier per label** and the `OneVsRestClassifier` can efficiently do this task and also outputs are easy to interpret. Since each label is represented by **one and only one classifier**, it is possible to gain knowledge about the label by inspecting its corresponding classifier. [OneVsRestClassifier](http://scikit-learn.org/stable/modules/multiclass.html#one-vs-the-rest)\n",
-    "\n",
-    "The reason I combined `LinearSVC` with `OneVsRestClassifier` is because `LinearSVC` supports **Multi-class**, while we want to perform **Multi-label** classification."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%%capture\n",
-    "from sklearn.multiclass import OneVsRestClassifier\n",
-    "from sklearn.svm import LinearSVC\n",
-    "\n",
-    "classifier = OneVsRestClassifier(LinearSVC())\n",
-    "classifier.fit(vectorised_train_documents, train_labels)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "After fitting the classifier, I decided to use `cross_val_score` to **measure score** of the classifier by **cross validation** on the training data. But the only problem was, I wanted to **shuffle** data to use with `cross_val_score`, but it does not support shuffle argument.\n",
-    "\n",
-    "So, I decided to use `KFold` with `cross_val_score` as `KFold` supports shuffling the data.\n",
-    "\n",
-    "I also enabled `random_state`, because `random_state` will guarantee the same output in each run. By setting the `random_state`, it is guaranteed that the pseudorandom number generator will generate the same sequence of random integers each time, which in turn will affect the split.\n",
-    "\n",
-    "Why **42**?\n",
-    "- [Why '42' is the preferred number when indicating something random?](https://softwareengineering.stackexchange.com/questions/507/why-42-is-the-preferred-number-when-indicating-something-random)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%%capture\n",
-    "from sklearn.model_selection import KFold, cross_val_score\n",
-    "\n",
-    "kf = KFold(n_splits=10, random_state = 42, shuffle = True)\n",
-    "scores = cross_val_score(classifier, vectorised_train_documents, train_labels, cv = kf)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Cross-validation scores: [0.83655084 0.86743887 0.8043758  0.83011583 0.83655084 0.81724582\n",
-      " 0.82754183 0.8030888  0.80694981 0.82731959]\n",
-      "Cross-validation accuracy: 0.8257 (+/- 0.0368)\n"
-     ]
-    }
-   ],
-   "source": [
-    "print('Cross-validation scores:', scores)\n",
-    "print('Cross-validation accuracy: {:.4f} (+/- {:.4f})'.format(scores.mean(), scores.std() * 2))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "In the end, I used different methods (`accuracy_score`, `precision_score`, `recall_score`, `f1_score` and `confusion_matrix`) provided by scikit-learn **to evaluate** the classifier. (both *Macro-* and *Micro-averages*)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%%capture\n",
-    "from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, confusion_matrix\n",
-    "\n",
-    "predictions = classifier.predict(vectorised_test_documents)\n",
-    "\n",
-    "accuracy = accuracy_score(test_labels, predictions)\n",
-    "\n",
-    "macro_precision = precision_score(test_labels, predictions, average='macro')\n",
-    "macro_recall = recall_score(test_labels, predictions, average='macro')\n",
-    "macro_f1 = f1_score(test_labels, predictions, average='macro')\n",
-    "\n",
-    "micro_precision = precision_score(test_labels, predictions, average='micro')\n",
-    "micro_recall = recall_score(test_labels, predictions, average='micro')\n",
-    "micro_f1 = f1_score(test_labels, predictions, average='micro')\n",
-    "\n",
-    "cm = confusion_matrix(test_labels.argmax(axis = 1), predictions.argmax(axis = 1))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Accuracy: 0.8099\n",
-      "Precision:\n",
-      "- Macro: 0.6076\n",
-      "- Micro: 0.9471\n",
-      "Recall:\n",
-      "- Macro: 0.3708\n",
-      "- Micro: 0.7981\n",
-      "F1-measure:\n",
-      "- Macro: 0.4410\n",
-      "- Micro: 0.8662\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(\"Accuracy: {:.4f}\\nPrecision:\\n- Macro: {:.4f}\\n- Micro: {:.4f}\\nRecall:\\n- Macro: {:.4f}\\n- Micro: {:.4f}\\nF1-measure:\\n- Macro: {:.4f}\\n- Micro: {:.4f}\".format(accuracy, macro_precision, micro_precision, macro_recall, micro_recall, macro_f1, micro_f1))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "In below cell, I used `matplotlib.pyplot` to **plot the confusion matrix** (of first *few results only* to keep the readings readable) using `heatmap` of `seaborn`."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<matplotlib.figure.Figure at 0x24d8cf39f28>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "import matplotlib.pyplot as plt\n",
-    "import seaborn as sb\n",
-    "import pandas as pd\n",
-    "\n",
-    "cm_plt = pd.DataFrame(cm[:73])\n",
-    "\n",
-    "plt.figure(figsize = (25, 25))\n",
-    "ax = plt.axes()\n",
-    "\n",
-    "sb.heatmap(cm_plt, annot=True)\n",
-    "\n",
-    "ax.xaxis.set_ticks_position('top')\n",
-    "\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Pipeline"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Now, I took the data from [Coconut - Wikipedia](https://en.wikipedia.org/wiki/Coconut) to check if the classifier is able to **correctly** predict the label(s) or not.\n",
-    "\n",
-    "And here is the output:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Example labels: [('coconut', 'oilseed')]\n"
-     ]
-    }
-   ],
-   "source": [
-    "example_text = '''The coconut tree (Cocos nucifera) is a member of the family Arecaceae (palm family) and the only species of the genus Cocos.\n",
-    "The term coconut can refer to the whole coconut palm or the seed, or the fruit, which, botanically, is a drupe, not a nut.\n",
-    "The spelling cocoanut is an archaic form of the word.\n",
-    "The term is derived from the 16th-century Portuguese and Spanish word coco meaning \"head\" or \"skull\", from the three indentations on the coconut shell that resemble facial features.\n",
-    "Coconuts are known for their versatility ranging from food to cosmetics.\n",
-    "They form a regular part of the diets of many people in the tropics and subtropics.\n",
-    "Coconuts are distinct from other fruits for their endosperm containing a large quantity of water (also called \"milk\"), and when immature, may be harvested for the potable coconut water.\n",
-    "When mature, they can be used as seed nuts or processed for oil, charcoal from the hard shell, and coir from the fibrous husk.\n",
-    "When dried, the coconut flesh is called copra.\n",
-    "The oil and milk derived from it are commonly used in cooking and frying, as well as in soaps and cosmetics.\n",
-    "The husks and leaves can be used as material to make a variety of products for furnishing and decorating.\n",
-    "The coconut also has cultural and religious significance in certain societies, particularly in India, where it is used in Hindu rituals.'''\n",
-    "\n",
-    "example_preds = classifier.predict(vectorizer.transform([example_text]))\n",
-    "example_labels = mlb.inverse_transform(example_preds)\n",
-    "print(\"Example labels: {}\".format(example_labels))"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.6.6"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/neural_network/fully_connected_neural_network.ipynb b/neural_network/fully_connected_neural_network.ipynb
deleted file mode 100644
index a8bcf4beeea1..000000000000
--- a/neural_network/fully_connected_neural_network.ipynb
+++ /dev/null
@@ -1,327 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Standard (Fully Connected) Neural Network"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#Use in Markup cell type\n",
-    "#![alt text](imagename.png \"Title\")  "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Implementing Fully connected Neural Net"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### Loading Required packages and Data"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Using TensorFlow backend.\n"
-     ]
-    }
-   ],
-   "source": [
-    "###1. Load Data and Splot Data\n",
-    "from keras.datasets import mnist\n",
-    "from keras.models import Sequential \n",
-    "from keras.layers.core import Dense, Activation\n",
-    "from keras.utils import np_utils\n",
-    "(X_train, Y_train), (X_test, Y_test) = mnist.load_data()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### Preprocessing"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<Figure size 2000x400 with 10 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "import matplotlib.pyplot as plt\n",
-    "n = 10  # how many digits we will display\n",
-    "plt.figure(figsize=(20, 4))\n",
-    "for i in range(n):\n",
-    "    # display original\n",
-    "    ax = plt.subplot(2, n, i + 1)\n",
-    "    plt.imshow(X_test[i].reshape(28, 28))\n",
-    "    plt.gray()\n",
-    "    ax.get_xaxis().set_visible(False)\n",
-    "    ax.get_yaxis().set_visible(False)\n",
-    "plt.show()\n",
-    "plt.close()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Previous X_train shape: (60000, 28, 28) \n",
-      "Previous Y_train shape:(60000,)\n",
-      "New X_train shape: (60000, 784) \n",
-      "New Y_train shape:(60000, 10)\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(\"Previous X_train shape: {} \\nPrevious Y_train shape:{}\".format(X_train.shape, Y_train.shape))\n",
-    "X_train = X_train.reshape(60000, 784)     \n",
-    "X_test = X_test.reshape(10000, 784)\n",
-    "X_train = X_train.astype('float32')     \n",
-    "X_test = X_test.astype('float32')     \n",
-    "X_train /= 255    \n",
-    "X_test /= 255\n",
-    "classes = 10\n",
-    "Y_train = np_utils.to_categorical(Y_train, classes)     \n",
-    "Y_test = np_utils.to_categorical(Y_test, classes)\n",
-    "print(\"New X_train shape: {} \\nNew Y_train shape:{}\".format(X_train.shape, Y_train.shape))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### Setting up parameters"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "input_size = 784\n",
-    "batch_size = 200   \n",
-    "hidden1 = 400\n",
-    "hidden2 = 20\n",
-    "epochs = 2"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### Building the FCN Model"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "_________________________________________________________________\n",
-      "Layer (type)                 Output Shape              Param #   \n",
-      "=================================================================\n",
-      "dense_1 (Dense)              (None, 400)               314000    \n",
-      "_________________________________________________________________\n",
-      "dense_2 (Dense)              (None, 20)                8020      \n",
-      "_________________________________________________________________\n",
-      "dense_3 (Dense)              (None, 10)                210       \n",
-      "=================================================================\n",
-      "Total params: 322,230\n",
-      "Trainable params: 322,230\n",
-      "Non-trainable params: 0\n",
-      "_________________________________________________________________\n"
-     ]
-    }
-   ],
-   "source": [
-    "###4.Build the model\n",
-    "model = Sequential()     \n",
-    "model.add(Dense(hidden1, input_dim=input_size, activation='relu'))\n",
-    "# output = relu (dot (W, input) + bias)\n",
-    "model.add(Dense(hidden2, activation='relu'))\n",
-    "model.add(Dense(classes, activation='softmax')) \n",
-    "\n",
-    "# Compilation\n",
-    "model.compile(loss='categorical_crossentropy', \n",
-    "    metrics=['accuracy'], optimizer='sgd')\n",
-    "model.summary()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### Training The Model"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Epoch 1/10\n",
-      " - 12s - loss: 1.4482 - acc: 0.6251\n",
-      "Epoch 2/10\n",
-      " - 3s - loss: 0.6239 - acc: 0.8482\n",
-      "Epoch 3/10\n",
-      " - 3s - loss: 0.4582 - acc: 0.8798\n",
-      "Epoch 4/10\n",
-      " - 3s - loss: 0.3941 - acc: 0.8936\n",
-      "Epoch 5/10\n",
-      " - 3s - loss: 0.3579 - acc: 0.9011\n",
-      "Epoch 6/10\n",
-      " - 4s - loss: 0.3328 - acc: 0.9070\n",
-      "Epoch 7/10\n",
-      " - 3s - loss: 0.3138 - acc: 0.9118\n",
-      "Epoch 8/10\n",
-      " - 3s - loss: 0.2980 - acc: 0.9157\n",
-      "Epoch 9/10\n",
-      " - 3s - loss: 0.2849 - acc: 0.9191\n",
-      "Epoch 10/10\n",
-      " - 3s - loss: 0.2733 - acc: 0.9223\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "<keras.callbacks.History at 0x272375a7240>"
-      ]
-     },
-     "execution_count": 7,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# Fitting on Data\n",
-    "model.fit(X_train, Y_train, batch_size=batch_size, epochs=10, verbose=2)\n",
-    "###5.Test "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "collapsed": true
-   },
-   "source": [
-    "#### Testing The Model"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "10000/10000 [==============================] - 1s 121us/step\n",
-      "\n",
-      "Test accuracy: 0.9257\n",
-      "[0 6 9 0 1 5 9 7 3 4]\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 1440x288 with 10 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "score = model.evaluate(X_test, Y_test, verbose=1)\n",
-    "print('\\n''Test accuracy:', score[1])\n",
-    "mask = range(10,20)\n",
-    "X_valid = X_test[mask]\n",
-    "y_pred = model.predict_classes(X_valid)\n",
-    "print(y_pred)\n",
-    "plt.figure(figsize=(20, 4))\n",
-    "for i in range(n):\n",
-    "    # display original\n",
-    "    ax = plt.subplot(2, n, i + 1)\n",
-    "    plt.imshow(X_valid[i].reshape(28, 28))\n",
-    "    plt.gray()\n",
-    "    ax.get_xaxis().set_visible(False)\n",
-    "    ax.get_yaxis().set_visible(False)\n",
-    "plt.show()\n",
-    "plt.close()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.6.6"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

From ce7faa5a3ae4824ebc89bf7b40b715cb4c898999 Mon Sep 17 00:00:00 2001
From: anubhav-sharma13 <45630457+anubhav-sharma13@users.noreply.github.com>
Date: Tue, 22 Oct 2019 13:00:11 +0530
Subject: [PATCH 292/348] Largest subarray sum (#1404)

* Insertion_sort

* largest subarray sum

* updated print command

* removed extraspaces

* removed sys.maxint

* added explaination

* Updated function style

* Update largest_subarray_sum.py

* Update i_sort.py

* Delete bogo_bogo_sort.py
---
 other/largest_subarray_sum.py | 23 +++++++++++++++
 sorts/bogo_bogo_sort.py       | 54 -----------------------------------
 sorts/i_sort.py               | 21 ++++++++++++++
 3 files changed, 44 insertions(+), 54 deletions(-)
 create mode 100644 other/largest_subarray_sum.py
 delete mode 100644 sorts/bogo_bogo_sort.py
 create mode 100644 sorts/i_sort.py

diff --git a/other/largest_subarray_sum.py b/other/largest_subarray_sum.py
new file mode 100644
index 000000000000..0449e72e64e3
--- /dev/null
+++ b/other/largest_subarray_sum.py
@@ -0,0 +1,23 @@
+from sys import maxsize
+
+
+def max_sub_array_sum(a: list, size: int = 0):
+    """
+    >>> max_sub_array_sum([-13, -3, -25, -20, -3, -16, -23, -12, -5, -22, -15, -4, -7])
+    -3
+    """
+    size = size or len(a)
+    max_so_far = -maxsize - 1
+    max_ending_here = 0
+    for i in range(0, size):
+        max_ending_here = max_ending_here + a[i]
+        if max_so_far < max_ending_here:
+            max_so_far = max_ending_here
+        if max_ending_here < 0:
+            max_ending_here = 0
+    return max_so_far
+
+
+if __name__ == "__main__":
+    a = [-13, -3, -25, -20, 1, -16, -23, -12, -5, -22, -15, -4, -7]
+    print(("Maximum contiguous sum is", max_sub_array_sum(a, len(a))))
diff --git a/sorts/bogo_bogo_sort.py b/sorts/bogo_bogo_sort.py
deleted file mode 100644
index f26a46e78645..000000000000
--- a/sorts/bogo_bogo_sort.py
+++ /dev/null
@@ -1,54 +0,0 @@
-"""
-Python implementation of bogobogosort, a "sorting algorithm
-designed not to succeed before the heat death of the universe
-on any sizable list" - https://en.wikipedia.org/wiki/Bogosort.
-
-Author: WilliamHYZhang
-"""
-
-import random
-
-
-def bogo_bogo_sort(collection):
-    """
-    returns the collection sorted in ascending order
-    :param collection: list of comparable items
-    :return: the list sorted in ascending order
-
-    Examples:
-    >>> bogo_bogo_sort([0, 5, 3, 2, 2])
-    [0, 2, 2, 3, 5]
-    >>> bogo_bogo_sort([-2, -5, -45])
-    [-45, -5, -2]
-    >>> bogo_bogo_sort([420, 69])
-    [69, 420]
-    """
-
-    def is_sorted(collection):
-        if len(collection) == 1:
-            return True
-
-        clone = collection.copy()
-        while True:
-            random.shuffle(clone)
-            ordered = bogo_bogo_sort(clone[:-1])
-            if clone[len(clone) - 1] >= max(ordered):
-                break
-
-        for i in range(len(ordered)):
-            clone[i] = ordered[i]
-
-        for i in range(len(collection)):
-            if clone[i] != collection[i]:
-                return False
-        return True
-
-    while not is_sorted(collection):
-        random.shuffle(collection)
-    return collection
-
-
-if __name__ == "__main__":
-    user_input = input("Enter numbers separated by a comma:\n").strip()
-    unsorted = [int(item) for item in user_input.split(",")]
-    print(bogo_bogo_sort(unsorted))
diff --git a/sorts/i_sort.py b/sorts/i_sort.py
new file mode 100644
index 000000000000..f6100a8d0819
--- /dev/null
+++ b/sorts/i_sort.py
@@ -0,0 +1,21 @@
+def insertionSort(arr):
+    """
+    >>> a = arr[:]
+    >>> insertionSort(a)
+    >>> a == sorted(a)
+    True
+    """
+    for i in range(1, len(arr)):
+        key = arr[i]
+        j = i - 1
+        while j >= 0 and key < arr[j]:
+            arr[j + 1] = arr[j]
+            j -= 1
+        arr[j + 1] = key
+
+
+arr = [12, 11, 13, 5, 6]
+insertionSort(arr)
+print("Sorted array is:")
+for i in range(len(arr)):
+    print("%d" % arr[i])

From 8b572e6cfd7da8d96443c3e1fd0b013153854265 Mon Sep 17 00:00:00 2001
From: Suad Djelili <suadjelili@gmail.com>
Date: Tue, 22 Oct 2019 10:31:17 +0300
Subject: [PATCH 293/348] added solution 7 for problem_01 (#1416)

* added solution 7 for problem_01

* added solution 5 for problem_02
---
 project_euler/problem_01/sol7.py | 32 ++++++++++++++++++++++
 project_euler/problem_02/sol5.py | 46 ++++++++++++++++++++++++++++++++
 2 files changed, 78 insertions(+)
 create mode 100644 project_euler/problem_01/sol7.py
 create mode 100644 project_euler/problem_02/sol5.py

diff --git a/project_euler/problem_01/sol7.py b/project_euler/problem_01/sol7.py
new file mode 100644
index 000000000000..a0510b54c409
--- /dev/null
+++ b/project_euler/problem_01/sol7.py
@@ -0,0 +1,32 @@
+"""
+Problem Statement:
+If we list all the natural numbers below 10 that are multiples of 3 or 5,
+we get 3,5,6 and 9. The sum of these multiples is 23.
+Find the sum of all the multiples of 3 or 5 below N.
+"""
+
+
+def solution(n):
+    """Returns the sum of all the multiples of 3 or 5 below n.
+
+    >>> solution(3)
+    0
+    >>> solution(4)
+    3
+    >>> solution(10)
+    23
+    >>> solution(600)
+    83700
+    """
+
+    result = 0
+    for i in range(n):
+        if i % 3 == 0:
+            result += i
+        elif i % 5 == 0:
+            result += i
+    return result
+
+
+if __name__ == "__main__":
+    print(solution(int(input().strip())))
diff --git a/project_euler/problem_02/sol5.py b/project_euler/problem_02/sol5.py
new file mode 100644
index 000000000000..8df2068dd8c3
--- /dev/null
+++ b/project_euler/problem_02/sol5.py
@@ -0,0 +1,46 @@
+"""
+Problem:
+Each new term in the Fibonacci sequence is generated by adding the previous two
+terms. By starting with 1 and 2, the first 10 terms will be:
+
+    1,2,3,5,8,13,21,34,55,89,..
+
+By considering the terms in the Fibonacci sequence whose values do not exceed
+n, find the sum of the even-valued terms. e.g. for n=10, we have {2,8}, sum is
+10.
+"""
+
+
+def solution(n):
+    """Returns the sum of all fibonacci sequence even elements that are lower
+    or equals to n.
+
+    >>> solution(10)
+    10
+    >>> solution(15)
+    10
+    >>> solution(2)
+    2
+    >>> solution(1)
+    0
+    >>> solution(34)
+    44
+    """
+
+    a = [0,1]
+    i = 0
+    while a[i] <= n:
+        a.append(a[i] + a[i+1])
+        if a[i+2] > n:
+            break
+        i += 1
+    sum = 0
+    for j in range(len(a) - 1):
+        if a[j] % 2 == 0:
+            sum += a[j]
+
+    return sum
+
+
+if __name__ == "__main__":
+    print(solution(int(input().strip())))

From 92268561a54f6f443a71c0e83fdd0a0d69ab24d7 Mon Sep 17 00:00:00 2001
From: Aashay Shingre <akshingre@gmail.com>
Date: Tue, 22 Oct 2019 13:12:56 +0530
Subject: [PATCH 294/348] Aho-Corasick String Matching Algorithm (#346)

* add aho-corasick algorithm

* Add a doctest and format with black
---
 strings/aho-corasick.py | 92 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 92 insertions(+)
 create mode 100644 strings/aho-corasick.py

diff --git a/strings/aho-corasick.py b/strings/aho-corasick.py
new file mode 100644
index 000000000000..6790892a358d
--- /dev/null
+++ b/strings/aho-corasick.py
@@ -0,0 +1,92 @@
+from collections import deque
+
+
+class Automaton:
+    def __init__(self, keywords):
+        self.adlist = list()
+        self.adlist.append(
+            {"value": "", "next_states": [], "fail_state": 0, "output": []}
+        )
+
+        for keyword in keywords:
+            self.add_keyword(keyword)
+        self.set_fail_transitions()
+
+    def find_next_state(self, current_state, char):
+        for state in self.adlist[current_state]["next_states"]:
+            if char == self.adlist[state]["value"]:
+                return state
+        return None
+
+    def add_keyword(self, keyword):
+        current_state = 0
+        for character in keyword:
+            if self.find_next_state(current_state, character):
+                current_state = self.find_next_state(current_state, character)
+            else:
+                self.adlist.append(
+                    {
+                        "value": character,
+                        "next_states": [],
+                        "fail_state": 0,
+                        "output": [],
+                    }
+                )
+                self.adlist[current_state]["next_states"].append(len(self.adlist) - 1)
+                current_state = len(self.adlist) - 1
+        self.adlist[current_state]["output"].append(keyword)
+
+    def set_fail_transitions(self):
+        q = deque()
+        for node in self.adlist[0]["next_states"]:
+            q.append(node)
+            self.adlist[node]["fail_state"] = 0
+        while q:
+            r = q.popleft()
+            for child in self.adlist[r]["next_states"]:
+                q.append(child)
+                state = self.adlist[r]["fail_state"]
+                while (
+                    self.find_next_state(state, self.adlist[child]["value"]) == None
+                    and state != 0
+                ):
+                    state = self.adlist[state]["fail_state"]
+                self.adlist[child]["fail_state"] = self.find_next_state(
+                    state, self.adlist[child]["value"]
+                )
+                if self.adlist[child]["fail_state"] == None:
+                    self.adlist[child]["fail_state"] = 0
+                self.adlist[child]["output"] = (
+                    self.adlist[child]["output"]
+                    + self.adlist[self.adlist[child]["fail_state"]]["output"]
+                )
+
+    def search_in(self, string):
+        """
+        >>> A = Automaton(["what", "hat", "ver", "er"])
+        >>> A.search_in("whatever, err ... , wherever")
+        {'what': [0], 'hat': [1], 'ver': [5, 25], 'er': [6, 10, 22, 26]}
+        """
+        result = dict()  # returns a dict with keywords and list of its occurences
+        current_state = 0
+        for i in range(len(string)):
+            while (
+                self.find_next_state(current_state, string[i]) == None
+                and current_state != 0
+            ):
+                current_state = self.adlist[current_state]["fail_state"]
+            current_state = self.find_next_state(current_state, string[i])
+            if current_state is None:
+                current_state = 0
+            else:
+                for key in self.adlist[current_state]["output"]:
+                    if not (key in result):
+                        result[key] = []
+                    result[key].append((i - len(key) + 1))
+        return result
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()

From 54830644a280ee2b8e59497f303220a211422118 Mon Sep 17 00:00:00 2001
From: Anmol Jain <30307833+jainanmol123@users.noreply.github.com>
Date: Tue, 22 Oct 2019 13:31:14 +0530
Subject: [PATCH 295/348] Create newton_forward_interpolation.py (#333)

* Create newton_forward_interpolation.py

This code is for calculating newton forward difference interpolation for fixed difference.

* Add doctests and reformat with black
---
 .../newton_forward_interpolation.py           | 55 +++++++++++++++++++
 1 file changed, 55 insertions(+)
 create mode 100644 arithmetic_analysis/newton_forward_interpolation.py

diff --git a/arithmetic_analysis/newton_forward_interpolation.py b/arithmetic_analysis/newton_forward_interpolation.py
new file mode 100644
index 000000000000..09adb5113f82
--- /dev/null
+++ b/arithmetic_analysis/newton_forward_interpolation.py
@@ -0,0 +1,55 @@
+# https://www.geeksforgeeks.org/newton-forward-backward-interpolation/
+
+import math
+
+# for calculating u value
+def ucal(u, p):
+    """
+    >>> ucal(1, 2)
+    0
+    >>> ucal(1.1, 2)
+    0.11000000000000011
+    >>> ucal(1.2, 2)
+    0.23999999999999994
+    """
+    temp = u
+    for i in range(1, p):
+        temp = temp * (u - i)
+    return temp
+
+
+def main():
+    n = int(input("enter the numbers of values"))
+    y = []
+    for i in range(n):
+        y.append([])
+    for i in range(n):
+        for j in range(n):
+            y[i].append(j)
+            y[i][j] = 0
+
+    print("enter the values of parameters in a list")
+    x = list(map(int, input().split()))
+
+    print("enter the values of corresponding parameters")
+    for i in range(n):
+        y[i][0] = float(input())
+
+    value = int(input("enter the value to interpolate"))
+    u = (value - x[0]) / (x[1] - x[0])
+
+    # for calculating forward difference table
+
+    for i in range(1, n):
+        for j in range(n - i):
+            y[j][i] = y[j + 1][i - 1] - y[j][i - 1]
+
+    summ = y[0][0]
+    for i in range(1, n):
+        summ += (ucal(u, i) * y[0][i]) / math.factorial(i)
+
+    print("the value at {} is {}".format(value, summ))
+
+
+if __name__ == "__main__":
+    main()

From 13802fcca154803e1cf619ddfb7f7975d0ca8f59 Mon Sep 17 00:00:00 2001
From: DanishSheikh1999 <43725095+DanishSheikh1999@users.noreply.github.com>
Date: Tue, 22 Oct 2019 14:25:01 +0530
Subject: [PATCH 296/348] Create greedy.py (#1359)

* Create greedy.py

* Update greedy.py

* Add a doctest and format with black

* Update build_directory_md.py
---
 other/greedy.py               | 63 +++++++++++++++++++++++++++++++++++
 scripts/build_directory_md.py |  6 ++--
 2 files changed, 65 insertions(+), 4 deletions(-)
 create mode 100644 other/greedy.py

diff --git a/other/greedy.py b/other/greedy.py
new file mode 100644
index 000000000000..d1bc156304b0
--- /dev/null
+++ b/other/greedy.py
@@ -0,0 +1,63 @@
+class things:
+    def __init__(self, n, v, w):
+        self.name = n
+        self.value = v
+        self.weight = w
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}({self.name}, {self.value}, {self.weight})"
+
+    def get_value(self):
+        return self.value
+
+    def get_name(self):
+        return self.name
+
+    def get_weight(self):
+        return self.weight
+
+    def value_Weight(self):
+        return self.value / self.weight
+
+
+def build_menu(name, value, weight):
+    menu = []
+    for i in range(len(value)):
+        menu.append(things(name[i], value[i], weight[i]))
+    return menu
+
+
+def greedy(item, maxCost, keyFunc):
+    itemsCopy = sorted(item, key=keyFunc, reverse=True)
+    result = []
+    totalValue, total_cost = 0.0, 0.0
+    for i in range(len(itemsCopy)):
+        if (total_cost + itemsCopy[i].get_weight()) <= maxCost:
+            result.append(itemsCopy[i])
+            total_cost += itemsCopy[i].get_weight()
+            totalValue += itemsCopy[i].get_value()
+    return (result, totalValue)
+
+
+def test_greedy():
+    """
+    >>> food = ["Burger", "Pizza", "Coca Cola", "Rice",
+    ...         "Sambhar", "Chicken", "Fries", "Milk"]
+    >>> value = [80, 100, 60, 70, 50, 110, 90, 60]
+    >>> weight = [40, 60, 40, 70, 100, 85, 55, 70]
+    >>> foods = build_menu(food, value, weight)
+    >>> foods  # doctest: +NORMALIZE_WHITESPACE
+    [things(Burger, 80, 40), things(Pizza, 100, 60), things(Coca Cola, 60, 40),
+     things(Rice, 70, 70), things(Sambhar, 50, 100), things(Chicken, 110, 85),
+     things(Fries, 90, 55), things(Milk, 60, 70)]
+    >>> greedy(foods, 500, things.get_value)  # doctest: +NORMALIZE_WHITESPACE
+    ([things(Chicken, 110, 85), things(Pizza, 100, 60), things(Fries, 90, 55),
+      things(Burger, 80, 40), things(Rice, 70, 70), things(Coca Cola, 60, 40),
+      things(Milk, 60, 70)], 570.0)
+    """
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()
diff --git a/scripts/build_directory_md.py b/scripts/build_directory_md.py
index cae38c13dbf4..2ebd445b3667 100755
--- a/scripts/build_directory_md.py
+++ b/scripts/build_directory_md.py
@@ -25,7 +25,7 @@ def print_path(old_path: str, new_path: str) -> str:
     for i, new_part in enumerate(new_path.split(os.sep)):
         if i + 1 > len(old_parts) or old_parts[i] != new_part:
             if new_part:
-                print(f"{md_prefix(i-1)} {new_part.replace('_', ' ').title()}")
+                print(f"{md_prefix(i)} {new_part.replace('_', ' ').title()}")
     return new_path
 
 
@@ -36,9 +36,7 @@ def print_directory_md(top_dir: str = ".") -> None:
         if filepath != old_path:
             old_path = print_path(old_path, filepath)
         indent = (filepath.count(os.sep) + 1) if filepath else 0
-        url = "/".join((URL_BASE, filepath.split(os.sep)[1], filename)).replace(
-            " ", "%20"
-        )
+        url = "/".join((URL_BASE, filepath, filename)).replace(" ", "%20")
         filename = os.path.splitext(filename.replace("_", " "))[0]
         print(f"{md_prefix(indent)} [{filename}]({url})")
 

From 7444a1f0693c5e08d6859d549ce5485db5a988b1 Mon Sep 17 00:00:00 2001
From: Ghulam Mohiyuddin <subahani98@gmail.com>
Date: Tue, 22 Oct 2019 14:56:06 +0530
Subject: [PATCH 297/348] Another method added for GCD (#1387)

* Another method added for GCD

* Now doctest fulfilled for added method.

* Update greatest_common_divisor.py

* Now unnecessary white spaces removed.

* Cycle_Detection_Undirected_Graph

Cycle_Detection_Undirected_Graph using Disjoint set DataStructure

* Update greatest_common_divisor.py again

* Again Updated cycle_detection_undirected_graph.py

* Delete cycle_detection_undirected_graph.py

* Add doctests and format the code with psf/black

* fixup: Typo

* Update greatest_common_divisor.py

* greatest_common_divisor()
---
 maths/greatest_common_divisor.py | 38 ++++++++++++++++++++++++++------
 1 file changed, 31 insertions(+), 7 deletions(-)

diff --git a/maths/greatest_common_divisor.py b/maths/greatest_common_divisor.py
index ebc08f37ffa6..a1b915bc3cfb 100644
--- a/maths/greatest_common_divisor.py
+++ b/maths/greatest_common_divisor.py
@@ -5,20 +5,44 @@
 """
 
 
-def gcd(a, b):
-    """Calculate Greatest Common Divisor (GCD)."""
-    return b if a == 0 else gcd(b % a, a)
+def greatest_common_divisor(a, b):
+    """
+    Calculate Greatest Common Divisor (GCD).
+    >>> greatest_common_divisor(24, 40)
+    8
+    """
+    return b if a == 0 else greatest_common_divisor(b % a, a)
+
+
+"""
+Below method is more memory efficient because it does not use the stack (chunk of memory).
+While above method is good, uses more memory for huge numbers because of the recursive calls
+required to calculate the greatest common divisor.
+"""
+
+
+def gcd_by_iterative(x, y):
+    """
+    >>> gcd_by_iterative(24, 40)
+    8
+    >>> greatest_common_divisor(24, 40) == gcd_by_iterative(24, 40)
+    True
+    """
+    while y:  # --> when y=0 then loop will terminate and return x as final GCD.
+        x, y = y, x % y
+    return x
 
 
 def main():
-    """Call GCD Function."""
+    """Call Greatest Common Divisor function."""
     try:
-        nums = input("Enter two Integers separated by comma (,): ").split(",")
+        nums = input("Enter two integers separated by comma (,): ").split(",")
         num_1 = int(nums[0])
         num_2 = int(nums[1])
-        print(f"gcd({num_1}, {num_2}) = {gcd(num_1, num_2)}")
+        print(f"greatest_common_divisor({num_1}, {num_2}) = {greatest_common_divisor(num_1, num_2)}")
+        print(f"By iterative gcd({num_1}, {num_2}) = {gcd_by_iterative(num_1, num_2)}")
     except (IndexError, UnboundLocalError, ValueError):
-        print("Wrong Input")
+        print("Wrong input")
 
 
 if __name__ == "__main__":

From 906c985de3b0156ac50a1bd10d0c803f3439cf4e Mon Sep 17 00:00:00 2001
From: Daniel Melo <38673841+danielx285@users.noreply.github.com>
Date: Tue, 22 Oct 2019 06:37:43 -0300
Subject: [PATCH 298/348] Create dinic.py (#1396)

* Create dinic.py

Dinic's algorithm for maximum flow

* Update dinic.py

Changes made.
---
 graphs/dinic.py | 93 +++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 93 insertions(+)
 create mode 100644 graphs/dinic.py

diff --git a/graphs/dinic.py b/graphs/dinic.py
new file mode 100644
index 000000000000..38e91e4940e0
--- /dev/null
+++ b/graphs/dinic.py
@@ -0,0 +1,93 @@
+INF = float("inf")
+
+class Dinic:
+    def __init__(self, n):
+        self.lvl = [0] * n
+        self.ptr = [0] * n
+        self.q = [0] * n
+        self.adj = [[] for _ in range(n)]
+
+    '''
+    Here we will add our edges containing with the following parameters:
+    vertex closest to source, vertex closest to sink and flow capacity
+    through that edge ...
+    '''
+    def add_edge(self, a, b, c, rcap=0):
+        self.adj[a].append([b, len(self.adj[b]), c, 0])
+        self.adj[b].append([a, len(self.adj[a]) - 1, rcap, 0])
+
+    #This is a sample depth first search to be used at max_flow
+    def depth_first_search(self, vertex, sink, flow):
+        if vertex == sink or not flow:
+            return flow
+
+        for i in range(self.ptr[vertex], len(self.adj[vertex])):
+            e = self.adj[vertex][i]
+            if self.lvl[e[0]] == self.lvl[vertex] + 1:
+                p = self.depth_first_search(e[0], sink, min(flow, e[2] - e[3]))
+                if p:
+                    self.adj[vertex][i][3] += p
+                    self.adj[e[0]][e[1]][3] -= p
+                    return p
+            self.ptr[vertex] = self.ptr[vertex] + 1
+        return 0
+    
+    #Here we calculate the flow that reaches the sink
+    def max_flow(self, source, sink):
+        flow, self.q[0] = 0, source
+        for l in range(31):  # l = 30 maybe faster for random data
+            while True:
+                self.lvl, self.ptr = [0] * len(self.q), [0] * len(self.q)
+                qi, qe, self.lvl[source] = 0, 1, 1
+                while qi < qe and not self.lvl[sink]:
+                    v = self.q[qi]
+                    qi += 1
+                    for e in self.adj[v]:
+                        if not self.lvl[e[0]] and (e[2] - e[3]) >> (30 - l):
+                            self.q[qe] = e[0]
+                            qe += 1
+                            self.lvl[e[0]] = self.lvl[v] + 1
+
+                p = self.depth_first_search(source, sink, INF)
+                while p:
+                    flow += p
+                    p = self.depth_first_search(source, sink, INF)
+
+                if not self.lvl[sink]:
+                    break
+
+        return flow
+
+#Example to use
+
+'''
+Will be a bipartite graph, than it has the vertices near the source(4)
+and the vertices near the sink(4)
+'''
+#Here we make a graphs with 10 vertex(source and sink includes)
+graph = Dinic(10)
+source = 0
+sink = 9
+'''
+Now we add the vertices next to the font in the font with 1 capacity in this edge
+(source -> source vertices)
+'''
+for vertex in range(1, 5):
+	graph.add_edge(source, vertex, 1)
+'''
+We will do the same thing for the vertices near the sink, but from vertex to sink
+(sink vertices -> sink)
+'''
+for vertex in range(5, 9):
+	graph.add_edge(vertex, sink, 1)
+'''
+Finally we add the verices near the sink to the vertices near the source.
+(source vertices -> sink vertices)
+'''
+for vertex in range(1, 5):
+	graph.add_edge(vertex, vertex+4, 1)
+
+#Now we can know that is the maximum flow(source -> sink)
+print(graph.max_flow(source, sink))
+
+        

From 11e2207182829ee6b1d13c0aec326d5a123d2c9b Mon Sep 17 00:00:00 2001
From: Ankur Chattopadhyay <39518771+chttrjeankr@users.noreply.github.com>
Date: Tue, 22 Oct 2019 21:32:03 +0530
Subject: [PATCH 299/348] Project Euler problems 06, 20 (#1419)

* added sol3.py for problem_20

* added sol4.py for problem_06
---
 project_euler/problem_06/sol4.py | 40 ++++++++++++++++++++++++++++++++
 project_euler/problem_20/sol3.py | 39 +++++++++++++++++++++++++++++++
 2 files changed, 79 insertions(+)
 create mode 100644 project_euler/problem_06/sol4.py
 create mode 100644 project_euler/problem_20/sol3.py

diff --git a/project_euler/problem_06/sol4.py b/project_euler/problem_06/sol4.py
new file mode 100644
index 000000000000..1e1de5570e7d
--- /dev/null
+++ b/project_euler/problem_06/sol4.py
@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+"""
+Problem:
+
+The sum of the squares of the first ten natural numbers is,
+            1^2 + 2^2 + ... + 10^2 = 385
+
+The square of the sum of the first ten natural numbers is,
+            (1 + 2 + ... + 10)^2 = 552 = 3025
+
+Hence the difference between the sum of the squares of the first ten natural
+numbers and the square of the sum is 3025 − 385 = 2640.
+
+Find the difference between the sum of the squares of the first N natural
+numbers and the square of the sum.
+"""
+
+
+def solution(n):
+    """Returns the difference between the sum of the squares of the first n
+    natural numbers and the square of the sum.
+
+    >>> solution(10)
+    2640
+    >>> solution(15)
+    13160
+    >>> solution(20)
+    41230
+    >>> solution(50)
+    1582700
+    >>> solution(100)
+    25164150
+    """
+    sum_of_squares = n * (n + 1) * (2 * n + 1) / 6
+    square_of_sum = (n * (n + 1) / 2) ** 2
+    return int(square_of_sum - sum_of_squares)
+
+
+if __name__ == "__main__":
+    print(solution(int(input("Enter a number: ").strip())))
diff --git a/project_euler/problem_20/sol3.py b/project_euler/problem_20/sol3.py
new file mode 100644
index 000000000000..13f9d7831c47
--- /dev/null
+++ b/project_euler/problem_20/sol3.py
@@ -0,0 +1,39 @@
+"""
+n! means n × (n − 1) × ... × 3 × 2 × 1
+
+For example, 10! = 10 × 9 × ... × 3 × 2 × 1 = 3628800,
+and the sum of the digits in the number 10! is 3 + 6 + 2 + 8 + 8 + 0 + 0 = 27.
+
+Find the sum of the digits in the number 100!
+"""
+from math import factorial
+
+
+def solution(n):
+    """Returns the sum of the digits in the number 100!
+    >>> solution(1000)
+    10539
+    >>> solution(200)
+    1404
+    >>> solution(100)
+    648
+    >>> solution(50)
+    216
+    >>> solution(10)
+    27
+    >>> solution(5)
+    3
+    >>> solution(3)
+    6
+    >>> solution(2)
+    2
+    >>> solution(1)
+    1
+    >>> solution(0)
+    1
+    """
+    return sum(map(int, str(factorial(n))))
+
+
+if __name__ == "__main__":
+    print(solution(int(input("Enter the Number: ").strip())))

From 7592cba417b1766b8c7c5721ffe916f5c14cdc60 Mon Sep 17 00:00:00 2001
From: Ankur Chattopadhyay <39518771+chttrjeankr@users.noreply.github.com>
Date: Tue, 22 Oct 2019 22:43:48 +0530
Subject: [PATCH 300/348] psf/black code formatting (#1421)

* added sol3.py for problem_20

* added sol4.py for problem_06

* ran `black .` on `\Python`
---
 ciphers/base64_cipher.py                      |   2 +-
 ciphers/caesar_cipher.py                      |  12 +-
 data_structures/binary_tree/treap.py          |  26 ++--
 divide_and_conquer/mergesort.py               |  67 ++++++-----
 dynamic_programming/abbreviation.py           |   1 +
 dynamic_programming/fibonacci.py              |   2 +-
 dynamic_programming/fractional_knapsack.py    |   1 +
 .../longest_common_subsequence.py             |   2 +-
 dynamic_programming/sum_of_subset.py          |   1 +
 fuzzy_logic/fuzzy_operations.py               |  80 +++++++------
 graphs/dinic.py                               |  43 +++----
 machine_learning/decision_tree.py             |   8 +-
 machine_learning/polymonial_regression.py     |  22 ++--
 maths/3n+1.py                                 | 113 +++++++++++++++++-
 maths/explicit_euler.py                       |   5 +-
 maths/factorial_python.py                     |   2 +-
 maths/greatest_common_divisor.py              |   4 +-
 maths/karatsuba.py                            |   9 +-
 maths/prime_sieve_eratosthenes.py             |  19 +--
 maths/qr_decomposition.py                     |  12 +-
 maths/runge_kutta.py                          |   8 +-
 other/activity_selection.py                   |  46 +++----
 other/magicdiamondpattern.py                  |  67 ++++++-----
 other/password_generator.py                   |  42 ++++---
 project_euler/problem_02/sol5.py              |   6 +-
 searches/fibonacci_search.py                  |  30 +++--
 sorts/bubble_sort.py                          |   3 +-
 sorts/double_sort.py                          |  36 +++---
 28 files changed, 415 insertions(+), 254 deletions(-)

diff --git a/ciphers/base64_cipher.py b/ciphers/base64_cipher.py
index eea065b94ee0..f95403c7b426 100644
--- a/ciphers/base64_cipher.py
+++ b/ciphers/base64_cipher.py
@@ -18,7 +18,7 @@ def encode_base64(text):
     i = 0
     while i < len(s):
         if i > 0 and ((i / 3 * 4) % 76) == 0:
-            r = r + "\r\n" # for unix newline, put "\n"
+            r = r + "\r\n"  # for unix newline, put "\n"
 
         n = (s[i] << 16) + (s[i + 1] << 8) + s[i + 2]
 
diff --git a/ciphers/caesar_cipher.py b/ciphers/caesar_cipher.py
index 52155bbdc49e..200f868051d4 100644
--- a/ciphers/caesar_cipher.py
+++ b/ciphers/caesar_cipher.py
@@ -1,5 +1,5 @@
 def encrypt(input_string: str, key: int) -> str:
-    result = ''
+    result = ""
     for x in input_string:
         if not x.isalpha():
             result += x
@@ -11,7 +11,7 @@ def encrypt(input_string: str, key: int) -> str:
 
 
 def decrypt(input_string: str, key: int) -> str:
-    result = ''
+    result = ""
     for x in input_string:
         if not x.isalpha():
             result += x
@@ -24,15 +24,15 @@ def decrypt(input_string: str, key: int) -> str:
 
 def brute_force(input_string: str) -> None:
     key = 1
-    result = ''
+    result = ""
     while key <= 94:
         for x in input_string:
             indx = (ord(x) - key) % 256
             if indx < 32:
                 indx = indx + 95
             result = result + chr(indx)
-        print(f'Key: {key}\t| Message: {result}')
-        result = ''
+        print(f"Key: {key}\t| Message: {result}")
+        result = ""
         key += 1
     return None
 
@@ -40,7 +40,7 @@ def brute_force(input_string: str) -> None:
 def main():
     while True:
         print(f'{"-" * 10}\n Menu\n{"-", * 10}')
-        print(*["1.Encrpyt", "2.Decrypt", "3.BruteForce", "4.Quit"], sep='\n')
+        print(*["1.Encrpyt", "2.Decrypt", "3.BruteForce", "4.Quit"], sep="\n")
         choice = input("What would you like to do?: ")
         if choice not in ["1", "2", "3", "4"]:
             print("Invalid choice, please enter a valid choice")
diff --git a/data_structures/binary_tree/treap.py b/data_structures/binary_tree/treap.py
index 0b5947f4cc04..a6ff3c9d798b 100644
--- a/data_structures/binary_tree/treap.py
+++ b/data_structures/binary_tree/treap.py
@@ -7,6 +7,7 @@ class Node(object):
     Treap's node
     Treap is a binary tree by value and heap by priority
     """
+
     def __init__(self, value: int = None):
         self.value = value
         self.prior = random()
@@ -20,10 +21,7 @@ def __repr__(self):
             return "'%s: %.5s'" % (self.value, self.prior)
         else:
             return pformat(
-                {
-                    "%s: %.5s"
-                    % (self.value, self.prior): (self.left, self.right)
-                },
+                {"%s: %.5s" % (self.value, self.prior): (self.left, self.right)},
                 indent=1,
             )
 
@@ -33,6 +31,7 @@ def __str__(self):
         right = str(self.right or "")
         return value + left + right
 
+
 def split(root: Node, value: int) -> Tuple[Node, Node]:
     """
     We split current tree into 2 trees with value:
@@ -61,12 +60,13 @@ def split(root: Node, value: int) -> Tuple[Node, Node]:
             root.right, right = split(root.right, value)
             return (root, right)
 
+
 def merge(left: Node, right: Node) -> Node:
     """
     We merge 2 trees into one.
     Note: all left tree's values must be less than all right tree's
     """
-    if (not left) or (not right):   # If one node is None, return the other
+    if (not left) or (not right):  # If one node is None, return the other
         return left or right
     elif left.prior < right.prior:
         """
@@ -82,6 +82,7 @@ def merge(left: Node, right: Node) -> Node:
         right.left = merge(left, right.left)
         return right
 
+
 def insert(root: Node, value: int) -> Node:
     """
     Insert element
@@ -94,6 +95,7 @@ def insert(root: Node, value: int) -> Node:
     left, right = split(root, value)
     return merge(merge(left, node), right)
 
+
 def erase(root: Node, value: int) -> Node:
     """
     Erase element
@@ -102,15 +104,16 @@ def erase(root: Node, value: int) -> Node:
     Split all nodes with values greater into right.
     Merge left, right
     """
-    left, right = split(root, value-1)
+    left, right = split(root, value - 1)
     _, right = split(right, value)
     return merge(left, right)
 
+
 def inorder(root: Node):
     """
     Just recursive print of a tree
     """
-    if not root:    # None
+    if not root:  # None
         return
     else:
         inorder(root.left)
@@ -154,13 +157,16 @@ def interactTreap(root, args):
 
     return root
 
+
 def main():
     """After each command, program prints treap"""
     root = None
-    print("enter numbers to creat a tree, + value to add value into treap, - value to erase all nodes with value. 'q' to quit. ")
+    print(
+        "enter numbers to creat a tree, + value to add value into treap, - value to erase all nodes with value. 'q' to quit. "
+    )
 
     args = input()
-    while args != 'q':
+    while args != "q":
         root = interactTreap(root, args)
         print(root)
         args = input()
@@ -168,7 +174,9 @@ def main():
     print("good by!")
     pass
 
+
 if __name__ == "__main__":
     import doctest
+
     doctest.testmod()
     main()
diff --git a/divide_and_conquer/mergesort.py b/divide_and_conquer/mergesort.py
index b2a5a4c321ae..d6693eb36a0a 100644
--- a/divide_and_conquer/mergesort.py
+++ b/divide_and_conquer/mergesort.py
@@ -1,45 +1,48 @@
-def merge(a,b,m,e):
-    l=a[b:m+1]
-    r=a[m+1:e+1]
-    k=b
-    i=0
-    j=0
-    while i<len(l) and j<len(r):
-        #change sign for Descending order
-        if l[i]<r[j]: 
-            a[k]=l[i]
-            i+=1
+def merge(a, b, m, e):
+    l = a[b : m + 1]
+    r = a[m + 1 : e + 1]
+    k = b
+    i = 0
+    j = 0
+    while i < len(l) and j < len(r):
+        # change sign for Descending order
+        if l[i] < r[j]:
+            a[k] = l[i]
+            i += 1
         else:
-            a[k]=r[j]
-            j+=1
-        k+=1
-    while i<len(l):
-        a[k]=l[i]
-        i+=1
-        k+=1
-    while j<len(r):
-        a[k]=r[j]
-        j+=1
-        k+=1
+            a[k] = r[j]
+            j += 1
+        k += 1
+    while i < len(l):
+        a[k] = l[i]
+        i += 1
+        k += 1
+    while j < len(r):
+        a[k] = r[j]
+        j += 1
+        k += 1
     return a
-    
-def mergesort(a,b,e):
+
+
+def mergesort(a, b, e):
     """
     >>> mergesort([3,2,1],0,2)
     [1, 2, 3]
     >>> mergesort([3,2,1,0,1,2,3,5,4],0,8)
     [0, 1, 1, 2, 2, 3, 3, 4, 5]
     """
-    if b<e:
-        m = (b+e)//2
-        #print("ms1",a,b,m)
-        mergesort(a,b,m)
-        #print("ms2",a,m+1,e)
-        mergesort(a,m+1,e)
-        #print("m",a,b,m,e)
-        merge(a,b,m,e)
+    if b < e:
+        m = (b + e) // 2
+        # print("ms1",a,b,m)
+        mergesort(a, b, m)
+        # print("ms2",a,m+1,e)
+        mergesort(a, m + 1, e)
+        # print("m",a,b,m,e)
+        merge(a, b, m, e)
         return a
 
+
 if __name__ == "__main__":
     import doctest
+
     doctest.testmod()
diff --git a/dynamic_programming/abbreviation.py b/dynamic_programming/abbreviation.py
index a2aec35af77b..5432c24882e4 100644
--- a/dynamic_programming/abbreviation.py
+++ b/dynamic_programming/abbreviation.py
@@ -11,6 +11,7 @@
 daBcd -> capitalize a and c(dABCd) -> remove d (ABC)
 """
 
+
 def abbr(a, b):
     """
     >>> abbr("daBcd", "ABC")
diff --git a/dynamic_programming/fibonacci.py b/dynamic_programming/fibonacci.py
index 125686416603..923560b54d30 100644
--- a/dynamic_programming/fibonacci.py
+++ b/dynamic_programming/fibonacci.py
@@ -58,7 +58,7 @@ def get(self, sequence_no=None):
                 print("\nInvalid input, please try again.")
     except NameError:
         print("\n********* Invalid input, good bye!! ************\n")
-        
+
     import doctest
 
     doctest.testmod()
diff --git a/dynamic_programming/fractional_knapsack.py b/dynamic_programming/fractional_knapsack.py
index 728cdeb009ac..15210146bf66 100644
--- a/dynamic_programming/fractional_knapsack.py
+++ b/dynamic_programming/fractional_knapsack.py
@@ -20,6 +20,7 @@ def fracKnapsack(vl, wt, W, n):
         else sum(vl[:k])
     )
 
+
 if __name__ == "__main__":
     import doctest
 
diff --git a/dynamic_programming/longest_common_subsequence.py b/dynamic_programming/longest_common_subsequence.py
index 4bb1db044d3b..a7206b221d96 100644
--- a/dynamic_programming/longest_common_subsequence.py
+++ b/dynamic_programming/longest_common_subsequence.py
@@ -76,7 +76,7 @@ def longest_common_subsequence(x: str, y: str):
     expected_subseq = "GTAB"
 
     ln, subseq = longest_common_subsequence(a, b)
-##    print("len =", ln, ", sub-sequence =", subseq)
+    ##    print("len =", ln, ", sub-sequence =", subseq)
     import doctest
 
     doctest.testmod()
diff --git a/dynamic_programming/sum_of_subset.py b/dynamic_programming/sum_of_subset.py
index 5c7944d5090e..9394d29dabc0 100644
--- a/dynamic_programming/sum_of_subset.py
+++ b/dynamic_programming/sum_of_subset.py
@@ -29,6 +29,7 @@ def isSumSubset(arr, arrLen, requiredSum):
     #     print(subset[i])
     print(subset[arrLen][requiredSum])
 
+
 if __name__ == "__main__":
     import doctest
 
diff --git a/fuzzy_logic/fuzzy_operations.py b/fuzzy_logic/fuzzy_operations.py
index e497eabd1690..ba4a8a22a4d1 100644
--- a/fuzzy_logic/fuzzy_operations.py
+++ b/fuzzy_logic/fuzzy_operations.py
@@ -8,37 +8,39 @@
 """
 # Create universe of discourse in python using linspace ()
 import numpy as np
+
 X = np.linspace(start=0, stop=75, num=75, endpoint=True, retstep=False)
 
 # Create two fuzzy sets by defining any membership function (trapmf(), gbellmf(),gaussmf(), etc).
 import skfuzzy as fuzz
-abc1=[0,25,50]
-abc2=[25,50,75]
-young = fuzz.membership.trimf(X,abc1)
-middle_aged = fuzz.membership.trimf(X,abc2)
+
+abc1 = [0, 25, 50]
+abc2 = [25, 50, 75]
+young = fuzz.membership.trimf(X, abc1)
+middle_aged = fuzz.membership.trimf(X, abc2)
 
 # Compute the different operations using inbuilt functions.
 one = np.ones(75)
 zero = np.zeros((75,))
-#1. Union = max(µA(x), µB(x))
+# 1. Union = max(µA(x), µB(x))
 union = fuzz.fuzzy_or(X, young, X, middle_aged)[1]
-#2. Intersection = min(µA(x), µB(x))
+# 2. Intersection = min(µA(x), µB(x))
 intersection = fuzz.fuzzy_and(X, young, X, middle_aged)[1]
-#3. Complement (A) = (1- min(µA(x))
+# 3. Complement (A) = (1- min(µA(x))
 complement_a = fuzz.fuzzy_not(young)
-#4. Difference (A/B) = min(µA(x),(1- µB(x)))
+# 4. Difference (A/B) = min(µA(x),(1- µB(x)))
 difference = fuzz.fuzzy_and(X, young, X, fuzz.fuzzy_not(middle_aged)[1])[1]
-#5. Algebraic Sum = [µA(x) + µB(x) – (µA(x) * µB(x))]
-alg_sum = young + middle_aged - (young*middle_aged)
-#6. Algebraic Product = (µA(x) * µB(x))
-alg_product = young*middle_aged
-#7. Bounded Sum = min[1,(µA(x), µB(x))]
-bdd_sum = fuzz.fuzzy_and(X, one, X, young+middle_aged)[1]
-#8. Bounded difference = min[0,(µA(x), µB(x))]
-bdd_difference = fuzz.fuzzy_or(X, zero, X, young-middle_aged)[1]
+# 5. Algebraic Sum = [µA(x) + µB(x) – (µA(x) * µB(x))]
+alg_sum = young + middle_aged - (young * middle_aged)
+# 6. Algebraic Product = (µA(x) * µB(x))
+alg_product = young * middle_aged
+# 7. Bounded Sum = min[1,(µA(x), µB(x))]
+bdd_sum = fuzz.fuzzy_and(X, one, X, young + middle_aged)[1]
+# 8. Bounded difference = min[0,(µA(x), µB(x))]
+bdd_difference = fuzz.fuzzy_or(X, zero, X, young - middle_aged)[1]
 
-#max-min composition
-#max-product composition
+# max-min composition
+# max-product composition
 
 
 # Plot each set A, set B and each operation result using plot() and subplot().
@@ -46,55 +48,55 @@
 
 plt.figure()
 
-plt.subplot(4,3,1)
-plt.plot(X,young)
+plt.subplot(4, 3, 1)
+plt.plot(X, young)
 plt.title("Young")
 plt.grid(True)
 
-plt.subplot(4,3,2)
-plt.plot(X,middle_aged)
+plt.subplot(4, 3, 2)
+plt.plot(X, middle_aged)
 plt.title("Middle aged")
 plt.grid(True)
 
-plt.subplot(4,3,3)
-plt.plot(X,union)
+plt.subplot(4, 3, 3)
+plt.plot(X, union)
 plt.title("union")
 plt.grid(True)
 
-plt.subplot(4,3,4)
-plt.plot(X,intersection)
+plt.subplot(4, 3, 4)
+plt.plot(X, intersection)
 plt.title("intersection")
 plt.grid(True)
 
-plt.subplot(4,3,5)
-plt.plot(X,complement_a)
+plt.subplot(4, 3, 5)
+plt.plot(X, complement_a)
 plt.title("complement_a")
 plt.grid(True)
 
-plt.subplot(4,3,6)
-plt.plot(X,difference)
+plt.subplot(4, 3, 6)
+plt.plot(X, difference)
 plt.title("difference a/b")
 plt.grid(True)
 
-plt.subplot(4,3,7)
-plt.plot(X,alg_sum)
+plt.subplot(4, 3, 7)
+plt.plot(X, alg_sum)
 plt.title("alg_sum")
 plt.grid(True)
 
-plt.subplot(4,3,8)
-plt.plot(X,alg_product)
+plt.subplot(4, 3, 8)
+plt.plot(X, alg_product)
 plt.title("alg_product")
 plt.grid(True)
 
-plt.subplot(4,3,9)
-plt.plot(X,bdd_sum)
+plt.subplot(4, 3, 9)
+plt.plot(X, bdd_sum)
 plt.title("bdd_sum")
 plt.grid(True)
 
-plt.subplot(4,3,10)
-plt.plot(X,bdd_difference)
+plt.subplot(4, 3, 10)
+plt.plot(X, bdd_difference)
 plt.title("bdd_difference")
 plt.grid(True)
 
-plt.subplots_adjust(hspace = 0.5)
+plt.subplots_adjust(hspace=0.5)
 plt.show()
diff --git a/graphs/dinic.py b/graphs/dinic.py
index 38e91e4940e0..4f5e81236984 100644
--- a/graphs/dinic.py
+++ b/graphs/dinic.py
@@ -1,5 +1,6 @@
 INF = float("inf")
 
+
 class Dinic:
     def __init__(self, n):
         self.lvl = [0] * n
@@ -7,16 +8,17 @@ def __init__(self, n):
         self.q = [0] * n
         self.adj = [[] for _ in range(n)]
 
-    '''
+    """
     Here we will add our edges containing with the following parameters:
     vertex closest to source, vertex closest to sink and flow capacity
     through that edge ...
-    '''
+    """
+
     def add_edge(self, a, b, c, rcap=0):
         self.adj[a].append([b, len(self.adj[b]), c, 0])
         self.adj[b].append([a, len(self.adj[a]) - 1, rcap, 0])
 
-    #This is a sample depth first search to be used at max_flow
+    # This is a sample depth first search to be used at max_flow
     def depth_first_search(self, vertex, sink, flow):
         if vertex == sink or not flow:
             return flow
@@ -31,8 +33,8 @@ def depth_first_search(self, vertex, sink, flow):
                     return p
             self.ptr[vertex] = self.ptr[vertex] + 1
         return 0
-    
-    #Here we calculate the flow that reaches the sink
+
+    # Here we calculate the flow that reaches the sink
     def max_flow(self, source, sink):
         flow, self.q[0] = 0, source
         for l in range(31):  # l = 30 maybe faster for random data
@@ -58,36 +60,35 @@ def max_flow(self, source, sink):
 
         return flow
 
-#Example to use
 
-'''
+# Example to use
+
+"""
 Will be a bipartite graph, than it has the vertices near the source(4)
 and the vertices near the sink(4)
-'''
-#Here we make a graphs with 10 vertex(source and sink includes)
+"""
+# Here we make a graphs with 10 vertex(source and sink includes)
 graph = Dinic(10)
 source = 0
 sink = 9
-'''
+"""
 Now we add the vertices next to the font in the font with 1 capacity in this edge
 (source -> source vertices)
-'''
+"""
 for vertex in range(1, 5):
-	graph.add_edge(source, vertex, 1)
-'''
+    graph.add_edge(source, vertex, 1)
+"""
 We will do the same thing for the vertices near the sink, but from vertex to sink
 (sink vertices -> sink)
-'''
+"""
 for vertex in range(5, 9):
-	graph.add_edge(vertex, sink, 1)
-'''
+    graph.add_edge(vertex, sink, 1)
+"""
 Finally we add the verices near the sink to the vertices near the source.
 (source vertices -> sink vertices)
-'''
+"""
 for vertex in range(1, 5):
-	graph.add_edge(vertex, vertex+4, 1)
+    graph.add_edge(vertex, vertex + 4, 1)
 
-#Now we can know that is the maximum flow(source -> sink)
+# Now we can know that is the maximum flow(source -> sink)
 print(graph.max_flow(source, sink))
-
-        
diff --git a/machine_learning/decision_tree.py b/machine_learning/decision_tree.py
index 14c02b64df0c..6b121c73f3b4 100644
--- a/machine_learning/decision_tree.py
+++ b/machine_learning/decision_tree.py
@@ -125,6 +125,7 @@ def predict(self, x):
             print("Error: Decision tree not yet trained")
             return None
 
+
 class Test_Decision_Tree:
     """Decision Tres test class
     """
@@ -139,12 +140,9 @@ def helper_mean_squared_error_test(labels, prediction):
         """
         squared_error_sum = np.float(0)
         for label in labels:
-            squared_error_sum += ((label-prediction) ** 2)
+            squared_error_sum += (label - prediction) ** 2
 
-        return np.float(squared_error_sum/labels.size)
-    
-    
-    
+        return np.float(squared_error_sum / labels.size)
 
 
 def main():
diff --git a/machine_learning/polymonial_regression.py b/machine_learning/polymonial_regression.py
index 03f5f0a9713d..0d9db0f7578a 100644
--- a/machine_learning/polymonial_regression.py
+++ b/machine_learning/polymonial_regression.py
@@ -2,19 +2,23 @@
 import pandas as pd
 
 # Importing the dataset
-dataset = pd.read_csv('https://s3.us-west-2.amazonaws.com/public.gamelab.fun/dataset/position_salaries.csv')
+dataset = pd.read_csv(
+    "https://s3.us-west-2.amazonaws.com/public.gamelab.fun/dataset/position_salaries.csv"
+)
 X = dataset.iloc[:, 1:2].values
 y = dataset.iloc[:, 2].values
 
 
 # Splitting the dataset into the Training set and Test set
-from sklearn.model_selection import train_test_split 
+from sklearn.model_selection import train_test_split
+
 X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
 
 
 # Fitting Polynomial Regression to the dataset
 from sklearn.preprocessing import PolynomialFeatures
 from sklearn.linear_model import LinearRegression
+
 poly_reg = PolynomialFeatures(degree=4)
 X_poly = poly_reg.fit_transform(X)
 pol_reg = LinearRegression()
@@ -23,15 +27,17 @@
 
 # Visualizing the Polymonial Regression results
 def viz_polymonial():
-    plt.scatter(X, y, color='red')
-    plt.plot(X, pol_reg.predict(poly_reg.fit_transform(X)), color='blue')
-    plt.title('Truth or Bluff (Linear Regression)')
-    plt.xlabel('Position level')
-    plt.ylabel('Salary')
+    plt.scatter(X, y, color="red")
+    plt.plot(X, pol_reg.predict(poly_reg.fit_transform(X)), color="blue")
+    plt.title("Truth or Bluff (Linear Regression)")
+    plt.xlabel("Position level")
+    plt.ylabel("Salary")
     plt.show()
     return
+
+
 viz_polymonial()
 
 # Predicting a new result with Polymonial Regression
 pol_reg.predict(poly_reg.fit_transform([[5.5]]))
-#output should be 132148.43750003
+# output should be 132148.43750003
diff --git a/maths/3n+1.py b/maths/3n+1.py
index ff769550297c..f6fe77b2b3fe 100644
--- a/maths/3n+1.py
+++ b/maths/3n+1.py
@@ -29,7 +29,118 @@ def test_n31():
     """
     assert n31(4) == ([4, 2, 1], 3)
     assert n31(11) == ([11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1], 15)
-    assert n31(31) == ([31, 94, 47, 142, 71, 214, 107, 322, 161, 484, 242, 121, 364, 182, 91, 274, 137, 412, 206, 103, 310, 155, 466, 233, 700, 350, 175, 526, 263, 790, 395, 1186, 593, 1780, 890, 445, 1336, 668, 334, 167, 502, 251, 754, 377, 1132, 566, 283, 850, 425, 1276, 638, 319, 958, 479, 1438, 719, 2158, 1079, 3238, 1619, 4858, 2429, 7288, 3644, 1822, 911, 2734, 1367, 4102, 2051, 6154, 3077, 9232, 4616, 2308, 1154, 577, 1732, 866, 433, 1300, 650, 325, 976, 488, 244, 122, 61, 184, 92, 46, 23, 70, 35, 106, 53, 160, 80, 40, 20, 10, 5, 16, 8, 4, 2, 1], 107)
+    assert n31(31) == (
+        [
+            31,
+            94,
+            47,
+            142,
+            71,
+            214,
+            107,
+            322,
+            161,
+            484,
+            242,
+            121,
+            364,
+            182,
+            91,
+            274,
+            137,
+            412,
+            206,
+            103,
+            310,
+            155,
+            466,
+            233,
+            700,
+            350,
+            175,
+            526,
+            263,
+            790,
+            395,
+            1186,
+            593,
+            1780,
+            890,
+            445,
+            1336,
+            668,
+            334,
+            167,
+            502,
+            251,
+            754,
+            377,
+            1132,
+            566,
+            283,
+            850,
+            425,
+            1276,
+            638,
+            319,
+            958,
+            479,
+            1438,
+            719,
+            2158,
+            1079,
+            3238,
+            1619,
+            4858,
+            2429,
+            7288,
+            3644,
+            1822,
+            911,
+            2734,
+            1367,
+            4102,
+            2051,
+            6154,
+            3077,
+            9232,
+            4616,
+            2308,
+            1154,
+            577,
+            1732,
+            866,
+            433,
+            1300,
+            650,
+            325,
+            976,
+            488,
+            244,
+            122,
+            61,
+            184,
+            92,
+            46,
+            23,
+            70,
+            35,
+            106,
+            53,
+            160,
+            80,
+            40,
+            20,
+            10,
+            5,
+            16,
+            8,
+            4,
+            2,
+            1,
+        ],
+        107,
+    )
 
 
 if __name__ == "__main__":
diff --git a/maths/explicit_euler.py b/maths/explicit_euler.py
index 9fce4e4185a6..8a43d71fb432 100644
--- a/maths/explicit_euler.py
+++ b/maths/explicit_euler.py
@@ -22,13 +22,13 @@ def explicit_euler(ode_func, y0, x0, stepsize, x_end):
     >>> y[-1]
     144.77277243257308
     """
-    N = int(np.ceil((x_end - x0)/stepsize))
+    N = int(np.ceil((x_end - x0) / stepsize))
     y = np.zeros((N + 1,))
     y[0] = y0
     x = x0
 
     for k in range(N):
-        y[k + 1] = y[k] + stepsize*ode_func(x, y[k])
+        y[k + 1] = y[k] + stepsize * ode_func(x, y[k])
         x += stepsize
 
     return y
@@ -38,4 +38,3 @@ def explicit_euler(ode_func, y0, x0, stepsize, x_end):
     import doctest
 
     doctest.testmod()
-
diff --git a/maths/factorial_python.py b/maths/factorial_python.py
index 10083af0bef2..ab97cd41e681 100644
--- a/maths/factorial_python.py
+++ b/maths/factorial_python.py
@@ -11,7 +11,7 @@ def factorial(input_number: int) -> int:
     """
 
     if input_number < 0:
-        raise ValueError('Input input_number should be non-negative')
+        raise ValueError("Input input_number should be non-negative")
     elif input_number == 0:
         return 1
     else:
diff --git a/maths/greatest_common_divisor.py b/maths/greatest_common_divisor.py
index a1b915bc3cfb..07dddab9aeff 100644
--- a/maths/greatest_common_divisor.py
+++ b/maths/greatest_common_divisor.py
@@ -39,7 +39,9 @@ def main():
         nums = input("Enter two integers separated by comma (,): ").split(",")
         num_1 = int(nums[0])
         num_2 = int(nums[1])
-        print(f"greatest_common_divisor({num_1}, {num_2}) = {greatest_common_divisor(num_1, num_2)}")
+        print(
+            f"greatest_common_divisor({num_1}, {num_2}) = {greatest_common_divisor(num_1, num_2)}"
+        )
         print(f"By iterative gcd({num_1}, {num_2}) = {gcd_by_iterative(num_1, num_2)}")
     except (IndexError, UnboundLocalError, ValueError):
         print("Wrong input")
diff --git a/maths/karatsuba.py b/maths/karatsuba.py
index be4630184933..df29c77a5cf2 100644
--- a/maths/karatsuba.py
+++ b/maths/karatsuba.py
@@ -1,5 +1,6 @@
 """ Multiply two numbers using Karatsuba algorithm """
 
+
 def karatsuba(a, b):
     """
     >>> karatsuba(15463, 23489) == 15463 * 23489
@@ -8,19 +9,19 @@ def karatsuba(a, b):
     True
     """
     if len(str(a)) == 1 or len(str(b)) == 1:
-        return (a * b)
+        return a * b
     else:
         m1 = max(len(str(a)), len(str(b)))
         m2 = m1 // 2
 
-        a1, a2 = divmod(a, 10**m2)
-        b1, b2 = divmod(b, 10**m2)
+        a1, a2 = divmod(a, 10 ** m2)
+        b1, b2 = divmod(b, 10 ** m2)
 
         x = karatsuba(a2, b2)
         y = karatsuba((a1 + a2), (b1 + b2))
         z = karatsuba(a1, b1)
 
-        return ((z * 10**(2*m2)) + ((y - z - x) * 10**(m2)) + (x))
+        return (z * 10 ** (2 * m2)) + ((y - z - x) * 10 ** (m2)) + (x)
 
 
 def main():
diff --git a/maths/prime_sieve_eratosthenes.py b/maths/prime_sieve_eratosthenes.py
index 7d039aaadd7d..4fa19d6db220 100644
--- a/maths/prime_sieve_eratosthenes.py
+++ b/maths/prime_sieve_eratosthenes.py
@@ -1,4 +1,4 @@
-'''
+"""
 Sieve of Eratosthenes
 
 Input : n =10
@@ -9,7 +9,8 @@
 
 you can read in detail about this at 
 https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes
-'''
+"""
+
 
 def prime_sieve_eratosthenes(num):
     """
@@ -20,22 +21,22 @@ def prime_sieve_eratosthenes(num):
     >>> prime_sieve_eratosthenes(20)
     2 3 5 7 11 13 17 19 
     """
-    
-    
+
     primes = [True for i in range(num + 1)]
     p = 2
-    
+
     while p * p <= num:
         if primes[p] == True:
-            for i in range(p*p, num+1, p):
+            for i in range(p * p, num + 1, p):
                 primes[i] = False
-        p+=1
+        p += 1
 
-    for prime in range(2, num+1):
+    for prime in range(2, num + 1):
         if primes[prime]:
             print(prime, end=" ")
 
+
 if __name__ == "__main__":
     num = int(input())
-    
+
     prime_sieve_eratosthenes(num)
diff --git a/maths/qr_decomposition.py b/maths/qr_decomposition.py
index 197211f1e694..5e15fede4f2a 100644
--- a/maths/qr_decomposition.py
+++ b/maths/qr_decomposition.py
@@ -51,21 +51,21 @@ def qr_householder(A):
         # determine scaling factor
         alpha = np.linalg.norm(x)
         # construct vector v for Householder reflection
-        v = x + np.sign(x[0])*alpha*e1
+        v = x + np.sign(x[0]) * alpha * e1
         v /= np.linalg.norm(v)
 
         # construct the Householder matrix
-        Q_k = np.eye(m - k) - 2.0*v@v.T
+        Q_k = np.eye(m - k) - 2.0 * v @ v.T
         # pad with ones and zeros as necessary
-        Q_k = np.block([[np.eye(k),            np.zeros((k, m - k))],
-                        [np.zeros((m - k, k)), Q_k                 ]])
+        Q_k = np.block([[np.eye(k), np.zeros((k, m - k))], [np.zeros((m - k, k)), Q_k]])
 
-        Q = Q@Q_k.T
-        R = Q_k@R
+        Q = Q @ Q_k.T
+        R = Q_k @ R
 
     return Q, R
 
 
 if __name__ == "__main__":
     import doctest
+
     doctest.testmod()
diff --git a/maths/runge_kutta.py b/maths/runge_kutta.py
index b0ba9025883f..383797daa5ac 100644
--- a/maths/runge_kutta.py
+++ b/maths/runge_kutta.py
@@ -22,17 +22,17 @@ def runge_kutta(f, y0, x0, h, x_end):
     >>> y[-1]
     148.41315904125113
     """
-    N = int(np.ceil((x_end - x0)/h))
+    N = int(np.ceil((x_end - x0) / h))
     y = np.zeros((N + 1,))
     y[0] = y0
     x = x0
 
     for k in range(N):
         k1 = f(x, y[k])
-        k2 = f(x + 0.5*h, y[k] + 0.5*h*k1)
-        k3 = f(x + 0.5*h, y[k] + 0.5*h*k2)
+        k2 = f(x + 0.5 * h, y[k] + 0.5 * h * k1)
+        k3 = f(x + 0.5 * h, y[k] + 0.5 * h * k2)
         k4 = f(x + h, y[k] + h * k3)
-        y[k + 1] = y[k] + (1/6)*h*(k1 + 2*k2 + 2*k3 + k4)
+        y[k + 1] = y[k] + (1 / 6) * h * (k1 + 2 * k2 + 2 * k3 + k4)
         x += h
 
     return y
diff --git a/other/activity_selection.py b/other/activity_selection.py
index 5c14df7d6aa7..4e8e6c78e3f5 100644
--- a/other/activity_selection.py
+++ b/other/activity_selection.py
@@ -1,12 +1,13 @@
 """The following implementation assumes that the activities 
 are already sorted according to their finish time"""
-  
+
 """Prints a maximum set of activities that can be done by a 
 single person, one at a time"""
-# n --> Total number of activities 
-# start[]--> An array that contains start time of all activities 
-# finish[] --> An array that contains finish time of all activities 
-  
+# n --> Total number of activities
+# start[]--> An array that contains start time of all activities
+# finish[] --> An array that contains finish time of all activities
+
+
 def printMaxActivities(start, finish):
     """
     >>> start = [1, 3, 0, 5, 8, 5] 
@@ -15,27 +16,28 @@ def printMaxActivities(start, finish):
     The following activities are selected:
     0 1 3 4 
     """
-    n = len(finish) 
+    n = len(finish)
     print("The following activities are selected:")
-  
-    # The first activity is always selected 
+
+    # The first activity is always selected
     i = 0
     print(i, end=" ")
-  
-    # Consider rest of the activities 
-    for j in range(n): 
-  
-        # If this activity has start time greater than 
-        # or equal to the finish time of previously 
-        # selected activity, then select it 
-        if start[j] >= finish[i]: 
+
+    # Consider rest of the activities
+    for j in range(n):
+
+        # If this activity has start time greater than
+        # or equal to the finish time of previously
+        # selected activity, then select it
+        if start[j] >= finish[i]:
             print(j, end=" ")
-            i = j 
-  
-# Driver program to test above function 
-start = [1, 3, 0, 5, 8, 5] 
-finish = [2, 4, 6, 7, 9, 9] 
-printMaxActivities(start, finish) 
+            i = j
+
+
+# Driver program to test above function
+start = [1, 3, 0, 5, 8, 5]
+finish = [2, 4, 6, 7, 9, 9]
+printMaxActivities(start, finish)
 
 """
 The following activities are selected:
diff --git a/other/magicdiamondpattern.py b/other/magicdiamondpattern.py
index 024fbd0f569a..9b434a7b6e0b 100644
--- a/other/magicdiamondpattern.py
+++ b/other/magicdiamondpattern.py
@@ -2,52 +2,53 @@
 
 # Function to print upper half of diamond (pyramid)
 def floyd(n):
-	'''
+    """
 	Parameters: 
     n : size of pattern 
-	'''
-	for i in range(0, n):
-		for j in range(0, n-i-1): # printing spaces
-			print(" ", end = "")
-		for k in range(0, i + 1): # printing stars 
-			print("* ", end = "")
-		print()
+	"""
+    for i in range(0, n):
+        for j in range(0, n - i - 1):  # printing spaces
+            print(" ", end="")
+        for k in range(0, i + 1):  # printing stars
+            print("* ", end="")
+        print()
 
 
 # Function to print lower half of diamond (pyramid)
 def reverse_floyd(n):
-	'''
+    """
 	Parameters: 
     n : size of pattern 
-	'''
-	for i in range(n, 0, -1):
-		for j in range(i, 0, -1):  # printing stars 
-			print("* ", end = "")
-		print()
-		for k in range(n-i+1, 0, -1):  # printing spaces 
-			print(" ", end = "")
+	"""
+    for i in range(n, 0, -1):
+        for j in range(i, 0, -1):  # printing stars
+            print("* ", end="")
+        print()
+        for k in range(n - i + 1, 0, -1):  # printing spaces
+            print(" ", end="")
+
 
 # Function to print complete diamond pattern of "*"
 def pretty_print(n):
-	'''
+    """
 	Parameters: 
     n : size of pattern 
-	'''
-	if n <= 0:
-		print("       ...       ....        nothing printing :(")
-		return 
-	floyd(n)   # upper half 
-	reverse_floyd(n) # lower half 
+	"""
+    if n <= 0:
+        print("       ...       ....        nothing printing :(")
+        return
+    floyd(n)  # upper half
+    reverse_floyd(n)  # lower half
 
 
 if __name__ == "__main__":
-	print(r"| /\ | |- |  |-  |--| |\  /| |-")
-	print(r"|/  \| |- |_ |_  |__| | \/ | |_")
-	K = 1
-	while(K):
-		user_number = int(input("enter the number and , and see the magic : "))
-		print()
-		pretty_print(user_number)
-		K = int(input("press 0 to exit... and 1 to continue..."))
-
-	print("Good Bye...")	
+    print(r"| /\ | |- |  |-  |--| |\  /| |-")
+    print(r"|/  \| |- |_ |_  |__| | \/ | |_")
+    K = 1
+    while K:
+        user_number = int(input("enter the number and , and see the magic : "))
+        print()
+        pretty_print(user_number)
+        K = int(input("press 0 to exit... and 1 to continue..."))
+
+    print("Good Bye...")
diff --git a/other/password_generator.py b/other/password_generator.py
index b4c7999ca44a..598f8d0eeade 100644
--- a/other/password_generator.py
+++ b/other/password_generator.py
@@ -27,21 +27,27 @@ def alternative_password_generator(ctbi, i):
     # Password generator = full boot with random_number, random_letters, and
     # random_character FUNCTIONS
     # Put your code here...
-	i = i - len(ctbi)
-	quotient = int(i / 3)
-	remainder = i % 3
-	#chars = ctbi + random_letters(ascii_letters, i / 3 + remainder) + random_number(digits, i / 3) + random_characters(punctuation, i / 3)
-	chars = ctbi + random(ascii_letters, quotient + remainder) + random(digits, quotient) + random(punctuation, quotient)
-	chars = list(chars)
-	shuffle(chars)
-	return "".join(chars)
-
-	
-	#random is a generalised function for letters, characters and numbers
+    i = i - len(ctbi)
+    quotient = int(i / 3)
+    remainder = i % 3
+    # chars = ctbi + random_letters(ascii_letters, i / 3 + remainder) + random_number(digits, i / 3) + random_characters(punctuation, i / 3)
+    chars = (
+        ctbi
+        + random(ascii_letters, quotient + remainder)
+        + random(digits, quotient)
+        + random(punctuation, quotient)
+    )
+    chars = list(chars)
+    shuffle(chars)
+    return "".join(chars)
+
+    # random is a generalised function for letters, characters and numbers
+
+
 def random(ctbi, i):
-	return "".join(choice(ctbi) for x in range(i))
-	
-	
+    return "".join(choice(ctbi) for x in range(i))
+
+
 def random_number(ctbi, i):
     pass  # Put your code here...
 
@@ -56,9 +62,13 @@ def random_characters(ctbi, i):
 
 def main():
     length = int(input("Please indicate the max length of your password: ").strip())
-    ctbi = input("Please indicate the characters that must be in your password: ").strip()
+    ctbi = input(
+        "Please indicate the characters that must be in your password: "
+    ).strip()
     print("Password generated:", password_generator(length))
-    print("Alternative Password generated:", alternative_password_generator(ctbi, length))
+    print(
+        "Alternative Password generated:", alternative_password_generator(ctbi, length)
+    )
     print("[If you are thinking of using this passsword, You better save it.]")
 
 
diff --git a/project_euler/problem_02/sol5.py b/project_euler/problem_02/sol5.py
index 8df2068dd8c3..180906cf8717 100644
--- a/project_euler/problem_02/sol5.py
+++ b/project_euler/problem_02/sol5.py
@@ -27,11 +27,11 @@ def solution(n):
     44
     """
 
-    a = [0,1]
+    a = [0, 1]
     i = 0
     while a[i] <= n:
-        a.append(a[i] + a[i+1])
-        if a[i+2] > n:
+        a.append(a[i] + a[i + 1])
+        if a[i + 2] > n:
             break
         i += 1
     sum = 0
diff --git a/searches/fibonacci_search.py b/searches/fibonacci_search.py
index f76528b9c283..67f2df505d4e 100644
--- a/searches/fibonacci_search.py
+++ b/searches/fibonacci_search.py
@@ -1,12 +1,14 @@
-#run using python fibonacci_search.py -v
+# run using python fibonacci_search.py -v
 
-'''
+"""
 @params
 arr: input array
 val: the value to be searched
 output: the index of element in the array or -1 if not found
 return 0 if input array is empty
-'''
+"""
+
+
 def fibonacci_search(arr, val):
 
     """
@@ -22,29 +24,31 @@ def fibonacci_search(arr, val):
     fibNext = fib_N_1 + fib_N_2
     length = len(arr)
     if length == 0:
-    	return 0
-    while (fibNext < len(arr)):
+        return 0
+    while fibNext < len(arr):
         fib_N_2 = fib_N_1
         fib_N_1 = fibNext
         fibNext = fib_N_1 + fib_N_2
-    index = -1;
-    while (fibNext > 1):
-        i = min(index + fib_N_2, (length-1))
-        if (arr[i] < val):
+    index = -1
+    while fibNext > 1:
+        i = min(index + fib_N_2, (length - 1))
+        if arr[i] < val:
             fibNext = fib_N_1
             fib_N_1 = fib_N_2
             fib_N_2 = fibNext - fib_N_1
             index = i
-        elif (arr[i] > val):
+        elif arr[i] > val:
             fibNext = fib_N_2
             fib_N_1 = fib_N_1 - fib_N_2
             fib_N_2 = fibNext - fib_N_1
-        else :
+        else:
             return i
-    if (fib_N_1 and index < length-1) and (arr[index+1] == val):
-        return index+1;
+    if (fib_N_1 and index < length - 1) and (arr[index + 1] == val):
+        return index + 1
     return -1
 
+
 if __name__ == "__main__":
     import doctest
+
     doctest.testmod()
diff --git a/sorts/bubble_sort.py b/sorts/bubble_sort.py
index 4faa40da1d8e..eb356bc7dcad 100644
--- a/sorts/bubble_sort.py
+++ b/sorts/bubble_sort.py
@@ -29,12 +29,13 @@ def bubble_sort(collection):
                 swapped = True
                 collection[j], collection[j + 1] = collection[j + 1], collection[j]
         if not swapped:
-            break  # Stop iteration if the collection is sorted.    
+            break  # Stop iteration if the collection is sorted.
     return collection
 
 
 if __name__ == "__main__":
     import time
+
     user_input = input("Enter numbers separated by a comma:").strip()
     unsorted = [int(item) for item in user_input.split(",")]
     start = time.process_time()
diff --git a/sorts/double_sort.py b/sorts/double_sort.py
index 011e17d8f035..aca4b97ca775 100644
--- a/sorts/double_sort.py
+++ b/sorts/double_sort.py
@@ -1,4 +1,4 @@
-def double_sort(lst): 
+def double_sort(lst):
     """this sorting algorithm sorts an array using the principle of bubble sort , 
     but does it both from left to right and right to left , 
     hence i decided to call it "double sort"
@@ -14,21 +14,29 @@ def double_sort(lst):
     >>> double_sort([-3, 10, 16, -42, 29]) == sorted([-3, 10, 16, -42, 29])
     True
     """
-    no_of_elements=len(lst)
-    for i in range(0,int(((no_of_elements-1)/2)+1)): # we dont need to traverse to end of list as
-        for j in range(0,no_of_elements-1):
-            if (lst[j+1]<lst[j]): # applying bubble sort algorithm from left to right (or forwards)
-                temp=lst[j+1]
-                lst[j+1]=lst[j]
-                lst[j]=temp
-            if (lst[no_of_elements-1-j]<lst[no_of_elements-2-j]): # applying bubble sort algorithm from right to left (or backwards)
-                temp=lst[no_of_elements-1-j]
-                lst[no_of_elements-1-j]=lst[no_of_elements-2-j]
-                lst[no_of_elements-2-j]=temp
+    no_of_elements = len(lst)
+    for i in range(
+        0, int(((no_of_elements - 1) / 2) + 1)
+    ):  # we dont need to traverse to end of list as
+        for j in range(0, no_of_elements - 1):
+            if (
+                lst[j + 1] < lst[j]
+            ):  # applying bubble sort algorithm from left to right (or forwards)
+                temp = lst[j + 1]
+                lst[j + 1] = lst[j]
+                lst[j] = temp
+            if (
+                lst[no_of_elements - 1 - j] < lst[no_of_elements - 2 - j]
+            ):  # applying bubble sort algorithm from right to left (or backwards)
+                temp = lst[no_of_elements - 1 - j]
+                lst[no_of_elements - 1 - j] = lst[no_of_elements - 2 - j]
+                lst[no_of_elements - 2 - j] = temp
     return lst
+
+
 if __name__ == "__main__":
     print("enter the list to be sorted")
-    lst = [int(x) for x in input().split()] # inputing elements of the list in one line
-    sorted_lst=double_sort(lst)
+    lst = [int(x) for x in input().split()]  # inputing elements of the list in one line
+    sorted_lst = double_sort(lst)
     print("the sorted list is")
     print(sorted_lst)

From 5fd868c46025509942793e9447f0811de00d56e8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Matheus=20T=2E=20Guimar=C3=A3es?= <matheusguimr@gmail.com>
Date: Tue, 22 Oct 2019 16:19:38 -0300
Subject: [PATCH 301/348] Add algorithm to rotate images (#1420)

* Add algorithm to rotate image

* Edit function to be compliant in Black and Flake8 formats

* Add type hints in get_rotation() and  enumerate() in loop
---
 digital_image_processing/rotation/__init__.py |  0
 digital_image_processing/rotation/rotation.py | 52 +++++++++++++++++++
 2 files changed, 52 insertions(+)
 create mode 100644 digital_image_processing/rotation/__init__.py
 create mode 100644 digital_image_processing/rotation/rotation.py

diff --git a/digital_image_processing/rotation/__init__.py b/digital_image_processing/rotation/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/digital_image_processing/rotation/rotation.py b/digital_image_processing/rotation/rotation.py
new file mode 100644
index 000000000000..37b45ca39897
--- /dev/null
+++ b/digital_image_processing/rotation/rotation.py
@@ -0,0 +1,52 @@
+from matplotlib import pyplot as plt
+import numpy as np
+import cv2
+
+
+def get_rotation(
+    img: np.array, pt1: np.float32, pt2: np.float32, rows: int, cols: int
+) -> np.array:
+    """
+    Get image rotation
+    :param img: np.array
+    :param pt1: 3x2 list
+    :param pt2: 3x2 list
+    :param rows: columns image shape
+    :param cols: rows image shape
+    :return: np.array
+    """
+    matrix = cv2.getAffineTransform(pt1, pt2)
+    return cv2.warpAffine(img, matrix, (rows, cols))
+
+
+if __name__ == "__main__":
+    # read original image
+    image = cv2.imread("lena.jpg")
+    # turn image in gray scale value
+    gray_img = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    # get image shape
+    img_rows, img_cols = gray_img.shape
+
+    # set different points to rotate image
+    pts1 = np.float32([[50, 50], [200, 50], [50, 200]])
+    pts2 = np.float32([[10, 100], [200, 50], [100, 250]])
+    pts3 = np.float32([[50, 50], [150, 50], [120, 200]])
+    pts4 = np.float32([[10, 100], [80, 50], [180, 250]])
+
+    # add all rotated images in a list
+    images = [
+        gray_img,
+        get_rotation(gray_img, pts1, pts2, img_rows, img_cols),
+        get_rotation(gray_img, pts2, pts3, img_rows, img_cols),
+        get_rotation(gray_img, pts2, pts4, img_rows, img_cols),
+    ]
+
+    # plot different image rotations
+    fig = plt.figure(1)
+    titles = ["Original", "Rotation 1", "Rotation 2", "Rotation 3"]
+    for i, image in enumerate(images):
+        plt.subplot(2, 2, i + 1), plt.imshow(image, "gray")
+        plt.title(titles[i])
+        plt.axis("off")
+        plt.subplots_adjust(left=0.0, bottom=0.05, right=1.0, top=0.95)
+    plt.show()

From 56830255ca30b063a300439d8bc070399bc0ed01 Mon Sep 17 00:00:00 2001
From: John Law <johnlaw.po@gmail.com>
Date: Wed, 23 Oct 2019 04:07:50 +0800
Subject: [PATCH 302/348] Readability of CONTRIBUTING.md (#1422)

* Readability of guidelines

* Update README.md
---
 CONTRIBUTING.md | 69 +++++++++++++++++++++++++++----------------------
 README.md       | 12 ++++++---
 2 files changed, 47 insertions(+), 34 deletions(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 6dd2f6c6ff78..ce2f03886e01 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -30,25 +30,32 @@ Your contribution will be tested by our [automated testing on Travis CI](https:/
 We want your work to be readable by others; therefore, we encourage you to note the following:
 
 - Please write in Python 3.7+.  __print()__ is a function in Python 3 so __print "Hello"__ will _not_ work but __print("Hello")__ will.
-
 - Please focus hard on naming of functions, classes, and variables.  Help your reader by using __descriptive names__ that can help you to remove redundant comments.
-    - Single letter variable names are _old school_ so please avoid them unless their life only spans a few lines.
-    - Expand acronyms because __gcd()__ is hard to understand but __greatest_common_divisor()__ is not.
-    - Please follow the [Python Naming Conventions](https://pep8.org/#prescriptive-naming-conventions) so variable_names and function_names should be lower_case, CONSTANTS in UPPERCASE, ClassNames should be CamelCase, etc.
+  - Single letter variable names are _old school_ so please avoid them unless their life only spans a few lines.
+  - Expand acronyms because __gcd()__ is hard to understand but __greatest_common_divisor()__ is not.
+  - Please follow the [Python Naming Conventions](https://pep8.org/#prescriptive-naming-conventions) so variable_names and function_names should be lower_case, CONSTANTS in UPPERCASE, ClassNames should be CamelCase, etc.
+
+
 
 - We encourage the use of Python [f-strings](https://realpython.com/python-f-strings/#f-strings-a-new-and-improved-way-to-format-strings-in-python) where the make the code easier to read.
 
-- Please consider running [__psf/black__](https://github.com/python/black) on your Python file(s) before submitting your pull request.  This is not yet a requirement but it does make your code more readable and automatically aligns it with much of [PEP 8](https://www.python.org/dev/peps/pep-0008/).  There are other code formatters (autopep8, yapf) but the __black__ style is now the recommendation of the Python Core Team. To use it,
-    ```bash
-    pip3 install black  # only required the first time
-    black .
-    ```
+
+
+- Please consider running [__psf/black__](https://github.com/python/black) on your Python file(s) before submitting your pull request.  This is not yet a requirement but it does make your code more readable and automatically aligns it with much of [PEP 8](https://www.python.org/dev/peps/pep-0008/). There are other code formatters (autopep8, yapf) but the __black__ style is now the recommendation of the Python Core Team. To use it,
+
+  ```bash
+  pip3 install black  # only required the first time
+  black .
+  ```
 
 - All submissions will need to pass the test __flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics__ before they will be accepted so if possible, try this test locally on your Python file(s) before submitting your pull request.
-    ```bash
-    pip3 install flake8  # only required the first time
-    flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
-    ```
+
+  ```bash
+  pip3 install flake8  # only required the first time
+  flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
+  ```
+
+
 
 - Original code submission require docstrings or comments to describe your work.
 
@@ -93,9 +100,10 @@ We want your work to be readable by others; therefore, we encourage you to note
   ```
 
   These doctests will be run by pytest as part of our automated testing so please try to run your doctests locally and make sure that they are found and pass:
-    ```bash
-    python3 -m doctest -v my_submission.py
-    ```
+
+  ```bash
+  python3 -m doctest -v my_submission.py
+  ```
 
   The use of the Python builtin __input()__ function is **not** encouraged:
 
@@ -110,44 +118,43 @@ We want your work to be readable by others; therefore, we encourage you to note
   ```python
   starting_value = int(input("Please enter a starting value: ").strip())
   ```
-  
+
   The use of [Python type hints](https://docs.python.org/3/library/typing.html) is encouraged for function parameters and return values.  Our automated testing will run [mypy](http://mypy-lang.org) so run that locally before making your submission.
-```python
-def sumab(a: int, b: int) --> int:
+
+  ```python
+  def sumab(a: int, b: int) --> int:
     pass
   ```
 
-- [__list comprehensions and generators__](https://docs.python.org/3/tutorial/datastructures.html#list-comprehensions) are preferred over the use of `lambda`, `map`, `filter`, `reduce` but the important thing is to demonstrate the power of Python in code that is easy to read and maintain.
 
-- Avoid importing external libraries for basic algorithms. Only use those libraries for complicated algorithms.
 
+- [__List comprehensions and generators__](https://docs.python.org/3/tutorial/datastructures.html#list-comprehensions) are preferred over the use of `lambda`, `map`, `filter`, `reduce` but the important thing is to demonstrate the power of Python in code that is easy to read and maintain.
+
+
+
+- Avoid importing external libraries for basic algorithms. Only use those libraries for complicated algorithms.
 - If you need a third party module that is not in the file __requirements.txt__, please add it to that file as part of your submission.
 
 #### Other Standard While Submitting Your Work
 
 - File extension for code should be `.py`. Jupiter notebook files are acceptable in machine learning algorithms.
-
-- Please avoid creating new directories if at all possible.  Try to fit your work into the existing directory structue.
-
 - Strictly use snake_case (underscore_separated) in your file_name, as it will be easy to parse in future using scripts.
+- Please avoid creating new directories if at all possible. Try to fit your work into the existing directory structure.
+- If possible, follow the standard *within* the folder you are submitting to.
 
-  If possible, follow the standard *within* the folder you are submitting to.
 
-- If you have modified/added code work, make sure the code compiles before submitting.
 
+- If you have modified/added code work, make sure the code compiles before submitting.
 - If you have modified/added documentation work, ensure your language is concise and contains no grammar errors.
-
 - Do not update the README.md or DIRECTORY.md file which will be periodically autogenerated by our Travis CI processes.
-
 - Add a corresponding explanation to [Algorithms-Explanation](https://github.com/TheAlgorithms/Algorithms-Explanation) (Optional but recommended).
-
 - All submissions will be tested with [__mypy__](http://www.mypy-lang.org) so we encourage to add [__Python type hints__](https://docs.python.org/3/library/typing.html) where it makes sense to do so.
 
-- Most importantly,
 
+
+- Most importantly,
   - **Be consistent in the use of these guidelines when submitting.**
   - **Join** [Gitter](https://gitter.im/TheAlgorithms) **now!**
   - Happy coding!
 
-
 Writer [@poyea](https://github.com/poyea), Jun 2019.
diff --git a/README.md b/README.md
index 8ccb789be7e9..51b2cf8c854c 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,5 @@
 # The Algorithms - Python
+
 [![Donate](https://img.shields.io/badge/Donate-PayPal-green.svg?logo=paypal&style=flat-square)](https://www.paypal.me/TheAlgorithms/100)&nbsp;
 [![Build Status](https://img.shields.io/travis/TheAlgorithms/Python.svg?label=Travis%20CI&logo=travis&style=flat-square)](https://travis-ci.com/TheAlgorithms/Python)&nbsp;
 [![LGTM](https://img.shields.io/lgtm/alerts/github/TheAlgorithms/Python.svg?label=LGTM&logo=LGTM&style=flat-square)](https://lgtm.com/projects/g/TheAlgorithms/Python/alerts)&nbsp;
@@ -6,6 +7,7 @@
 [![contributions welcome](https://img.shields.io/static/v1.svg?label=Contributions&message=Welcome&color=0059b3&style=flat-square)](https://github.com/TheAlgorithms/Python/blob/master/CONTRIBUTING.md)&nbsp;
 ![](https://img.shields.io/github/repo-size/TheAlgorithms/Python.svg?label=Repo%20size&style=flat-square)&nbsp;
 <!--[![Tested on Python 3.7](https://img.shields.io/badge/Tested%20-Python%203.7-blue.svg?logo=python&style=flat-square)]( https://www.python.org/downloads) &nbsp;-->
+
 ### All algorithms implemented in Python (for education)
 
 These implementations are for learning purposes. They may be less efficient than the implementations in the Python standard library.
@@ -14,12 +16,16 @@ These implementations are for learning purposes. They may be less efficient than
 
 Read our [Contribution Guidelines](CONTRIBUTING.md) before you contribute.
 
-[![Open in Gitpod](https://gitpod.io/button/open-in-gitpod.svg?style=flat-square)](https://gitpod.io/#https://github.com/TheAlgorithms/Python)
-
 ## Community Channel
 
 We're on [Gitter](https://gitter.im/TheAlgorithms)! Please join us.
 
-## Algorithms
+## List of Algorithms
 
 See our [directory](DIRECTORY.md).
+
+
+
+
+
+[![Open in Gitpod](https://gitpod.io/button/open-in-gitpod.svg?style=flat-square)](https://gitpod.io/#https://github.com/TheAlgorithms/Python)

From d477a4ddf2afa0b954f4d283bd73cdfdc44853d7 Mon Sep 17 00:00:00 2001
From: Ankur Chattopadhyay <39518771+chttrjeankr@users.noreply.github.com>
Date: Wed, 23 Oct 2019 23:50:38 +0530
Subject: [PATCH 303/348] introduced shuffled_shift_cipher.py in /ciphers
 (#1424)

* introduced shuffled_shift_cipher.py in /ciphers

* made requested changes

* introduced doctests, type hints
removed __make_one_digit()

* test_end_to_end() inserted

* Make test_end_to_end() a test ;-)
---
 ciphers/shuffled_shift_cipher.py | 177 +++++++++++++++++++++++++++++++
 1 file changed, 177 insertions(+)
 create mode 100644 ciphers/shuffled_shift_cipher.py

diff --git a/ciphers/shuffled_shift_cipher.py b/ciphers/shuffled_shift_cipher.py
new file mode 100644
index 000000000000..bbefe3305fa7
--- /dev/null
+++ b/ciphers/shuffled_shift_cipher.py
@@ -0,0 +1,177 @@
+import random
+import string
+
+
+class ShuffledShiftCipher(object):
+    """
+    This algorithm uses the Caesar Cipher algorithm but removes the option to
+    use brute force to decrypt the message.
+
+    The passcode is a a random password from the selection buffer of
+    1. uppercase letters of the English alphabet
+    2. lowercase letters of the English alphabet
+    3. digits from 0 to 9
+
+    Using unique characters from the passcode, the normal list of characters,
+    that can be allowed in the plaintext, is pivoted and shuffled. Refer to docstring
+    of __make_key_list() to learn more about the shuffling.
+
+    Then, using the passcode, a number is calculated which is used to encrypt the
+    plaintext message with the normal shift cipher method, only in this case, the
+    reference, to look back at while decrypting, is shuffled.
+
+    Each cipher object can possess an optional argument as passcode, without which a
+    new passcode is generated for that object automatically.
+    cip1 = ShuffledShiftCipher('d4usr9TWxw9wMD')
+    cip2 = ShuffledShiftCipher()
+    """
+
+    def __init__(self, passcode: str = None):
+        """
+        Initializes a cipher object with a passcode as it's entity
+        Note: No new passcode is generated if user provides a passcode
+        while creating the object
+        """
+        self.__passcode = passcode or self.__passcode_creator()
+        self.__key_list = self.__make_key_list()
+        self.__shift_key = self.__make_shift_key()
+
+    def __str__(self):
+        """
+        :return: passcode of the cipher object
+        """
+        return "Passcode is: " + "".join(self.__passcode)
+
+    def __neg_pos(self, iterlist: list) -> list:
+        """
+        Mutates the list by changing the sign of each alternate element
+
+        :param iterlist: takes a list iterable
+        :return: the mutated list
+
+        """
+        for i in range(1, len(iterlist), 2):
+            iterlist[i] *= -1
+        return iterlist
+
+    def __passcode_creator(self) -> list:
+        """
+        Creates a random password from the selection buffer of
+        1. uppercase letters of the English alphabet
+        2. lowercase letters of the English alphabet
+        3. digits from 0 to 9
+
+        :rtype: list
+        :return: a password of a random length between 10 to 20
+        """
+        choices = string.ascii_letters + string.digits
+        password = [random.choice(choices) for i in range(random.randint(10, 20))]
+        return password
+
+    def __make_key_list(self) -> list:
+        """
+        Shuffles the ordered character choices by pivoting at breakpoints
+        Breakpoints are the set of characters in the passcode
+
+        eg:
+            if, ABCDEFGHIJKLMNOPQRSTUVWXYZ are the possible characters
+            and CAMERA is the passcode
+            then, breakpoints = [A,C,E,M,R] # sorted set of characters from passcode
+            shuffled parts: [A,CB,ED,MLKJIHGF,RQPON,ZYXWVUTS]
+            shuffled __key_list : ACBEDMLKJIHGFRQPONZYXWVUTS
+
+        Shuffling only 26 letters of the english alphabet can generate 26!
+        combinations for the shuffled list. In the program we consider, a set of
+        97 characters (including letters, digits, punctuation and whitespaces),
+        thereby creating a possibility of 97! combinations (which is a 152 digit number in itself),
+        thus diminishing the possibility of a brute force approach. Moreover,
+        shift keys even introduce a multiple of 26 for a brute force approach
+        for each of the already 97! combinations.
+        """
+        # key_list_options contain nearly all printable except few elements from string.whitespace
+        key_list_options = (
+            string.ascii_letters + string.digits + string.punctuation + " \t\n"
+        )
+
+        keys_l = []
+
+        # creates points known as breakpoints to break the key_list_options at those points and pivot each substring
+        breakpoints = sorted(set(self.__passcode))
+        temp_list = []
+
+        # algorithm for creating a new shuffled list, keys_l, out of key_list_options
+        for i in key_list_options:
+            temp_list.extend(i)
+
+            # checking breakpoints at which to pivot temporary sublist and add it into keys_l
+            if i in breakpoints or i == key_list_options[-1]:
+                keys_l.extend(temp_list[::-1])
+                temp_list = []
+
+        # returning a shuffled keys_l to prevent brute force guessing of shift key
+        return keys_l
+
+    def __make_shift_key(self) -> int:
+        """
+        sum() of the mutated list of ascii values of all characters where the
+        mutated list is the one returned by __neg_pos()
+        """
+        num = sum(self.__neg_pos([ord(x) for x in self.__passcode]))
+        return num if num > 0 else len(self.__passcode)
+
+    def decrypt(self, encoded_message: str) -> str:
+        """
+        Performs shifting of the encoded_message w.r.t. the shuffled __key_list
+        to create the decoded_message
+
+        >>> ssc = ShuffledShiftCipher('4PYIXyqeQZr44')
+        >>> ssc.decrypt("d>**-1z6&'5z'5z:z+-='$'>=zp:>5:#z<'.&>#")
+        'Hello, this is a modified Caesar cipher'
+
+        """
+        decoded_message = ""
+
+        # decoding shift like Caesar cipher algorithm implementing negative shift or reverse shift or left shift
+        for i in encoded_message:
+            position = self.__key_list.index(i)
+            decoded_message += self.__key_list[
+                (position - self.__shift_key) % -len(self.__key_list)
+            ]
+
+        return decoded_message
+
+    def encrypt(self, plaintext: str) -> str:
+        """
+        Performs shifting of the plaintext w.r.t. the shuffled __key_list
+        to create the encoded_message
+
+        >>> ssc = ShuffledShiftCipher('4PYIXyqeQZr44')
+        >>> ssc.encrypt('Hello, this is a modified Caesar cipher')
+        "d>**-1z6&'5z'5z:z+-='$'>=zp:>5:#z<'.&>#"
+
+        """
+        encoded_message = ""
+
+        # encoding shift like Caesar cipher algorithm implementing positive shift or forward shift or right shift
+        for i in plaintext:
+            position = self.__key_list.index(i)
+            encoded_message += self.__key_list[
+                (position + self.__shift_key) % len(self.__key_list)
+            ]
+
+        return encoded_message
+
+
+def test_end_to_end(msg: str = "Hello, this is a modified Caesar cipher"):
+    """
+    >>> test_end_to_end()
+    'Hello, this is a modified Caesar cipher'
+    """
+    cip1 = ShuffledShiftCipher()
+    return cip1.decrypt(cip1.encrypt(msg))
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()

From 7b3d385ad62a74b7e984c9b5424006566e4f848d Mon Sep 17 00:00:00 2001
From: praisearts <34782930+praisearts@users.noreply.github.com>
Date: Thu, 24 Oct 2019 09:31:58 +0100
Subject: [PATCH 304/348] create simple binary search (#1430)

* create simnple binary search

#A binary search implementation to test if a number is in a list of elements

* Add .py, format with psf/black, and add doctests
---
 searches/simple-binary-search.py | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 searches/simple-binary-search.py

diff --git a/searches/simple-binary-search.py b/searches/simple-binary-search.py
new file mode 100644
index 000000000000..80e43ea346b2
--- /dev/null
+++ b/searches/simple-binary-search.py
@@ -0,0 +1,26 @@
+# A binary search implementation to test if a number is in a list of elements
+
+
+def binary_search(a_list, item):
+    """
+    >>> test_list = [0, 1, 2, 8, 13, 17, 19, 32, 42]
+    >>> print(binary_search(test_list, 3))
+    False
+    >>> print(binary_search(test_list, 13))
+    True
+    """
+    if len(a_list) == 0:
+        return False
+    midpoint = len(a_list) // 2
+    if a_list[midpoint] == item:
+        return True
+    if item < a_list[midpoint]:
+        return binary_search(a_list[:midpoint], item)
+    else:
+        return binary_search(a_list[midpoint + 1 :], item)
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()

From 07483139d14214adaebbd58ee22fd6bb552e1a00 Mon Sep 17 00:00:00 2001
From: Alex Veltman <alexveltman0@gmail.com>
Date: Thu, 24 Oct 2019 11:08:45 +0200
Subject: [PATCH 305/348] Added determinate function (#1429)

* Added determinate function

* Changed determinate function name

* Changed instance of .det() to .determinate()

* Added force_test() function

* Update tests.py
---
 linear_algebra/README.md    |  3 ++-
 linear_algebra/src/lib.py   | 27 +++++++++++++++++++++++++++
 linear_algebra/src/tests.py | 16 +++++++++++++++-
 3 files changed, 44 insertions(+), 2 deletions(-)

diff --git a/linear_algebra/README.md b/linear_algebra/README.md
index f1b554e139de..169cd074d396 100644
--- a/linear_algebra/README.md
+++ b/linear_algebra/README.md
@@ -45,7 +45,8 @@ This module contains some useful classes and functions for dealing with linear a
     - changeComponent(x,y,value) : changes the specified component.  
     - component(x,y) : returns the specified component.  
     - width() : returns the width of the matrix  
-    - height() : returns the height of the matrix  
+    - height() : returns the height of the matrix
+    - determinate() : returns the determinate of the matrix if it is square 
     - operator + : implements the matrix-addition.  
     - operator - _ implements the matrix-subtraction  
 
diff --git a/linear_algebra/src/lib.py b/linear_algebra/src/lib.py
index bf9e0d302a89..2f7a1775371f 100644
--- a/linear_algebra/src/lib.py
+++ b/linear_algebra/src/lib.py
@@ -277,6 +277,33 @@ def height(self):
         """
         return self.__height
 
+    def determinate(self) -> float:
+        """
+            returns the determinate of an nxn matrix using Laplace expansion
+        """
+        if self.__height == self.__width and self.__width >= 2:
+            total = 0
+            if self.__width > 2:
+                for x in range(0, self.__width):
+                    for y in range(0, self.__height):
+                        total += (
+                            self.__matrix[x][y]
+                            * (-1) ** (x + y)
+                            * Matrix(
+                                self.__matrix[0:x] + self.__matrix[x + 1 :],
+                                self.__width - 1,
+                                self.__height - 1,
+                            ).determinate()
+                        )
+            else:
+                return (
+                    self.__matrix[0][0] * self.__matrix[1][1]
+                    - self.__matrix[0][1] * self.__matrix[1][0]
+                )
+            return total
+        else:
+            raise Exception("matrix is not square")
+
     def __mul__(self, other):
         """
             implements the matrix-vector multiplication.
diff --git a/linear_algebra/src/tests.py b/linear_algebra/src/tests.py
index b63f2ae8c2db..4123a7c9e663 100644
--- a/linear_algebra/src/tests.py
+++ b/linear_algebra/src/tests.py
@@ -118,6 +118,13 @@ def test_str_matrix(self):
         A = Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]], 3, 3)
         self.assertEqual("|1,2,3|\n|2,4,5|\n|6,7,8|\n", str(A))
 
+    def test_determinate(self):
+        """
+            test for determinate()
+        """
+        A = Matrix([[1, 1, 4, 5], [3, 3, 3, 2], [5, 1, 9, 0], [9, 7, 7, 9]], 4, 4)
+        self.assertEqual(-376, A.determinate())
+
     def test__mul__matrix(self):
         A = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]], 3, 3)
         x = Vector([1, 2, 3])
@@ -149,6 +156,13 @@ def test_squareZeroMatrix(self):
             str(squareZeroMatrix(5)),
         )
 
-
+def force_test() -> None:
+    """
+    This will ensure that pytest runs the unit tests above.
+    To explore https://github.com/TheAlgorithms/Python/pull/1124 uncomment the line below.
+    >>> # unittest.main()
+    """
+    pass
+    
 if __name__ == "__main__":
     unittest.main()

From ec85cc81915cda82cec22e6ed9a4177b6dc1103e Mon Sep 17 00:00:00 2001
From: Alex Veltman <alexveltman0@gmail.com>
Date: Thu, 24 Oct 2019 12:39:51 +0200
Subject: [PATCH 306/348] Fixes in methods and tests in Linear Algebra (#1432)

* Fixes in methods and tests

* Renamed tests.py to test_linear_algebra.py

* removed force_test()

* Delete test_linear_algebra.py

* Format code with psf/black

* Rename tests.py to test_linear_algebra.py
---
 linear_algebra/src/lib.py                             |  4 ++--
 .../src/{tests.py => test_linear_algebra.py}          | 11 ++---------
 2 files changed, 4 insertions(+), 11 deletions(-)
 rename linear_algebra/src/{tests.py => test_linear_algebra.py} (94%)

diff --git a/linear_algebra/src/lib.py b/linear_algebra/src/lib.py
index 2f7a1775371f..15d176cc6392 100644
--- a/linear_algebra/src/lib.py
+++ b/linear_algebra/src/lib.py
@@ -119,7 +119,7 @@ def __sub__(self, other):
         size = len(self)
         if size == len(other):
             result = [self.__components[i] - other.component(i) for i in range(size)]
-            return result
+            return Vector(result)
         else:  # error case
             raise Exception("must have the same size")
 
@@ -130,7 +130,7 @@ def __mul__(self, other):
         """
         if isinstance(other, float) or isinstance(other, int):
             ans = [c * other for c in self.__components]
-            return ans
+            return Vector(ans)
         elif isinstance(other, Vector) and (len(self) == len(other)):
             size = len(self)
             summe = 0
diff --git a/linear_algebra/src/tests.py b/linear_algebra/src/test_linear_algebra.py
similarity index 94%
rename from linear_algebra/src/tests.py
rename to linear_algebra/src/test_linear_algebra.py
index 4123a7c9e663..f8e7db7de6cc 100644
--- a/linear_algebra/src/tests.py
+++ b/linear_algebra/src/test_linear_algebra.py
@@ -45,7 +45,7 @@ def test_euclidLength(self):
             test for the eulidean length
         """
         x = Vector([1, 2])
-        self.assertAlmostEqual(x.eulidLength(), 2.236, 3)
+        self.assertAlmostEqual(x.euclidLength(), 2.236, 3)
 
     def test_add(self):
         """
@@ -156,13 +156,6 @@ def test_squareZeroMatrix(self):
             str(squareZeroMatrix(5)),
         )
 
-def force_test() -> None:
-    """
-    This will ensure that pytest runs the unit tests above.
-    To explore https://github.com/TheAlgorithms/Python/pull/1124 uncomment the line below.
-    >>> # unittest.main()
-    """
-    pass
-    
+
 if __name__ == "__main__":
     unittest.main()

From 03e9a75d69538649df3e05d40a1c8e7d870fd807 Mon Sep 17 00:00:00 2001
From: Isaac Gomes de Oliveira <isaacgdoliveira@gmail.com>
Date: Fri, 25 Oct 2019 00:56:56 -0300
Subject: [PATCH 307/348] Add gaussian_elimination.py for solving linear
 systems (#1448)

---
 arithmetic_analysis/gaussian_elimination.py | 83 +++++++++++++++++++++
 1 file changed, 83 insertions(+)
 create mode 100644 arithmetic_analysis/gaussian_elimination.py

diff --git a/arithmetic_analysis/gaussian_elimination.py b/arithmetic_analysis/gaussian_elimination.py
new file mode 100644
index 000000000000..51207686c12a
--- /dev/null
+++ b/arithmetic_analysis/gaussian_elimination.py
@@ -0,0 +1,83 @@
+"""
+Gaussian elimination method for solving a system of linear equations.
+Gaussian elimination - https://en.wikipedia.org/wiki/Gaussian_elimination
+"""
+
+
+import numpy as np
+
+
+def retroactive_resolution(coefficients: np.matrix, vector: np.array) -> np.array:
+    """
+    This function performs a retroactive linear system resolution
+        for triangular matrix
+
+    Examples:
+        2x1 + 2x2 - 1x3 = 5         2x1 + 2x2 = -1
+        0x1 - 2x2 - 1x3 = -7        0x1 - 2x2 = -1
+        0x1 + 0x2 + 5x3 = 15
+    >>> gaussian_elimination([[2, 2, -1], [0, -2, -1], [0, 0, 5]], [[5], [-7], [15]])
+    array([[2.],
+           [2.],
+           [3.]])
+    >>> gaussian_elimination([[2, 2], [0, -2]], [[-1], [-1]])
+    array([[-1. ],
+           [ 0.5]])
+    """
+
+    rows, columns = np.shape(coefficients)
+
+    x = np.zeros((rows, 1), dtype=float)
+    for row in reversed(range(rows)):
+        sum = 0
+        for col in range(row + 1, columns):
+            sum += coefficients[row, col] * x[col]
+
+        x[row, 0] = (vector[row] - sum) / coefficients[row, row]
+
+    return x
+
+
+def gaussian_elimination(coefficients: np.matrix, vector: np.array) -> np.array:
+    """
+    This function performs Gaussian elimination method
+
+    Examples:
+        1x1 - 4x2 - 2x3 = -2        1x1 + 2x2 = 5
+        5x1 + 2x2 - 2x3 = -3        5x1 + 2x2 = 5
+        1x1 - 1x2 + 0x3 = 4
+    >>> gaussian_elimination([[1, -4, -2], [5, 2, -2], [1, -1, 0]], [[-2], [-3], [4]])
+    array([[ 2.3 ],
+           [-1.7 ],
+           [ 5.55]])
+    >>> gaussian_elimination([[1, 2], [5, 2]], [[5], [5]])
+    array([[0. ],
+           [2.5]])
+    """
+    # coefficients must to be a square matrix so we need to check first
+    rows, columns = np.shape(coefficients)
+    if rows != columns:
+        return []
+
+    # augmented matrix
+    augmented_mat = np.concatenate((coefficients, vector), axis=1)
+    augmented_mat = augmented_mat.astype("float64")
+
+    # scale the matrix leaving it triangular
+    for row in range(rows - 1):
+        pivot = augmented_mat[row, row]
+        for col in range(row + 1, columns):
+            factor = augmented_mat[col, row] / pivot
+            augmented_mat[col, :] -= factor * augmented_mat[row, :]
+
+    x = retroactive_resolution(
+        augmented_mat[:, 0:columns], augmented_mat[:, columns : columns + 1]
+    )
+
+    return x
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()

From a2a3ca674f908c29499b78592339d10c44ec8da2 Mon Sep 17 00:00:00 2001
From: Samarth Sehgal <samarthsehgal97@gmail.com>
Date: Fri, 25 Oct 2019 21:26:27 +0530
Subject: [PATCH 308/348] Update treap.py (#1455)

---
 data_structures/binary_tree/treap.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/data_structures/binary_tree/treap.py b/data_structures/binary_tree/treap.py
index a6ff3c9d798b..b603eec3ef3c 100644
--- a/data_structures/binary_tree/treap.py
+++ b/data_structures/binary_tree/treap.py
@@ -172,7 +172,7 @@ def main():
         args = input()
 
     print("good by!")
-    pass
+    
 
 
 if __name__ == "__main__":

From 182062d60be1ea6695d22c196ea039bda29a9311 Mon Sep 17 00:00:00 2001
From: bizzfitch <56891892+bizzfitch@users.noreply.github.com>
Date: Fri, 25 Oct 2019 13:04:06 -0400
Subject: [PATCH 309/348] Adding deterministic miller rabin primality test
 (#1453)

* Adding deterministic miller rabin primality test

* Moved to ciphers directory and renamed for clarity. Changed docstring to add test
---
 ciphers/deterministic_miller_rabin.py | 135 ++++++++++++++++++++++++++
 1 file changed, 135 insertions(+)
 create mode 100644 ciphers/deterministic_miller_rabin.py

diff --git a/ciphers/deterministic_miller_rabin.py b/ciphers/deterministic_miller_rabin.py
new file mode 100644
index 000000000000..37845d6c9b41
--- /dev/null
+++ b/ciphers/deterministic_miller_rabin.py
@@ -0,0 +1,135 @@
+"""Created by Nathan Damon, @bizzfitch on github
+>>> test_miller_rabin()
+"""
+
+
+def miller_rabin(n, allow_probable=False):
+    """Deterministic Miller-Rabin algorithm for primes ~< 3.32e24.
+
+    Uses numerical analysis results to return whether or not the passed number
+    is prime. If the passed number is above the upper limit, and
+    allow_probable is True, then a return value of True indicates that n is
+    probably prime. This test does not allow False negatives- a return value
+    of False is ALWAYS composite.
+
+    Parameters
+    ----------
+    n : int
+        The integer to be tested. Since we usually care if a number is prime,
+        n < 2 returns False instead of raising a ValueError.
+    allow_probable: bool, default False
+        Whether or not to test n above the upper bound of the deterministic test.
+
+    Raises
+    ------
+    ValueError
+
+    Reference
+    ---------
+    https://en.wikipedia.org/wiki/Miller%E2%80%93Rabin_primality_test
+    """
+    if n == 2:
+        return True
+    if not n % 2 or n < 2:
+        return False
+    if n > 5 and n % 10 not in (1, 3, 7, 9):  # can quickly check last digit
+        return False
+    if n > 3_317_044_064_679_887_385_961_981 and not allow_probable:
+        raise ValueError(
+            "Warning: upper bound of deterministic test is exceeded. "
+            "Pass allow_probable=True to allow probabilistic test. "
+            "A return value of True indicates a probable prime."
+        )
+    # array bounds provided by analysis
+    bounds = [2_047,
+              1_373_653,
+              25_326_001,
+              3_215_031_751,
+              2_152_302_898_747,
+              3_474_749_660_383,
+              341_550_071_728_321,
+              1,
+              3_825_123_056_546_413_051,
+              1,
+              1,
+              318_665_857_834_031_151_167_461,
+              3_317_044_064_679_887_385_961_981]
+
+    primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41]
+    for idx, _p in enumerate(bounds, 1):
+        if n < _p:
+            # then we have our last prime to check
+            plist = primes[:idx]
+            break
+    d, s = n - 1, 0
+    # break up n -1 into a power of 2 (s) and
+    # remaining odd component
+    # essentially, solve for d * 2 ** s == n - 1
+    while d % 2 == 0:
+        d //= 2
+        s += 1
+    for prime in plist:
+        pr = False
+        for r in range(s):
+            m = pow(prime, d * 2 ** r, n)
+            # see article for analysis explanation for m
+            if (r == 0 and m == 1) or ((m + 1) % n == 0):
+                pr = True
+                # this loop will not determine compositeness
+                break
+        if pr:
+            continue
+        # if pr is False, then the above loop never evaluated to true,
+        # and the n MUST be composite
+        return False
+    return True
+
+
+def test_miller_rabin():
+    """Testing a nontrivial (ends in 1, 3, 7, 9) composite
+    and a prime in each range.
+    """
+    assert not miller_rabin(561)
+    assert miller_rabin(563)
+    # 2047
+
+    assert not miller_rabin(838_201)
+    assert miller_rabin(838_207)
+    # 1_373_653
+
+    assert not miller_rabin(17_316_001)
+    assert miller_rabin(17_316_017)
+    # 25_326_001
+
+    assert not miller_rabin(3_078_386_641)
+    assert miller_rabin(3_078_386_653)
+    # 3_215_031_751
+
+    assert not miller_rabin(1_713_045_574_801)
+    assert miller_rabin(1_713_045_574_819)
+    # 2_152_302_898_747
+
+    assert not miller_rabin(2_779_799_728_307)
+    assert miller_rabin(2_779_799_728_327)
+    # 3_474_749_660_383
+
+    assert not miller_rabin(113_850_023_909_441)
+    assert miller_rabin(113_850_023_909_527)
+    # 341_550_071_728_321
+
+    assert not miller_rabin(1_275_041_018_848_804_351)
+    assert miller_rabin(1_275_041_018_848_804_391)
+    # 3_825_123_056_546_413_051
+
+    assert not miller_rabin(79_666_464_458_507_787_791_867)
+    assert miller_rabin(79_666_464_458_507_787_791_951)
+    # 318_665_857_834_031_151_167_461
+
+    assert not miller_rabin(552_840_677_446_647_897_660_333)
+    assert miller_rabin(552_840_677_446_647_897_660_359)
+    # 3_317_044_064_679_887_385_961_981
+    # upper limit for probabilistic test
+
+
+if __name__ == '__main__':
+    test_miller_rabin()

From 3ea0992dc70e45d17d7f354b101ef3f4ea216bff Mon Sep 17 00:00:00 2001
From: Samarth Sehgal <samarthsehgal97@gmail.com>
Date: Fri, 25 Oct 2019 22:35:23 +0530
Subject: [PATCH 310/348] Update aho-corasick.py (#1457)

---
 strings/aho-corasick.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/strings/aho-corasick.py b/strings/aho-corasick.py
index 6790892a358d..b2f89450ee7a 100644
--- a/strings/aho-corasick.py
+++ b/strings/aho-corasick.py
@@ -54,7 +54,7 @@ def set_fail_transitions(self):
                 self.adlist[child]["fail_state"] = self.find_next_state(
                     state, self.adlist[child]["value"]
                 )
-                if self.adlist[child]["fail_state"] == None:
+                if self.adlist[child]["fail_state"] is None:
                     self.adlist[child]["fail_state"] = 0
                 self.adlist[child]["output"] = (
                     self.adlist[child]["output"]
@@ -71,7 +71,7 @@ def search_in(self, string):
         current_state = 0
         for i in range(len(string)):
             while (
-                self.find_next_state(current_state, string[i]) == None
+                self.find_next_state(current_state, string[i]) is None
                 and current_state != 0
             ):
                 current_state = self.adlist[current_state]["fail_state"]

From a61b05b10ca843282b5497ac9367e73906b374b9 Mon Sep 17 00:00:00 2001
From: Ankur Chattopadhyay <39518771+chttrjeankr@users.noreply.github.com>
Date: Fri, 25 Oct 2019 23:03:24 +0530
Subject: [PATCH 311/348] minor changes in format of DIRECTORY.md (#1461)

---
 DIRECTORY.md                  | 853 ++++++++++++++++++----------------
 scripts/build_directory_md.py |   4 +-
 2 files changed, 447 insertions(+), 410 deletions(-)

diff --git a/DIRECTORY.md b/DIRECTORY.md
index a4838d24dab7..e2d74d39828f 100644
--- a/DIRECTORY.md
+++ b/DIRECTORY.md
@@ -1,459 +1,496 @@
-## Arithmetic Analysis
 
-- [bisection](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/bisection.py)
-- [in static equilibrium](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/in_static_equilibrium.py)
-- [intersection](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/intersection.py)
-- [lu decomposition](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/lu_decomposition.py)
-- [newton method](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/newton_method.py)
-- [newton raphson method](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/newton_raphson_method.py)
+## Arithmetic Analysis
+  * [Bisection](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/bisection.py)
+  * [Gaussian Elimination](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/gaussian_elimination.py)
+  * [In Static Equilibrium](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/in_static_equilibrium.py)
+  * [Intersection](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/intersection.py)
+  * [Lu Decomposition](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/lu_decomposition.py)
+  * [Newton Forward Interpolation](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/newton_forward_interpolation.py)
+  * [Newton Method](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/newton_method.py)
+  * [Newton Raphson Method](https://github.com/TheAlgorithms/Python/blob/master/arithmetic_analysis/newton_raphson_method.py)
 
 ## Backtracking
-
-- [all combinations](https://github.com/TheAlgorithms/Python/blob/master/backtracking/all_combinations.py)
-- [all permutations](https://github.com/TheAlgorithms/Python/blob/master/backtracking/all_permutations.py)
-- [all subsequences](https://github.com/TheAlgorithms/Python/blob/master/backtracking/all_subsequences.py)
-- [minimax](https://github.com/TheAlgorithms/Python/blob/master/backtracking/minimax.py)
-- [n queens](https://github.com/TheAlgorithms/Python/blob/master/backtracking/n_queens.py)
-- [sudoku](https://github.com/TheAlgorithms/Python/blob/master/backtracking/sudoku.py)
-- [sum of subsets](https://github.com/TheAlgorithms/Python/blob/master/backtracking/sum_of_subsets.py)
+  * [All Combinations](https://github.com/TheAlgorithms/Python/blob/master/backtracking/all_combinations.py)
+  * [All Permutations](https://github.com/TheAlgorithms/Python/blob/master/backtracking/all_permutations.py)
+  * [All Subsequences](https://github.com/TheAlgorithms/Python/blob/master/backtracking/all_subsequences.py)
+  * [Minimax](https://github.com/TheAlgorithms/Python/blob/master/backtracking/minimax.py)
+  * [N Queens](https://github.com/TheAlgorithms/Python/blob/master/backtracking/n_queens.py)
+  * [Sudoku](https://github.com/TheAlgorithms/Python/blob/master/backtracking/sudoku.py)
+  * [Sum Of Subsets](https://github.com/TheAlgorithms/Python/blob/master/backtracking/sum_of_subsets.py)
+
+## Blockchain
+  * [Chinese Remainder Theorem](https://github.com/TheAlgorithms/Python/blob/master/blockchain/chinese_remainder_theorem.py)
+  * [Diophantine Equation](https://github.com/TheAlgorithms/Python/blob/master/blockchain/diophantine_equation.py)
+  * [Modular Division](https://github.com/TheAlgorithms/Python/blob/master/blockchain/modular_division.py)
 
 ## Boolean Algebra
-
-- [quine mc cluskey](https://github.com/TheAlgorithms/Python/blob/master/boolean_algebra/quine_mc_cluskey.py)
+  * [Quine Mc Cluskey](https://github.com/TheAlgorithms/Python/blob/master/boolean_algebra/quine_mc_cluskey.py)
 
 ## Ciphers
-
-- [affine cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/affine_cipher.py)
-- [atbash](https://github.com/TheAlgorithms/Python/blob/master/ciphers/atbash.py)
-- [base16](https://github.com/TheAlgorithms/Python/blob/master/ciphers/base16.py)
-- [base32](https://github.com/TheAlgorithms/Python/blob/master/ciphers/base32.py)
-- [base64 cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/base64_cipher.py)
-- [base85](https://github.com/TheAlgorithms/Python/blob/master/ciphers/base85.py)
-- [brute force caesar cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/brute_force_caesar_cipher.py)
-- [caesar cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/caesar_cipher.py)
-- [cryptomath module](https://github.com/TheAlgorithms/Python/blob/master/ciphers/cryptomath_module.py)
-- [elgamal key generator](https://github.com/TheAlgorithms/Python/blob/master/ciphers/elgamal_key_generator.py)
-- [hill cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/hill_cipher.py)
-- [morse code implementation](https://github.com/TheAlgorithms/Python/blob/master/ciphers/morse_code_implementation.py)
-- [onepad cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/onepad_cipher.py)
-- [playfair cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/playfair_cipher.py)
-- [rabin miller](https://github.com/TheAlgorithms/Python/blob/master/ciphers/rabin_miller.py)
-- [rot13](https://github.com/TheAlgorithms/Python/blob/master/ciphers/rot13.py)
-- [rsa cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/rsa_cipher.py)
-- [rsa key generator](https://github.com/TheAlgorithms/Python/blob/master/ciphers/rsa_key_generator.py)
-- [simple substitution cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/simple_substitution_cipher.py)
-- [trafid cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/trafid_cipher.py)
-- [transposition cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/transposition_cipher.py)
-- [transposition cipher encrypt decrypt file](https://github.com/TheAlgorithms/Python/blob/master/ciphers/transposition_cipher_encrypt_decrypt_file.py)
-- [vigenere cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/vigenere_cipher.py)
-- [xor cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/xor_cipher.py)
+  * [Affine Cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/affine_cipher.py)
+  * [Atbash](https://github.com/TheAlgorithms/Python/blob/master/ciphers/atbash.py)
+  * [Base16](https://github.com/TheAlgorithms/Python/blob/master/ciphers/base16.py)
+  * [Base32](https://github.com/TheAlgorithms/Python/blob/master/ciphers/base32.py)
+  * [Base64 Cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/base64_cipher.py)
+  * [Base85](https://github.com/TheAlgorithms/Python/blob/master/ciphers/base85.py)
+  * [Brute Force Caesar Cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/brute_force_caesar_cipher.py)
+  * [Caesar Cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/caesar_cipher.py)
+  * [Cryptomath Module](https://github.com/TheAlgorithms/Python/blob/master/ciphers/cryptomath_module.py)
+  * [Elgamal Key Generator](https://github.com/TheAlgorithms/Python/blob/master/ciphers/elgamal_key_generator.py)
+  * [Hill Cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/hill_cipher.py)
+  * [Morse Code Implementation](https://github.com/TheAlgorithms/Python/blob/master/ciphers/morse_code_implementation.py)
+  * [Onepad Cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/onepad_cipher.py)
+  * [Playfair Cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/playfair_cipher.py)
+  * [Rabin Miller](https://github.com/TheAlgorithms/Python/blob/master/ciphers/rabin_miller.py)
+  * [Rot13](https://github.com/TheAlgorithms/Python/blob/master/ciphers/rot13.py)
+  * [Rsa Cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/rsa_cipher.py)
+  * [Rsa Key Generator](https://github.com/TheAlgorithms/Python/blob/master/ciphers/rsa_key_generator.py)
+  * [Shuffled Shift Cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/shuffled_shift_cipher.py)
+  * [Simple Substitution Cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/simple_substitution_cipher.py)
+  * [Trafid Cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/trafid_cipher.py)
+  * [Transposition Cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/transposition_cipher.py)
+  * [Transposition Cipher Encrypt Decrypt File](https://github.com/TheAlgorithms/Python/blob/master/ciphers/transposition_cipher_encrypt_decrypt_file.py)
+  * [Vigenere Cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/vigenere_cipher.py)
+  * [Xor Cipher](https://github.com/TheAlgorithms/Python/blob/master/ciphers/xor_cipher.py)
 
 ## Compression
-
-- [burrows wheeler](https://github.com/TheAlgorithms/Python/blob/master/compression/burrows_wheeler.py)
-- [huffman](https://github.com/TheAlgorithms/Python/blob/master/compression/huffman.py)
-- [peak signal to noise ratio](https://github.com/TheAlgorithms/Python/blob/master/compression/peak_signal_to_noise_ratio.py)
+  * [Burrows Wheeler](https://github.com/TheAlgorithms/Python/blob/master/compression/burrows_wheeler.py)
+  * [Huffman](https://github.com/TheAlgorithms/Python/blob/master/compression/huffman.py)
+  * [Peak Signal To Noise Ratio](https://github.com/TheAlgorithms/Python/blob/master/compression/peak_signal_to_noise_ratio.py)
 
 ## Conversions
-
-- [decimal to binary](https://github.com/TheAlgorithms/Python/blob/master/conversions/decimal_to_binary.py)
-- [decimal to hexadecimal](https://github.com/TheAlgorithms/Python/blob/master/conversions/decimal_to_hexadecimal.py)
-- [decimal to octal](https://github.com/TheAlgorithms/Python/blob/master/conversions/decimal_to_octal.py)
+  * [Decimal To Binary](https://github.com/TheAlgorithms/Python/blob/master/conversions/decimal_to_binary.py)
+  * [Decimal To Hexadecimal](https://github.com/TheAlgorithms/Python/blob/master/conversions/decimal_to_hexadecimal.py)
+  * [Decimal To Octal](https://github.com/TheAlgorithms/Python/blob/master/conversions/decimal_to_octal.py)
 
 ## Data Structures
-
-- Binary Tree
-  - [avl tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/avl_tree.py)
-  - [basic binary tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/basic_binary_tree.py)
-  - [binary search tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/binary_search_tree.py)
-  - [fenwick tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/fenwick_tree.py)
-  - [lazy segment tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/lazy_segment_tree.py)
-  - [lca](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/lca.py)
-  - [red black tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/red_black_tree.py)
-  - [segment tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/segment_tree.py)
-  - [treap](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/treap.py)
-- Hashing
-  - [double hash](https://github.com/TheAlgorithms/Python/blob/master/data_structures/hashing/double_hash.py)
-  - [hash table](https://github.com/TheAlgorithms/Python/blob/master/data_structures/hashing/hash_table.py)
-  - [hash table with linked list](https://github.com/TheAlgorithms/Python/blob/master/data_structures/hashing/hash_table_with_linked_list.py)
-- Number Theory
-  - [prime numbers](https://github.com/TheAlgorithms/Python/blob/master/data_structures/number_theory/prime_numbers.py)
-  - [quadratic probing](https://github.com/TheAlgorithms/Python/blob/master/data_structures/number_theory/quadratic_probing.py)
-- Heap
-  - [heap](https://github.com/TheAlgorithms/Python/blob/master/data_structures/heap/heap.py)
-- Linked List
-  - [doubly linked list](https://github.com/TheAlgorithms/Python/blob/master/data_structures/linked_list/doubly_linked_list.py)
-  - [is palindrome](https://github.com/TheAlgorithms/Python/blob/master/data_structures/linked_list/is_palindrome.py)
-  - [singly linked list](https://github.com/TheAlgorithms/Python/blob/master/data_structures/linked_list/singly_linked_list.py)
-  - [swap nodes](https://github.com/TheAlgorithms/Python/blob/master/data_structures/linked_list/swap_nodes.py)
-- Queue
-  - [double ended queue](https://github.com/TheAlgorithms/Python/blob/master/data_structures/queue/double_ended_queue.py)
-  - [queue on list](https://github.com/TheAlgorithms/Python/blob/master/data_structures/queue/queue_on_list.py)
-  - [queue on pseudo stack](https://github.com/TheAlgorithms/Python/blob/master/data_structures/queue/queue_on_pseudo_stack.py)
-- Stacks
-  - [balanced parentheses](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stacks/balanced_parentheses.py)
-  - [infix to postfix conversion](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stacks/infix_to_postfix_conversion.py)
-  - [infix to prefix conversion](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stacks/infix_to_prefix_conversion.py)
-  - [next greater element](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stacks/next_greater_element.py)
-  - [postfix evaluation](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stacks/postfix_evaluation.py)
-  - [stack](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stacks/stack.py)
-  - [stock span problem](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stacks/stock_span_problem.py)
-- Trie
-  - [trie](https://github.com/TheAlgorithms/Python/blob/master/data_structures/trie/trie.py)
+  * Binary Tree
+    * [Avl Tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/avl_tree.py)
+    * [Basic Binary Tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/basic_binary_tree.py)
+    * [Binary Search Tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/binary_search_tree.py)
+    * [Fenwick Tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/fenwick_tree.py)
+    * [Lazy Segment Tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/lazy_segment_tree.py)
+    * [Lca](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/lca.py)
+    * [Red Black Tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/red_black_tree.py)
+    * [Segment Tree](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/segment_tree.py)
+    * [Treap](https://github.com/TheAlgorithms/Python/blob/master/data_structures/binary_tree/treap.py)
+  * Disjoint Set
+    * [Disjoint Set](https://github.com/TheAlgorithms/Python/blob/master/data_structures/disjoint_set/disjoint_set.py)
+  * Hashing
+    * [Double Hash](https://github.com/TheAlgorithms/Python/blob/master/data_structures/hashing/double_hash.py)
+    * [Hash Table](https://github.com/TheAlgorithms/Python/blob/master/data_structures/hashing/hash_table.py)
+    * [Hash Table With Linked List](https://github.com/TheAlgorithms/Python/blob/master/data_structures/hashing/hash_table_with_linked_list.py)
+    * Number Theory
+      * [Prime Numbers](https://github.com/TheAlgorithms/Python/blob/master/data_structures/hashing/number_theory/prime_numbers.py)
+    * [Quadratic Probing](https://github.com/TheAlgorithms/Python/blob/master/data_structures/hashing/quadratic_probing.py)
+  * Heap
+    * [Binomial Heap](https://github.com/TheAlgorithms/Python/blob/master/data_structures/heap/binomial_heap.py)
+    * [Heap](https://github.com/TheAlgorithms/Python/blob/master/data_structures/heap/heap.py)
+    * [Min Heap](https://github.com/TheAlgorithms/Python/blob/master/data_structures/heap/min_heap.py)
+  * Linked List
+    * [Doubly Linked List](https://github.com/TheAlgorithms/Python/blob/master/data_structures/linked_list/doubly_linked_list.py)
+    * [Is Palindrome](https://github.com/TheAlgorithms/Python/blob/master/data_structures/linked_list/is_palindrome.py)
+    * [Singly Linked List](https://github.com/TheAlgorithms/Python/blob/master/data_structures/linked_list/singly_linked_list.py)
+    * [Swap Nodes](https://github.com/TheAlgorithms/Python/blob/master/data_structures/linked_list/swap_nodes.py)
+  * Queue
+    * [Double Ended Queue](https://github.com/TheAlgorithms/Python/blob/master/data_structures/queue/double_ended_queue.py)
+    * [Linked Queue](https://github.com/TheAlgorithms/Python/blob/master/data_structures/queue/linked_queue.py)
+    * [Queue On List](https://github.com/TheAlgorithms/Python/blob/master/data_structures/queue/queue_on_list.py)
+    * [Queue On Pseudo Stack](https://github.com/TheAlgorithms/Python/blob/master/data_structures/queue/queue_on_pseudo_stack.py)
+  * Stacks
+    * [Balanced Parentheses](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stacks/balanced_parentheses.py)
+    * [Infix To Postfix Conversion](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stacks/infix_to_postfix_conversion.py)
+    * [Infix To Prefix Conversion](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stacks/infix_to_prefix_conversion.py)
+    * [Linked Stack](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stacks/linked_stack.py)
+    * [Next Greater Element](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stacks/next_greater_element.py)
+    * [Postfix Evaluation](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stacks/postfix_evaluation.py)
+    * [Stack](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stacks/stack.py)
+    * [Stock Span Problem](https://github.com/TheAlgorithms/Python/blob/master/data_structures/stacks/stock_span_problem.py)
+  * Trie
+    * [Trie](https://github.com/TheAlgorithms/Python/blob/master/data_structures/trie/trie.py)
 
 ## Digital Image Processing
-
-- [change contrast](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/change_contrast.py)
-- Edge Detection
-  - [canny](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/edge_detection/canny.py)
-- Filters
-  - [convolve](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/filters/convolve.py)
-  - [gaussian filter](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/filters/gaussian_filter.py)
-  - [median filter](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/filters/median_filter.py)
-  - [sobel filter](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/filters/sobel_filter.py)
-- [test digital image processing](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/test_digital_image_processing.py)
+  * [Change Contrast](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/change_contrast.py)
+  * Edge Detection
+    * [Canny](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/edge_detection/canny.py)
+  * Filters
+    * [Convolve](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/filters/convolve.py)
+    * [Gaussian Filter](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/filters/gaussian_filter.py)
+    * [Median Filter](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/filters/median_filter.py)
+    * [Sobel Filter](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/filters/sobel_filter.py)
+  * Rotation
+    * [Rotation](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/rotation/rotation.py)
+  * [Test Digital Image Processing](https://github.com/TheAlgorithms/Python/blob/master/digital_image_processing/test_digital_image_processing.py)
 
 ## Divide And Conquer
-
-- [closest pair of points](https://github.com/TheAlgorithms/Python/blob/master/divide_and_conquer/closest_pair_of_points.py)
-- [convex hull](https://github.com/TheAlgorithms/Python/blob/master/divide_and_conquer/convex_hull.py)
-- [inversions](https://github.com/TheAlgorithms/Python/blob/master/divide_and_conquer/inversions.py)
-- [max subarray sum](https://github.com/TheAlgorithms/Python/blob/master/divide_and_conquer/max_subarray_sum.py)
+  * [Closest Pair Of Points](https://github.com/TheAlgorithms/Python/blob/master/divide_and_conquer/closest_pair_of_points.py)
+  * [Convex Hull](https://github.com/TheAlgorithms/Python/blob/master/divide_and_conquer/convex_hull.py)
+  * [Inversions](https://github.com/TheAlgorithms/Python/blob/master/divide_and_conquer/inversions.py)
+  * [Max Subarray Sum](https://github.com/TheAlgorithms/Python/blob/master/divide_and_conquer/max_subarray_sum.py)
+  * [Mergesort](https://github.com/TheAlgorithms/Python/blob/master/divide_and_conquer/mergesort.py)
 
 ## Dynamic Programming
-
-- [abbreviation](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/abbreviation.py)
-- [bitmask](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/bitmask.py)
-- [climbing stairs](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/climbing_stairs.py)
-- [coin change](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/coin_change.py)
-- [edit distance](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/edit_distance.py)
-- [factorial](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/factorial.py)
-- [fast fibonacci](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/fast_fibonacci.py)
-- [fibonacci](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/fibonacci.py)
-- [floyd warshall](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/floyd_warshall.py)
-- [fractional knapsack](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/fractional_knapsack.py)
-- [integer partition](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/integer_partition.py)
-- [k means clustering tensorflow](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/k_means_clustering_tensorflow.py)
-- [knapsack](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/knapsack.py)
-- [longest common subsequence](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/longest_common_subsequence.py)
-- [longest increasing subsequence](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/longest_increasing_subsequence.py)
-- [longest increasing subsequence o(nlogn)](<https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/longest_increasing_subsequence_o(nlogn).py>)
-- [longest sub array](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/longest_sub_array.py)
-- [matrix chain order](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/matrix_chain_order.py)
-- [max sub array](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/max_sub_array.py)
-- [minimum partition](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/minimum_partition.py)
-- [rod cutting](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/rod_cutting.py)
-- [subset generation](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/subset_generation.py)
-- [sum of subset](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/sum_of_subset.py)
+  * [Abbreviation](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/abbreviation.py)
+  * [Bitmask](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/bitmask.py)
+  * [Climbing Stairs](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/climbing_stairs.py)
+  * [Coin Change](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/coin_change.py)
+  * [Edit Distance](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/edit_distance.py)
+  * [Factorial](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/factorial.py)
+  * [Fast Fibonacci](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/fast_fibonacci.py)
+  * [Fibonacci](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/fibonacci.py)
+  * [Floyd Warshall](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/floyd_warshall.py)
+  * [Fractional Knapsack](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/fractional_knapsack.py)
+  * [Integer Partition](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/integer_partition.py)
+  * [K Means Clustering Tensorflow](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/k_means_clustering_tensorflow.py)
+  * [Knapsack](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/knapsack.py)
+  * [Longest Common Subsequence](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/longest_common_subsequence.py)
+  * [Longest Increasing Subsequence](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/longest_increasing_subsequence.py)
+  * [Longest Increasing Subsequence O(Nlogn)](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/longest_increasing_subsequence_o(nlogn).py)
+  * [Longest Sub Array](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/longest_sub_array.py)
+  * [Matrix Chain Order](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/matrix_chain_order.py)
+  * [Max Sub Array](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/max_sub_array.py)
+  * [Minimum Partition](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/minimum_partition.py)
+  * [Rod Cutting](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/rod_cutting.py)
+  * [Subset Generation](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/subset_generation.py)
+  * [Sum Of Subset](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/sum_of_subset.py)
 
 ## File Transfer
+  * [Recieve File](https://github.com/TheAlgorithms/Python/blob/master/file_transfer/recieve_file.py)
+  * [Send File](https://github.com/TheAlgorithms/Python/blob/master/file_transfer/send_file.py)
 
-- [recieve file](https://github.com/TheAlgorithms/Python/blob/master/file_transfer/recieve_file.py)
-- [send file](https://github.com/TheAlgorithms/Python/blob/master/file_transfer/send_file.py)
+## Fuzzy Logic
+  * [Fuzzy Operations](https://github.com/TheAlgorithms/Python/blob/master/fuzzy_logic/fuzzy_operations.py)
 
 ## Graphs
-
-- [a star](https://github.com/TheAlgorithms/Python/blob/master/graphs/a_star.py)
-- [articulation points](https://github.com/TheAlgorithms/Python/blob/master/graphs/articulation_points.py)
-- [basic graphs](https://github.com/TheAlgorithms/Python/blob/master/graphs/basic_graphs.py)
-- [bellman ford](https://github.com/TheAlgorithms/Python/blob/master/graphs/bellman_ford.py)
-- [bfs](https://github.com/TheAlgorithms/Python/blob/master/graphs/bfs.py)
-- [bfs shortest path](https://github.com/TheAlgorithms/Python/blob/master/graphs/bfs_shortest_path.py)
-- [breadth first search](https://github.com/TheAlgorithms/Python/blob/master/graphs/breadth_first_search.py)
-- [check bipartite graph bfs](https://github.com/TheAlgorithms/Python/blob/master/graphs/check_bipartite_graph_bfs.py)
-- [check bipartite graph dfs](https://github.com/TheAlgorithms/Python/blob/master/graphs/check_bipartite_graph_dfs.py)
-- [depth first search](https://github.com/TheAlgorithms/Python/blob/master/graphs/depth_first_search.py)
-- [dfs](https://github.com/TheAlgorithms/Python/blob/master/graphs/dfs.py)
-- [dijkstra](https://github.com/TheAlgorithms/Python/blob/master/graphs/dijkstra.py)
-- [dijkstra 2](https://github.com/TheAlgorithms/Python/blob/master/graphs/dijkstra_2.py)
-- [dijkstra algorithm](https://github.com/TheAlgorithms/Python/blob/master/graphs/dijkstra_algorithm.py)
-- [directed and undirected (weighted) graph](<https://github.com/TheAlgorithms/Python/blob/master/graphs/directed_and_undirected_(weighted)_graph.py>)
-- [edmonds karp multiple source and sink](https://github.com/TheAlgorithms/Python/blob/master/graphs/edmonds_karp_multiple_source_and_sink.py)
-- [eulerian path and circuit for undirected graph](https://github.com/TheAlgorithms/Python/blob/master/graphs/eulerian_path_and_circuit_for_undirected_graph.py)
-- [even tree](https://github.com/TheAlgorithms/Python/blob/master/graphs/even_tree.py)
-- [finding bridges](https://github.com/TheAlgorithms/Python/blob/master/graphs/finding_bridges.py)
-- [graph list](https://github.com/TheAlgorithms/Python/blob/master/graphs/graph_list.py)
-- [graph matrix](https://github.com/TheAlgorithms/Python/blob/master/graphs/graph_matrix.py)
-- [graphs floyd warshall](https://github.com/TheAlgorithms/Python/blob/master/graphs/graphs_floyd_warshall.py)
-- [kahns algorithm long](https://github.com/TheAlgorithms/Python/blob/master/graphs/kahns_algorithm_long.py)
-- [kahns algorithm topo](https://github.com/TheAlgorithms/Python/blob/master/graphs/kahns_algorithm_topo.py)
-- [minimum spanning tree kruskal](https://github.com/TheAlgorithms/Python/blob/master/graphs/minimum_spanning_tree_kruskal.py)
-- [minimum spanning tree prims](https://github.com/TheAlgorithms/Python/blob/master/graphs/minimum_spanning_tree_prims.py)
-- [multi hueristic astar](https://github.com/TheAlgorithms/Python/blob/master/graphs/multi_hueristic_astar.py)
-- [page rank](https://github.com/TheAlgorithms/Python/blob/master/graphs/page_rank.py)
-- [prim](https://github.com/TheAlgorithms/Python/blob/master/graphs/prim.py)
-- [scc kosaraju](https://github.com/TheAlgorithms/Python/blob/master/graphs/scc_kosaraju.py)
-- [tarjans scc](https://github.com/TheAlgorithms/Python/blob/master/graphs/tarjans_scc.py)
+  * [A Star](https://github.com/TheAlgorithms/Python/blob/master/graphs/a_star.py)
+  * [Articulation Points](https://github.com/TheAlgorithms/Python/blob/master/graphs/articulation_points.py)
+  * [Basic Graphs](https://github.com/TheAlgorithms/Python/blob/master/graphs/basic_graphs.py)
+  * [Bellman Ford](https://github.com/TheAlgorithms/Python/blob/master/graphs/bellman_ford.py)
+  * [Bfs](https://github.com/TheAlgorithms/Python/blob/master/graphs/bfs.py)
+  * [Bfs Shortest Path](https://github.com/TheAlgorithms/Python/blob/master/graphs/bfs_shortest_path.py)
+  * [Breadth First Search](https://github.com/TheAlgorithms/Python/blob/master/graphs/breadth_first_search.py)
+  * [Check Bipartite Graph Bfs](https://github.com/TheAlgorithms/Python/blob/master/graphs/check_bipartite_graph_bfs.py)
+  * [Check Bipartite Graph Dfs](https://github.com/TheAlgorithms/Python/blob/master/graphs/check_bipartite_graph_dfs.py)
+  * [Depth First Search](https://github.com/TheAlgorithms/Python/blob/master/graphs/depth_first_search.py)
+  * [Dfs](https://github.com/TheAlgorithms/Python/blob/master/graphs/dfs.py)
+  * [Dijkstra](https://github.com/TheAlgorithms/Python/blob/master/graphs/dijkstra.py)
+  * [Dijkstra 2](https://github.com/TheAlgorithms/Python/blob/master/graphs/dijkstra_2.py)
+  * [Dijkstra Algorithm](https://github.com/TheAlgorithms/Python/blob/master/graphs/dijkstra_algorithm.py)
+  * [Dinic](https://github.com/TheAlgorithms/Python/blob/master/graphs/dinic.py)
+  * [Directed And Undirected (Weighted) Graph](https://github.com/TheAlgorithms/Python/blob/master/graphs/directed_and_undirected_(weighted)_graph.py)
+  * [Edmonds Karp Multiple Source And Sink](https://github.com/TheAlgorithms/Python/blob/master/graphs/edmonds_karp_multiple_source_and_sink.py)
+  * [Eulerian Path And Circuit For Undirected Graph](https://github.com/TheAlgorithms/Python/blob/master/graphs/eulerian_path_and_circuit_for_undirected_graph.py)
+  * [Even Tree](https://github.com/TheAlgorithms/Python/blob/master/graphs/even_tree.py)
+  * [Finding Bridges](https://github.com/TheAlgorithms/Python/blob/master/graphs/finding_bridges.py)
+  * [G Topological Sort](https://github.com/TheAlgorithms/Python/blob/master/graphs/g_topological_sort.py)
+  * [Graph List](https://github.com/TheAlgorithms/Python/blob/master/graphs/graph_list.py)
+  * [Graph Matrix](https://github.com/TheAlgorithms/Python/blob/master/graphs/graph_matrix.py)
+  * [Graphs Floyd Warshall](https://github.com/TheAlgorithms/Python/blob/master/graphs/graphs_floyd_warshall.py)
+  * [Kahns Algorithm Long](https://github.com/TheAlgorithms/Python/blob/master/graphs/kahns_algorithm_long.py)
+  * [Kahns Algorithm Topo](https://github.com/TheAlgorithms/Python/blob/master/graphs/kahns_algorithm_topo.py)
+  * [Minimum Spanning Tree Kruskal](https://github.com/TheAlgorithms/Python/blob/master/graphs/minimum_spanning_tree_kruskal.py)
+  * [Minimum Spanning Tree Prims](https://github.com/TheAlgorithms/Python/blob/master/graphs/minimum_spanning_tree_prims.py)
+  * [Multi Hueristic Astar](https://github.com/TheAlgorithms/Python/blob/master/graphs/multi_hueristic_astar.py)
+  * [Page Rank](https://github.com/TheAlgorithms/Python/blob/master/graphs/page_rank.py)
+  * [Prim](https://github.com/TheAlgorithms/Python/blob/master/graphs/prim.py)
+  * [Scc Kosaraju](https://github.com/TheAlgorithms/Python/blob/master/graphs/scc_kosaraju.py)
+  * [Tarjans Scc](https://github.com/TheAlgorithms/Python/blob/master/graphs/tarjans_scc.py)
 
 ## Hashes
-
-- [chaos machine](https://github.com/TheAlgorithms/Python/blob/master/hashes/chaos_machine.py)
-- [enigma machine](https://github.com/TheAlgorithms/Python/blob/master/hashes/enigma_machine.py)
-- [md5](https://github.com/TheAlgorithms/Python/blob/master/hashes/md5.py)
-- [sha1](https://github.com/TheAlgorithms/Python/blob/master/hashes/sha1.py)
+  * [Chaos Machine](https://github.com/TheAlgorithms/Python/blob/master/hashes/chaos_machine.py)
+  * [Enigma Machine](https://github.com/TheAlgorithms/Python/blob/master/hashes/enigma_machine.py)
+  * [Md5](https://github.com/TheAlgorithms/Python/blob/master/hashes/md5.py)
+  * [Sha1](https://github.com/TheAlgorithms/Python/blob/master/hashes/sha1.py)
 
 ## Linear Algebra
-
-- Src
-  - [lib](https://github.com/TheAlgorithms/Python/blob/master/linear_algebra/src/lib.py)
-  - [polynom-for-points](https://github.com/TheAlgorithms/Python/blob/master/linear_algebra/src/polynom-for-points.py)
-  - [tests](https://github.com/TheAlgorithms/Python/blob/master/linear_algebra/src/tests.py)
+  * Src
+    * [Lib](https://github.com/TheAlgorithms/Python/blob/master/linear_algebra/src/lib.py)
+    * [Polynom-For-Points](https://github.com/TheAlgorithms/Python/blob/master/linear_algebra/src/polynom-for-points.py)
+    * [Test Linear Algebra](https://github.com/TheAlgorithms/Python/blob/master/linear_algebra/src/test_linear_algebra.py)
 
 ## Machine Learning
-
-- [decision tree](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/decision_tree.py)
-- [gradient descent](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/gradient_descent.py)
-- [k means clust](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/k_means_clust.py)
-- [knn sklearn](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/knn_sklearn.py)
-- [linear regression](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/linear_regression.py)
-- [logistic regression](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/logistic_regression.py)
-- [naive bayes](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/naive_bayes.ipynb)
-- Random Forest Classification
-  - [random forest classification](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/random_forest_classification/random_forest_classification.py)
-  - [random forest classifier](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/random_forest_classification/random_forest_classifier.ipynb)
-- Random Forest Regression
-  - [random forest regression](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/random_forest_regression/random_forest_regression.ipynb)
-  - [random forest regression](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/random_forest_regression/random_forest_regression.py)
-- [reuters one vs rest classifier](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/reuters_one_vs_rest_classifier.ipynb)
-- [scoring functions](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/scoring_functions.py)
-- [sorted vector machines](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/sorted_vector_machines.py)
+  * [Decision Tree](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/decision_tree.py)
+  * [Gradient Descent](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/gradient_descent.py)
+  * [K Means Clust](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/k_means_clust.py)
+  * [K Nearest Neighbours](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/k_nearest_neighbours.py)
+  * [Knn Sklearn](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/knn_sklearn.py)
+  * [Linear Regression](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/linear_regression.py)
+  * [Logistic Regression](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/logistic_regression.py)
+  * [Polymonial Regression](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/polymonial_regression.py)
+  * [Scoring Functions](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/scoring_functions.py)
+  * [Sequential Minimum Optimization](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/sequential_minimum_optimization.py)
+  * [Support Vector Machines](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/support_vector_machines.py)
 
 ## Maths
-
-- [3n+1](https://github.com/TheAlgorithms/Python/blob/master/maths/3n+1.py)
-- [abs](https://github.com/TheAlgorithms/Python/blob/master/maths/abs.py)
-- [abs max](https://github.com/TheAlgorithms/Python/blob/master/maths/abs_max.py)
-- [abs min](https://github.com/TheAlgorithms/Python/blob/master/maths/abs_min.py)
-- [average mean](https://github.com/TheAlgorithms/Python/blob/master/maths/average_mean.py)
-- [average median](https://github.com/TheAlgorithms/Python/blob/master/maths/average_median.py)
-- [basic maths](https://github.com/TheAlgorithms/Python/blob/master/maths/basic_maths.py)
-- [binary exponentiation](https://github.com/TheAlgorithms/Python/blob/master/maths/binary_exponentiation.py)
-- [collatz sequence](https://github.com/TheAlgorithms/Python/blob/master/maths/collatz_sequence.py)
-- [extended euclidean algorithm](https://github.com/TheAlgorithms/Python/blob/master/maths/extended_euclidean_algorithm.py)
-- [factorial python](https://github.com/TheAlgorithms/Python/blob/master/maths/factorial_python.py)
-- [factorial recursive](https://github.com/TheAlgorithms/Python/blob/master/maths/factorial_recursive.py)
-- [fermat little theorem](https://github.com/TheAlgorithms/Python/blob/master/maths/fermat_little_theorem.py)
-- [fibonacci](https://github.com/TheAlgorithms/Python/blob/master/maths/fibonacci.py)
-- [fibonacci sequence recursion](https://github.com/TheAlgorithms/Python/blob/master/maths/fibonacci_sequence_recursion.py)
-- [find lcm](https://github.com/TheAlgorithms/Python/blob/master/maths/find_lcm.py)
-- [find max](https://github.com/TheAlgorithms/Python/blob/master/maths/find_max.py)
-- [find min](https://github.com/TheAlgorithms/Python/blob/master/maths/find_min.py)
-- [gaussian](https://github.com/TheAlgorithms/Python/blob/master/maths/gaussian.py)
-- [greater common divisor](https://github.com/TheAlgorithms/Python/blob/master/maths/greater_common_divisor.py)
-- [is square free](https://github.com/TheAlgorithms/Python/blob/master/maths/is_square_free.py)
-- [largest of very large numbers](https://github.com/TheAlgorithms/Python/blob/master/maths/largest_of_very_large_numbers.py)
-- [lucas lehmer primality test](https://github.com/TheAlgorithms/Python/blob/master/maths/lucas_lehmer_primality_test.py)
-- [lucas series](https://github.com/TheAlgorithms/Python/blob/master/maths/lucas_series.py)
-- [mobius function](https://github.com/TheAlgorithms/Python/blob/master/maths/mobius_function.py)
-- [modular exponential](https://github.com/TheAlgorithms/Python/blob/master/maths/modular_exponential.py)
-- [newton raphson](https://github.com/TheAlgorithms/Python/blob/master/maths/newton_raphson.py)
-- [prime check](https://github.com/TheAlgorithms/Python/blob/master/maths/prime_check.py)
-- [prime factors](https://github.com/TheAlgorithms/Python/blob/master/maths/prime_factors.py)
-- [quadratic equations complex numbers](https://github.com/TheAlgorithms/Python/blob/master/maths/quadratic_equations_complex_numbers.py)
-- [segmented sieve](https://github.com/TheAlgorithms/Python/blob/master/maths/segmented_sieve.py)
-- [sieve of eratosthenes](https://github.com/TheAlgorithms/Python/blob/master/maths/sieve_of_eratosthenes.py)
-- [simpson rule](https://github.com/TheAlgorithms/Python/blob/master/maths/simpson_rule.py)
-- [test prime check](https://github.com/TheAlgorithms/Python/blob/master/maths/test_prime_check.py)
-- [trapezoidal rule](https://github.com/TheAlgorithms/Python/blob/master/maths/trapezoidal_rule.py)
-- [volume](https://github.com/TheAlgorithms/Python/blob/master/maths/volume.py)
-- [zellers congruence](https://github.com/TheAlgorithms/Python/blob/master/maths/zellers_congruence.py)
+  * [3N+1](https://github.com/TheAlgorithms/Python/blob/master/maths/3n+1.py)
+  * [Abs](https://github.com/TheAlgorithms/Python/blob/master/maths/abs.py)
+  * [Abs Max](https://github.com/TheAlgorithms/Python/blob/master/maths/abs_max.py)
+  * [Abs Min](https://github.com/TheAlgorithms/Python/blob/master/maths/abs_min.py)
+  * [Average Mean](https://github.com/TheAlgorithms/Python/blob/master/maths/average_mean.py)
+  * [Average Median](https://github.com/TheAlgorithms/Python/blob/master/maths/average_median.py)
+  * [Basic Maths](https://github.com/TheAlgorithms/Python/blob/master/maths/basic_maths.py)
+  * [Binary Exponentiation](https://github.com/TheAlgorithms/Python/blob/master/maths/binary_exponentiation.py)
+  * [Collatz Sequence](https://github.com/TheAlgorithms/Python/blob/master/maths/collatz_sequence.py)
+  * [Explicit Euler](https://github.com/TheAlgorithms/Python/blob/master/maths/explicit_euler.py)
+  * [Extended Euclidean Algorithm](https://github.com/TheAlgorithms/Python/blob/master/maths/extended_euclidean_algorithm.py)
+  * [Factorial Python](https://github.com/TheAlgorithms/Python/blob/master/maths/factorial_python.py)
+  * [Factorial Recursive](https://github.com/TheAlgorithms/Python/blob/master/maths/factorial_recursive.py)
+  * [Fermat Little Theorem](https://github.com/TheAlgorithms/Python/blob/master/maths/fermat_little_theorem.py)
+  * [Fibonacci](https://github.com/TheAlgorithms/Python/blob/master/maths/fibonacci.py)
+  * [Fibonacci Sequence Recursion](https://github.com/TheAlgorithms/Python/blob/master/maths/fibonacci_sequence_recursion.py)
+  * [Find Max](https://github.com/TheAlgorithms/Python/blob/master/maths/find_max.py)
+  * [Find Max Recursion](https://github.com/TheAlgorithms/Python/blob/master/maths/find_max_recursion.py)
+  * [Find Min](https://github.com/TheAlgorithms/Python/blob/master/maths/find_min.py)
+  * [Find Min Recursion](https://github.com/TheAlgorithms/Python/blob/master/maths/find_min_recursion.py)
+  * [Gaussian](https://github.com/TheAlgorithms/Python/blob/master/maths/gaussian.py)
+  * [Greatest Common Divisor](https://github.com/TheAlgorithms/Python/blob/master/maths/greatest_common_divisor.py)
+  * [Hardy Ramanujanalgo](https://github.com/TheAlgorithms/Python/blob/master/maths/hardy_ramanujanalgo.py)
+  * [Is Square Free](https://github.com/TheAlgorithms/Python/blob/master/maths/is_square_free.py)
+  * [Jaccard Similarity](https://github.com/TheAlgorithms/Python/blob/master/maths/jaccard_similarity.py)
+  * [Karatsuba](https://github.com/TheAlgorithms/Python/blob/master/maths/karatsuba.py)
+  * [Kth Lexicographic Permutation](https://github.com/TheAlgorithms/Python/blob/master/maths/kth_lexicographic_permutation.py)
+  * [Largest Of Very Large Numbers](https://github.com/TheAlgorithms/Python/blob/master/maths/largest_of_very_large_numbers.py)
+  * [Least Common Multiple](https://github.com/TheAlgorithms/Python/blob/master/maths/least_common_multiple.py)
+  * [Lucas Lehmer Primality Test](https://github.com/TheAlgorithms/Python/blob/master/maths/lucas_lehmer_primality_test.py)
+  * [Lucas Series](https://github.com/TheAlgorithms/Python/blob/master/maths/lucas_series.py)
+  * [Matrix Exponentiation](https://github.com/TheAlgorithms/Python/blob/master/maths/matrix_exponentiation.py)
+  * [Mobius Function](https://github.com/TheAlgorithms/Python/blob/master/maths/mobius_function.py)
+  * [Modular Exponential](https://github.com/TheAlgorithms/Python/blob/master/maths/modular_exponential.py)
+  * [Newton Raphson](https://github.com/TheAlgorithms/Python/blob/master/maths/newton_raphson.py)
+  * [Polynomial Evaluation](https://github.com/TheAlgorithms/Python/blob/master/maths/polynomial_evaluation.py)
+  * [Prime Check](https://github.com/TheAlgorithms/Python/blob/master/maths/prime_check.py)
+  * [Prime Factors](https://github.com/TheAlgorithms/Python/blob/master/maths/prime_factors.py)
+  * [Prime Sieve Eratosthenes](https://github.com/TheAlgorithms/Python/blob/master/maths/prime_sieve_eratosthenes.py)
+  * [Qr Decomposition](https://github.com/TheAlgorithms/Python/blob/master/maths/qr_decomposition.py)
+  * [Quadratic Equations Complex Numbers](https://github.com/TheAlgorithms/Python/blob/master/maths/quadratic_equations_complex_numbers.py)
+  * [Radix2 Fft](https://github.com/TheAlgorithms/Python/blob/master/maths/radix2_fft.py)
+  * [Runge Kutta](https://github.com/TheAlgorithms/Python/blob/master/maths/runge_kutta.py)
+  * [Segmented Sieve](https://github.com/TheAlgorithms/Python/blob/master/maths/segmented_sieve.py)
+  * [Sieve Of Eratosthenes](https://github.com/TheAlgorithms/Python/blob/master/maths/sieve_of_eratosthenes.py)
+  * [Simpson Rule](https://github.com/TheAlgorithms/Python/blob/master/maths/simpson_rule.py)
+  * [Softmax](https://github.com/TheAlgorithms/Python/blob/master/maths/softmax.py)
+  * [Sum Of Arithmetic Series](https://github.com/TheAlgorithms/Python/blob/master/maths/sum_of_arithmetic_series.py)
+  * [Test Prime Check](https://github.com/TheAlgorithms/Python/blob/master/maths/test_prime_check.py)
+  * [Trapezoidal Rule](https://github.com/TheAlgorithms/Python/blob/master/maths/trapezoidal_rule.py)
+  * [Volume](https://github.com/TheAlgorithms/Python/blob/master/maths/volume.py)
+  * [Zellers Congruence](https://github.com/TheAlgorithms/Python/blob/master/maths/zellers_congruence.py)
 
 ## Matrix
-
-- [matrix operation](https://github.com/TheAlgorithms/Python/blob/master/matrix/matrix_operation.py)
-- [nth fibonacci using matrix exponentiation](https://github.com/TheAlgorithms/Python/blob/master/matrix/nth_fibonacci_using_matrix_exponentiation.py)
-- [rotate matrix](https://github.com/TheAlgorithms/Python/blob/master/matrix/rotate_matrix.py)
-- [searching in sorted matrix](https://github.com/TheAlgorithms/Python/blob/master/matrix/searching_in_sorted_matrix.py)
-- [spiral print](https://github.com/TheAlgorithms/Python/blob/master/matrix/spiral_print.py)
-- Tests
-  - [test matrix operation](https://github.com/TheAlgorithms/Python/blob/master/matrix/tests/test_matrix_operation.py)
+  * [Matrix Class](https://github.com/TheAlgorithms/Python/blob/master/matrix/matrix_class.py)
+  * [Matrix Operation](https://github.com/TheAlgorithms/Python/blob/master/matrix/matrix_operation.py)
+  * [Nth Fibonacci Using Matrix Exponentiation](https://github.com/TheAlgorithms/Python/blob/master/matrix/nth_fibonacci_using_matrix_exponentiation.py)
+  * [Rotate Matrix](https://github.com/TheAlgorithms/Python/blob/master/matrix/rotate_matrix.py)
+  * [Searching In Sorted Matrix](https://github.com/TheAlgorithms/Python/blob/master/matrix/searching_in_sorted_matrix.py)
+  * [Sherman Morrison](https://github.com/TheAlgorithms/Python/blob/master/matrix/sherman_morrison.py)
+  * [Spiral Print](https://github.com/TheAlgorithms/Python/blob/master/matrix/spiral_print.py)
+  * Tests
+    * [Test Matrix Operation](https://github.com/TheAlgorithms/Python/blob/master/matrix/tests/test_matrix_operation.py)
 
 ## Networking Flow
-
-- [ford fulkerson](https://github.com/TheAlgorithms/Python/blob/master/networking_flow/ford_fulkerson.py)
-- [minimum cut](https://github.com/TheAlgorithms/Python/blob/master/networking_flow/minimum_cut.py)
+  * [Ford Fulkerson](https://github.com/TheAlgorithms/Python/blob/master/networking_flow/ford_fulkerson.py)
+  * [Minimum Cut](https://github.com/TheAlgorithms/Python/blob/master/networking_flow/minimum_cut.py)
 
 ## Neural Network
-
-- [back propagation neural network](https://github.com/TheAlgorithms/Python/blob/master/neural_network/back_propagation_neural_network.py)
-- [convolution neural network](https://github.com/TheAlgorithms/Python/blob/master/neural_network/convolution_neural_network.py)
-- [fully connected neural network](https://github.com/TheAlgorithms/Python/blob/master/neural_network/fully_connected_neural_network.ipynb)
-- [perceptron](https://github.com/TheAlgorithms/Python/blob/master/neural_network/perceptron.py)
+  * [Back Propagation Neural Network](https://github.com/TheAlgorithms/Python/blob/master/neural_network/back_propagation_neural_network.py)
+  * [Convolution Neural Network](https://github.com/TheAlgorithms/Python/blob/master/neural_network/convolution_neural_network.py)
+  * [Perceptron](https://github.com/TheAlgorithms/Python/blob/master/neural_network/perceptron.py)
 
 ## Other
-
-- [anagrams](https://github.com/TheAlgorithms/Python/blob/master/other/anagrams.py)
-- [binary exponentiation](https://github.com/TheAlgorithms/Python/blob/master/other/binary_exponentiation.py)
-- [binary exponentiation 2](https://github.com/TheAlgorithms/Python/blob/master/other/binary_exponentiation_2.py)
-- [detecting english programmatically](https://github.com/TheAlgorithms/Python/blob/master/other/detecting_english_programmatically.py)
-- [euclidean gcd](https://github.com/TheAlgorithms/Python/blob/master/other/euclidean_gcd.py)
-- [fischer yates shuffle](https://github.com/TheAlgorithms/Python/blob/master/other/fischer_yates_shuffle.py)
-- [food wastage analysis from 1961-2013 fao](https://github.com/TheAlgorithms/Python/blob/master/other/food_wastage_analysis_from_1961-2013_fao.ipynb)
-- [frequency finder](https://github.com/TheAlgorithms/Python/blob/master/other/frequency_finder.py)
-- [game of life](https://github.com/TheAlgorithms/Python/blob/master/other/game_of_life.py)
-- [linear congruential generator](https://github.com/TheAlgorithms/Python/blob/master/other/linear_congruential_generator.py)
-- [nested brackets](https://github.com/TheAlgorithms/Python/blob/master/other/nested_brackets.py)
-- [palindrome](https://github.com/TheAlgorithms/Python/blob/master/other/palindrome.py)
-- [password generator](https://github.com/TheAlgorithms/Python/blob/master/other/password_generator.py)
-- [primelib](https://github.com/TheAlgorithms/Python/blob/master/other/primelib.py)
-- [sierpinski triangle](https://github.com/TheAlgorithms/Python/blob/master/other/sierpinski_triangle.py)
-- [tower of hanoi](https://github.com/TheAlgorithms/Python/blob/master/other/tower_of_hanoi.py)
-- [two sum](https://github.com/TheAlgorithms/Python/blob/master/other/two_sum.py)
-- [word patterns](https://github.com/TheAlgorithms/Python/blob/master/other/word_patterns.py)
+  * [Activity Selection](https://github.com/TheAlgorithms/Python/blob/master/other/activity_selection.py)
+  * [Anagrams](https://github.com/TheAlgorithms/Python/blob/master/other/anagrams.py)
+  * [Autocomplete Using Trie](https://github.com/TheAlgorithms/Python/blob/master/other/autocomplete_using_trie.py)
+  * [Binary Exponentiation](https://github.com/TheAlgorithms/Python/blob/master/other/binary_exponentiation.py)
+  * [Binary Exponentiation 2](https://github.com/TheAlgorithms/Python/blob/master/other/binary_exponentiation_2.py)
+  * [Detecting English Programmatically](https://github.com/TheAlgorithms/Python/blob/master/other/detecting_english_programmatically.py)
+  * [Euclidean Gcd](https://github.com/TheAlgorithms/Python/blob/master/other/euclidean_gcd.py)
+  * [Fischer Yates Shuffle](https://github.com/TheAlgorithms/Python/blob/master/other/fischer_yates_shuffle.py)
+  * [Food Wastage Analysis From 1961-2013 Fao](https://github.com/TheAlgorithms/Python/blob/master/other/food_wastage_analysis_from_1961-2013_fao.ipynb)
+  * [Frequency Finder](https://github.com/TheAlgorithms/Python/blob/master/other/frequency_finder.py)
+  * [Game Of Life](https://github.com/TheAlgorithms/Python/blob/master/other/game_of_life.py)
+  * [Greedy](https://github.com/TheAlgorithms/Python/blob/master/other/greedy.py)
+  * [Largest Subarray Sum](https://github.com/TheAlgorithms/Python/blob/master/other/largest_subarray_sum.py)
+  * [Linear Congruential Generator](https://github.com/TheAlgorithms/Python/blob/master/other/linear_congruential_generator.py)
+  * [Magicdiamondpattern](https://github.com/TheAlgorithms/Python/blob/master/other/magicdiamondpattern.py)
+  * [Nested Brackets](https://github.com/TheAlgorithms/Python/blob/master/other/nested_brackets.py)
+  * [Palindrome](https://github.com/TheAlgorithms/Python/blob/master/other/palindrome.py)
+  * [Password Generator](https://github.com/TheAlgorithms/Python/blob/master/other/password_generator.py)
+  * [Primelib](https://github.com/TheAlgorithms/Python/blob/master/other/primelib.py)
+  * [Sierpinski Triangle](https://github.com/TheAlgorithms/Python/blob/master/other/sierpinski_triangle.py)
+  * [Tower Of Hanoi](https://github.com/TheAlgorithms/Python/blob/master/other/tower_of_hanoi.py)
+  * [Two Sum](https://github.com/TheAlgorithms/Python/blob/master/other/two_sum.py)
+  * [Word Patterns](https://github.com/TheAlgorithms/Python/blob/master/other/word_patterns.py)
 
 ## Project Euler
-
-- Problem 01
-  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_01/sol1.py)
-  - [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_01/sol2.py)
-  - [sol3](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_01/sol3.py)
-  - [sol4](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_01/sol4.py)
-  - [sol5](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_01/sol5.py)
-  - [sol6](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_01/sol6.py)
-- Problem 02
-  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_02/sol1.py)
-  - [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_02/sol2.py)
-  - [sol3](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_02/sol3.py)
-  - [sol4](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_02/sol4.py)
-- Problem 03
-  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_03/sol1.py)
-  - [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_03/sol2.py)
-- Problem 04
-  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_04/sol1.py)
-  - [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_04/sol2.py)
-- Problem 05
-  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_05/sol1.py)
-  - [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_05/sol2.py)
-- Problem 06
-  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_06/sol1.py)
-  - [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_06/sol2.py)
-  - [sol3](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_06/sol3.py)
-- Problem 07
-  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_07/sol1.py)
-  - [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_07/sol2.py)
-  - [sol3](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_07/sol3.py)
-- Problem 08
-  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_08/sol1.py)
-  - [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_08/sol2.py)
-- Problem 09
-  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_09/sol1.py)
-  - [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_09/sol2.py)
-  - [sol3](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_09/sol3.py)
-- Problem 10
-  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_10/sol1.py)
-  - [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_10/sol2.py)
-  - [sol3](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_10/sol3.py)
-- Problem 11
-  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_11/sol1.py)
-  - [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_11/sol2.py)
-- Problem 12
-  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_12/sol1.py)
-  - [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_12/sol2.py)
-- Problem 13
-  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_13/sol1.py)
-- Problem 14
-  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_14/sol1.py)
-  - [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_14/sol2.py)
-- Problem 15
-  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_15/sol1.py)
-- Problem 16
-  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_16/sol1.py)
-  - [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_16/sol2.py)
-- Problem 17
-  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_17/sol1.py)
-- Problem 18
-  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_18/sol1.py)
-- Problem 19
-  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_19/sol1.py)
-- Problem 20
-  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_20/sol1.py)
-  - [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_20/sol2.py)
-- Problem 21
-  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_21/sol1.py)
-- Problem 22
-  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_22/sol1.py)
-  - [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_22/sol2.py)
-- Problem 234
-  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_234/sol1.py)
-- Problem 24
-  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_24/sol1.py)
-- Problem 25
-  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_25/sol1.py)
-  - [sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_25/sol2.py)
-- Problem 28
-  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_28/sol1.py)
-- Problem 29
-  - [solution](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_28/solution.py)
-- Problem 31
-  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_31/sol1.py)
-- Problem 36
-  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_36/sol1.py)
-- Problem 40
-  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_40/sol1.py)
-- Problem 48
-  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_48/sol1.py)
-- Problem 52
-  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_52/sol1.py)
-- Problem 53
-  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_53/sol1.py)
-- Problem 56
-  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_56/sol1.py)
-- Problem 76
-  - [sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_76/sol1.py)
+  * Problem 01
+    * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_01/sol1.py)
+    * [Sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_01/sol2.py)
+    * [Sol3](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_01/sol3.py)
+    * [Sol4](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_01/sol4.py)
+    * [Sol5](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_01/sol5.py)
+    * [Sol6](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_01/sol6.py)
+    * [Sol7](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_01/sol7.py)
+  * Problem 02
+    * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_02/sol1.py)
+    * [Sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_02/sol2.py)
+    * [Sol3](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_02/sol3.py)
+    * [Sol4](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_02/sol4.py)
+    * [Sol5](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_02/sol5.py)
+  * Problem 03
+    * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_03/sol1.py)
+    * [Sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_03/sol2.py)
+  * Problem 04
+    * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_04/sol1.py)
+    * [Sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_04/sol2.py)
+  * Problem 05
+    * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_05/sol1.py)
+    * [Sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_05/sol2.py)
+  * Problem 06
+    * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_06/sol1.py)
+    * [Sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_06/sol2.py)
+    * [Sol3](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_06/sol3.py)
+    * [Sol4](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_06/sol4.py)
+  * Problem 07
+    * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_07/sol1.py)
+    * [Sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_07/sol2.py)
+    * [Sol3](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_07/sol3.py)
+  * Problem 08
+    * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_08/sol1.py)
+    * [Sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_08/sol2.py)
+  * Problem 09
+    * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_09/sol1.py)
+    * [Sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_09/sol2.py)
+    * [Sol3](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_09/sol3.py)
+  * Problem 10
+    * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_10/sol1.py)
+    * [Sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_10/sol2.py)
+    * [Sol3](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_10/sol3.py)
+  * Problem 11
+    * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_11/sol1.py)
+    * [Sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_11/sol2.py)
+  * Problem 12
+    * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_12/sol1.py)
+    * [Sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_12/sol2.py)
+  * Problem 13
+    * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_13/sol1.py)
+  * Problem 14
+    * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_14/sol1.py)
+    * [Sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_14/sol2.py)
+  * Problem 15
+    * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_15/sol1.py)
+  * Problem 16
+    * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_16/sol1.py)
+    * [Sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_16/sol2.py)
+  * Problem 17
+    * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_17/sol1.py)
+  * Problem 18
+    * [Solution](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_18/solution.py)
+  * Problem 19
+    * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_19/sol1.py)
+  * Problem 20
+    * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_20/sol1.py)
+    * [Sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_20/sol2.py)
+    * [Sol3](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_20/sol3.py)
+  * Problem 21
+    * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_21/sol1.py)
+  * Problem 22
+    * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_22/sol1.py)
+    * [Sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_22/sol2.py)
+  * Problem 23
+    * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_23/sol1.py)
+  * Problem 234
+    * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_234/sol1.py)
+  * Problem 24
+    * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_24/sol1.py)
+  * Problem 25
+    * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_25/sol1.py)
+    * [Sol2](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_25/sol2.py)
+  * Problem 28
+    * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_28/sol1.py)
+  * Problem 29
+    * [Solution](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_29/solution.py)
+  * Problem 31
+    * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_31/sol1.py)
+  * Problem 32
+    * [Sol32](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_32/sol32.py)
+  * Problem 36
+    * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_36/sol1.py)
+  * Problem 40
+    * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_40/sol1.py)
+  * Problem 42
+    * [Solution42](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_42/solution42.py)
+  * Problem 48
+    * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_48/sol1.py)
+  * Problem 52
+    * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_52/sol1.py)
+  * Problem 53
+    * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_53/sol1.py)
+  * Problem 551
+    * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_551/sol1.py)
+  * Problem 56
+    * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_56/sol1.py)
+  * Problem 67
+    * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_67/sol1.py)
+  * Problem 76
+    * [Sol1](https://github.com/TheAlgorithms/Python/blob/master/project_euler/problem_76/sol1.py)
 
 ## Searches
-
-- [binary search](https://github.com/TheAlgorithms/Python/blob/master/searches/binary_search.py)
-- [interpolation search](https://github.com/TheAlgorithms/Python/blob/master/searches/interpolation_search.py)
-- [jump search](https://github.com/TheAlgorithms/Python/blob/master/searches/jump_search.py)
-- [linear search](https://github.com/TheAlgorithms/Python/blob/master/searches/linear_search.py)
-- [quick select](https://github.com/TheAlgorithms/Python/blob/master/searches/quick_select.py)
-- [sentinel linear search](https://github.com/TheAlgorithms/Python/blob/master/searches/sentinel_linear_search.py)
-- [tabu search](https://github.com/TheAlgorithms/Python/blob/master/searches/tabu_search.py)
-- [ternary search](https://github.com/TheAlgorithms/Python/blob/master/searches/ternary_search.py)
+  * [Binary Search](https://github.com/TheAlgorithms/Python/blob/master/searches/binary_search.py)
+  * [Fibonacci Search](https://github.com/TheAlgorithms/Python/blob/master/searches/fibonacci_search.py)
+  * [Interpolation Search](https://github.com/TheAlgorithms/Python/blob/master/searches/interpolation_search.py)
+  * [Jump Search](https://github.com/TheAlgorithms/Python/blob/master/searches/jump_search.py)
+  * [Linear Search](https://github.com/TheAlgorithms/Python/blob/master/searches/linear_search.py)
+  * [Quick Select](https://github.com/TheAlgorithms/Python/blob/master/searches/quick_select.py)
+  * [Sentinel Linear Search](https://github.com/TheAlgorithms/Python/blob/master/searches/sentinel_linear_search.py)
+  * [Simple-Binary-Search](https://github.com/TheAlgorithms/Python/blob/master/searches/simple-binary-search.py)
+  * [Tabu Search](https://github.com/TheAlgorithms/Python/blob/master/searches/tabu_search.py)
+  * [Ternary Search](https://github.com/TheAlgorithms/Python/blob/master/searches/ternary_search.py)
 
 ## Sorts
-
-- [bitonic sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/bitonic_sort.py)
-- [bogo sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/bogo_sort.py)
-- [bubble sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/bubble_sort.py)
-- [bucket sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/bucket_sort.py)
-- [cocktail shaker sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/cocktail_shaker_sort.py)
-- [comb sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/comb_sort.py)
-- [counting sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/counting_sort.py)
-- [cycle sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/cycle_sort.py)
-- [external sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/external_sort.py)
-- [gnome sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/gnome_sort.py)
-- [heap sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/heap_sort.py)
-- [insertion sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/insertion_sort.py)
-- [merge sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/merge_sort.py)
-- [merge sort fastest](https://github.com/TheAlgorithms/Python/blob/master/sorts/merge_sort_fastest.py)
-- [odd even transposition parallel](https://github.com/TheAlgorithms/Python/blob/master/sorts/odd_even_transposition_parallel.py)
-- [odd even transposition single threaded](https://github.com/TheAlgorithms/Python/blob/master/sorts/odd_even_transposition_single_threaded.py)
-- [pancake sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/pancake_sort.py)
-- [pigeon sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/pigeon_sort.py)
-- [quick sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/quick_sort.py)
-- [quick sort 3 partition](https://github.com/TheAlgorithms/Python/blob/master/sorts/quick_sort_3_partition.py)
-- [radix sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/radix_sort.py)
-- [random normal distribution quicksort](https://github.com/TheAlgorithms/Python/blob/master/sorts/random_normal_distribution_quicksort.py)
-- [random pivot quick sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/random_pivot_quick_sort.py)
-- [selection sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/selection_sort.py)
-- [shell sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/shell_sort.py)
-- [tim sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/tim_sort.py)
-- [topological sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/topological_sort.py)
-- [tree sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/tree_sort.py)
-- [wiggle sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/wiggle_sort.py)
+  * [Bitonic Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/bitonic_sort.py)
+  * [Bogo Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/bogo_sort.py)
+  * [Bubble Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/bubble_sort.py)
+  * [Bucket Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/bucket_sort.py)
+  * [Cocktail Shaker Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/cocktail_shaker_sort.py)
+  * [Comb Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/comb_sort.py)
+  * [Counting Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/counting_sort.py)
+  * [Cycle Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/cycle_sort.py)
+  * [Double Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/double_sort.py)
+  * [External Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/external_sort.py)
+  * [Gnome Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/gnome_sort.py)
+  * [Heap Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/heap_sort.py)
+  * [I Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/i_sort.py)
+  * [Insertion Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/insertion_sort.py)
+  * [Merge Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/merge_sort.py)
+  * [Merge Sort Fastest](https://github.com/TheAlgorithms/Python/blob/master/sorts/merge_sort_fastest.py)
+  * [Odd Even Transposition Parallel](https://github.com/TheAlgorithms/Python/blob/master/sorts/odd_even_transposition_parallel.py)
+  * [Odd Even Transposition Single Threaded](https://github.com/TheAlgorithms/Python/blob/master/sorts/odd_even_transposition_single_threaded.py)
+  * [Pancake Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/pancake_sort.py)
+  * [Pigeon Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/pigeon_sort.py)
+  * [Quick Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/quick_sort.py)
+  * [Quick Sort 3 Partition](https://github.com/TheAlgorithms/Python/blob/master/sorts/quick_sort_3_partition.py)
+  * [Radix Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/radix_sort.py)
+  * [Random Normal Distribution Quicksort](https://github.com/TheAlgorithms/Python/blob/master/sorts/random_normal_distribution_quicksort.py)
+  * [Random Pivot Quick Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/random_pivot_quick_sort.py)
+  * [Selection Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/selection_sort.py)
+  * [Shell Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/shell_sort.py)
+  * [Stooge Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/stooge_sort.py)
+  * [Tim Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/tim_sort.py)
+  * [Topological Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/topological_sort.py)
+  * [Tree Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/tree_sort.py)
+  * [Wiggle Sort](https://github.com/TheAlgorithms/Python/blob/master/sorts/wiggle_sort.py)
 
 ## Strings
-
-- [boyer moore search](https://github.com/TheAlgorithms/Python/blob/master/strings/boyer_moore_search.py)
-- [knuth morris pratt](https://github.com/TheAlgorithms/Python/blob/master/strings/knuth_morris_pratt.py)
-- [levenshtein distance](https://github.com/TheAlgorithms/Python/blob/master/strings/levenshtein_distance.py)
-- [manacher](https://github.com/TheAlgorithms/Python/blob/master/strings/manacher.py)
-- [min cost string conversion](https://github.com/TheAlgorithms/Python/blob/master/strings/min_cost_string_conversion.py)
-- [naive string search](https://github.com/TheAlgorithms/Python/blob/master/strings/naive_string_search.py)
-- [rabin karp](https://github.com/TheAlgorithms/Python/blob/master/strings/rabin_karp.py)
+  * [Aho-Corasick](https://github.com/TheAlgorithms/Python/blob/master/strings/aho-corasick.py)
+  * [Boyer Moore Search](https://github.com/TheAlgorithms/Python/blob/master/strings/boyer_moore_search.py)
+  * [Knuth Morris Pratt](https://github.com/TheAlgorithms/Python/blob/master/strings/knuth_morris_pratt.py)
+  * [Levenshtein Distance](https://github.com/TheAlgorithms/Python/blob/master/strings/levenshtein_distance.py)
+  * [Manacher](https://github.com/TheAlgorithms/Python/blob/master/strings/manacher.py)
+  * [Min Cost String Conversion](https://github.com/TheAlgorithms/Python/blob/master/strings/min_cost_string_conversion.py)
+  * [Naive String Search](https://github.com/TheAlgorithms/Python/blob/master/strings/naive_string_search.py)
+  * [Rabin Karp](https://github.com/TheAlgorithms/Python/blob/master/strings/rabin_karp.py)
 
 ## Traversals
+  * [Binary Tree Traversals](https://github.com/TheAlgorithms/Python/blob/master/traversals/binary_tree_traversals.py)
 
-- [binary tree traversals](https://github.com/TheAlgorithms/Python/blob/master/traversals/binary_tree_traversals.py)
+## Web Programming
+  * [Crawl Google Results](https://github.com/TheAlgorithms/Python/blob/master/web_programming/crawl_google_results.py)
diff --git a/scripts/build_directory_md.py b/scripts/build_directory_md.py
index 2ebd445b3667..1043e6ccb696 100755
--- a/scripts/build_directory_md.py
+++ b/scripts/build_directory_md.py
@@ -17,7 +17,7 @@ def good_filepaths(top_dir: str = ".") -> Iterator[str]:
 
 
 def md_prefix(i):
-    return f"{i * '  '}*" if i else "##"
+    return f"{i * '  '}*" if i else "\n##"
 
 
 def print_path(old_path: str, new_path: str) -> str:
@@ -37,7 +37,7 @@ def print_directory_md(top_dir: str = ".") -> None:
             old_path = print_path(old_path, filepath)
         indent = (filepath.count(os.sep) + 1) if filepath else 0
         url = "/".join((URL_BASE, filepath, filename)).replace(" ", "%20")
-        filename = os.path.splitext(filename.replace("_", " "))[0]
+        filename = os.path.splitext(filename.replace("_", " ").title())[0]
         print(f"{md_prefix(indent)} [{filename}]({url})")
 
 

From a57809af9c7611ae119b44b3279fee6f7ce7049c Mon Sep 17 00:00:00 2001
From: prathmesh1199 <51616294+prathmesh1199@users.noreply.github.com>
Date: Sat, 26 Oct 2019 14:48:28 +0530
Subject: [PATCH 312/348] Added binomial coefficient (#1467)

* Added binomial coefficient

* Format code with psf/black and add a doctest
---
 maths/binomial_coefficient.py | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 maths/binomial_coefficient.py

diff --git a/maths/binomial_coefficient.py b/maths/binomial_coefficient.py
new file mode 100644
index 000000000000..4def041492f3
--- /dev/null
+++ b/maths/binomial_coefficient.py
@@ -0,0 +1,20 @@
+def binomial_coefficient(n, r):
+    """
+    Find binomial coefficient using pascals triangle.
+
+    >>> binomial_coefficient(10, 5)
+    252
+    """
+    C = [0 for i in range(r + 1)]
+    # nc0 = 1
+    C[0] = 1
+    for i in range(1, n + 1):
+        # to compute current row from previous row.
+        j = min(i, r)
+        while j > 0:
+            C[j] += C[j - 1]
+            j -= 1
+    return C[r]
+
+
+print(binomial_coefficient(n=10, r=5))

From bc52aa6d4d5c96322817b5073d5308739f8c188b Mon Sep 17 00:00:00 2001
From: ArjunwadkarAjay <41279300+ArjunwadkarAjay@users.noreply.github.com>
Date: Sun, 27 Oct 2019 23:07:25 +0530
Subject: [PATCH 313/348] Some grammatical and spelling corrections (#1475)

---
 maths/collatz_sequence.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/maths/collatz_sequence.py b/maths/collatz_sequence.py
index c83da3f0f0e8..a5f044a62b18 100644
--- a/maths/collatz_sequence.py
+++ b/maths/collatz_sequence.py
@@ -1,16 +1,16 @@
 def collatz_sequence(n):
     """
-    Collatz conjecture: start with any positive integer n.Next termis obtained from the previous term as follows: 
-    if the previous term is even, the next term is one half the previous term. 
+    Collatz conjecture: start with any positive integer n.Next term is obtained from the previous term as follows: 
+    if the previous term is even, the next term is one half of the previous term. 
     If the previous term is odd, the next term is 3 times the previous term plus 1. 
-    The conjecture states the sequence will always reach 1 regaardess of starting n.
+    The conjecture states the sequence will always reach 1 regaardless of starting value n.
     Example:
     >>> collatz_sequence(43)
     [43, 130, 65, 196, 98, 49, 148, 74, 37, 112, 56, 28, 14, 7, 22, 11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1]
     """
     sequence = [n]
     while n != 1:
-        if n % 2 == 0:  # even
+        if n % 2 == 0:  # even number condition
             n //= 2
         else:
             n = 3 * n + 1

From a7078d7c27df2ee1fd096635c06d599a6b20ade9 Mon Sep 17 00:00:00 2001
From: Suad Djelili <suadjelili@gmail.com>
Date: Sun, 27 Oct 2019 21:07:04 +0300
Subject: [PATCH 314/348] added solution 4 for problem_20 (#1476)

---
 project_euler/problem_20/sol4.py | 40 ++++++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)
 create mode 100644 project_euler/problem_20/sol4.py

diff --git a/project_euler/problem_20/sol4.py b/project_euler/problem_20/sol4.py
new file mode 100644
index 000000000000..50ebca5a0bf7
--- /dev/null
+++ b/project_euler/problem_20/sol4.py
@@ -0,0 +1,40 @@
+"""
+n! means n × (n − 1) × ... × 3 × 2 × 1
+
+For example, 10! = 10 × 9 × ... × 3 × 2 × 1 = 3628800,
+and the sum of the digits in the number 10! is 3 + 6 + 2 + 8 + 8 + 0 + 0 = 27.
+
+Find the sum of the digits in the number 100!
+"""
+
+
+def solution(n):
+    """Returns the sum of the digits in the number 100!
+    >>> solution(100)
+    648
+    >>> solution(50)
+    216
+    >>> solution(10)
+    27
+    >>> solution(5)
+    3
+    >>> solution(3)
+    6
+    >>> solution(2)
+    2
+    >>> solution(1)
+    1
+    """
+    fact = 1
+    result = 0
+    for i in range(1,n + 1):
+        fact *= i
+
+    for j in str(fact):
+        result += int(j)
+
+    return result
+
+
+if __name__ == "__main__":
+    print(solution(int(input("Enter the Number: ").strip())))

From 8b52e442307d3d8a6f18468964381e2c2df16b33 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Orkun=20=C4=B0ncili?= <orkunincili0@gmail.com>
Date: Sun, 27 Oct 2019 23:48:38 +0300
Subject: [PATCH 315/348] Python program that listing top 'n' movie in imdb
 (#1477)

* Python program that listing top 'n' movie in imdb

* Update get_imdbtop.py
---
 web_programming/get_imdbtop.py | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 web_programming/get_imdbtop.py

diff --git a/web_programming/get_imdbtop.py b/web_programming/get_imdbtop.py
new file mode 100644
index 000000000000..95fbeba7a772
--- /dev/null
+++ b/web_programming/get_imdbtop.py
@@ -0,0 +1,18 @@
+from bs4 import BeautifulSoup
+import requests
+
+
+def imdb_top(imdb_top_n):
+    base_url = (f"https://www.imdb.com/search/title?title_type="
+                f"feature&sort=num_votes,desc&count={imdb_top_n}")
+    source = BeautifulSoup(requests.get(base_url).content, "html.parser")
+    for m in source.findAll("div", class_="lister-item mode-advanced"):
+        print("\n" + m.h3.a.text)  # movie's name
+        print(m.find("span", attrs={"class": "genre"}).text)  # genre
+        print(m.strong.text)  # movie's rating
+        print(f"https://www.imdb.com{m.a.get('href')}")  # movie's page link
+        print("*" * 40)
+
+
+if __name__ == "__main__":
+    imdb_top(input("How many movies would you like to see? "))

From 39c40e7e40b908d31f7cb1dd9d46f1277bb2e343 Mon Sep 17 00:00:00 2001
From: Suad Djelili <suadjelili@gmail.com>
Date: Mon, 28 Oct 2019 02:52:34 +0300
Subject: [PATCH 316/348] added solution 3 for problem_25 (#1478)

* added solution 4 for problem_20

* added solution 3 for problem_25
---
 project_euler/problem_25/sol3.py | 57 ++++++++++++++++++++++++++++++++
 1 file changed, 57 insertions(+)
 create mode 100644 project_euler/problem_25/sol3.py

diff --git a/project_euler/problem_25/sol3.py b/project_euler/problem_25/sol3.py
new file mode 100644
index 000000000000..4e3084ce5456
--- /dev/null
+++ b/project_euler/problem_25/sol3.py
@@ -0,0 +1,57 @@
+# -*- coding: utf-8 -*-
+"""
+The Fibonacci sequence is defined by the recurrence relation:
+
+    Fn = Fn−1 + Fn−2, where F1 = 1 and F2 = 1.
+
+Hence the first 12 terms will be:
+
+    F1 = 1
+    F2 = 1
+    F3 = 2
+    F4 = 3
+    F5 = 5
+    F6 = 8
+    F7 = 13
+    F8 = 21
+    F9 = 34
+    F10 = 55
+    F11 = 89
+    F12 = 144
+
+The 12th term, F12, is the first term to contain three digits.
+
+What is the index of the first term in the Fibonacci sequence to contain 1000
+digits?
+"""
+
+
+def solution(n):
+    """Returns the index of the first term in the Fibonacci sequence to contain
+    n digits.
+
+    >>> solution(1000)
+    4782
+    >>> solution(100)
+    476
+    >>> solution(50)
+    237
+    >>> solution(3)
+    12
+    """
+    f1, f2 = 1, 1
+    index = 2
+    while True:
+        i = 0
+        f = f1 + f2
+        f1, f2 = f2, f
+        index += 1
+        for j in str(f):
+            i += 1
+        if i == n:
+            break
+    return index
+
+
+if __name__ == "__main__":
+    print(solution(int(str(input()).strip())))

From 8a5b1abd0a2a110db80d4a67c0db979ce3c4cf4e Mon Sep 17 00:00:00 2001
From: Deekshaesha <57080015+Deekshaesha@users.noreply.github.com>
Date: Mon, 28 Oct 2019 13:44:53 +0530
Subject: [PATCH 317/348] finding max  (#1488)

* Update find_max.py

* Update find_max.py

* Format with psf/black and add doctests
---
 maths/find_max.py | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/maths/find_max.py b/maths/find_max.py
index 7cc82aacfb09..8b5ab48e6185 100644
--- a/maths/find_max.py
+++ b/maths/find_max.py
@@ -2,15 +2,23 @@
 
 
 def find_max(nums):
+    """
+    >>> for nums in ([3, 2, 1], [-3, -2, -1], [3, -3, 0], [3.0, 3.1, 2.9]):
+    ...     find_max(nums) == max(nums)
+    True
+    True
+    True
+    True
+    """
     max = nums[0]
     for x in nums:
         if x > max:
             max = x
-    print(max)
+    return max
 
 
 def main():
-    find_max([2, 4, 9, 7, 19, 94, 5])
+    print(find_max([2, 4, 9, 7, 19, 94, 5]))  # 94
 
 
 if __name__ == "__main__":

From e36fe34b0b00588d8665b53918d9cdf40d5fee98 Mon Sep 17 00:00:00 2001
From: arjun1299 <arjun1299@gmail.com>
Date: Mon, 28 Oct 2019 17:36:28 +0530
Subject: [PATCH 318/348] Hard coded inputs to mixed_keyword cypher (#1500)

* Update morse_code_implementation.py

* Delete porta_cipher.py

* Update mixed_keyword_cypher.py

* Mixed keyword cypher added

* issue with mixed keyword fixed

* no math included

* hardcoded inputs

* porta cypher added

* porta cypher added

* commented in mixed keyword according to contrib.md
---
 ciphers/mixed_keyword_cypher.py | 71 +++++++++++++++++++++++++++++++++
 1 file changed, 71 insertions(+)
 create mode 100644 ciphers/mixed_keyword_cypher.py

diff --git a/ciphers/mixed_keyword_cypher.py b/ciphers/mixed_keyword_cypher.py
new file mode 100644
index 000000000000..c8d3ad6a535f
--- /dev/null
+++ b/ciphers/mixed_keyword_cypher.py
@@ -0,0 +1,71 @@
+def mixed_keyword(key="college", pt="UNIVERSITY"):
+    """
+
+    For key:hello
+
+    H E L O
+    A B C D
+    F G I J
+    K M N P
+    Q R S T
+    U V W X
+    Y Z
+    and map vertically
+
+    >>> mixed_keyword("college", "UNIVERSITY")  # doctest: +NORMALIZE_WHITESPACE
+    {'A': 'C', 'B': 'A', 'C': 'I', 'D': 'P', 'E': 'U', 'F': 'Z', 'G': 'O', 'H': 'B',
+     'I': 'J', 'J': 'Q', 'K': 'V', 'L': 'L', 'M': 'D', 'N': 'K', 'O': 'R', 'P': 'W',
+     'Q': 'E', 'R': 'F', 'S': 'M', 'T': 'S', 'U': 'X', 'V': 'G', 'W': 'H', 'X': 'N',
+     'Y': 'T', 'Z': 'Y'}
+    'XKJGUFMJST'
+    """
+    key = key.upper()
+    pt = pt.upper()
+    temp = []
+    for i in key:
+        if i not in temp:
+            temp.append(i)
+    l = len(temp)
+    # print(temp)
+    alpha = []
+    modalpha = []
+    # modalpha.append(temp)
+    dic = dict()
+    c = 0
+    for i in range(65, 91):
+        t = chr(i)
+        alpha.append(t)
+        if t not in temp:
+            temp.append(t)
+    # print(temp)
+    r = int(26 / 4)
+    # print(r)
+    k = 0
+    for i in range(r):
+        t = []
+        for j in range(l):
+            t.append(temp[k])
+            if not (k < 25):
+                break
+            k += 1
+        modalpha.append(t)
+    # print(modalpha)
+    d = dict()
+    j = 0
+    k = 0
+    for j in range(l):
+        for i in modalpha:
+            if not (len(i) - 1 >= j):
+                break
+            d[alpha[k]] = i[j]
+            if not k < 25:
+                break
+            k += 1
+    print(d)
+    cypher = ""
+    for i in pt:
+        cypher += d[i]
+    return cypher
+
+
+print(mixed_keyword("college", "UNIVERSITY"))

From bf50ea09aea7ab24fe6591b0542c19e4bac0f87a Mon Sep 17 00:00:00 2001
From: Christian Clauss <cclauss@me.com>
Date: Mon, 28 Oct 2019 13:38:08 +0100
Subject: [PATCH 319/348] Add Travis_CI_tests_are_failing.md (#1499)

* Add Travis_CI_tests_are_failing.md

* Update Travis_CI_tests_are_failing.md
---
 Travis_CI_tests_are_failing.md |   9 +++++++++
 images/Travis_CI_fail_1.png    | Bin 0 -> 80257 bytes
 images/Travis_CI_fail_2.png    | Bin 0 -> 45660 bytes
 3 files changed, 9 insertions(+)
 create mode 100644 Travis_CI_tests_are_failing.md
 create mode 100644 images/Travis_CI_fail_1.png
 create mode 100644 images/Travis_CI_fail_2.png

diff --git a/Travis_CI_tests_are_failing.md b/Travis_CI_tests_are_failing.md
new file mode 100644
index 000000000000..10bf5a6655d2
--- /dev/null
+++ b/Travis_CI_tests_are_failing.md
@@ -0,0 +1,9 @@
+# Travis CI test are failing
+### How do I find out what is wrong with my pull request?
+1. In your PR look for the failing test and click the `Details` link: ![Travis_CI_fail_1.png](images/Travis_CI_fail_1.png)
+2. On the next page, click `The build failed` link: ![Travis_CI_fail_2.png](images/Travis_CI_fail_2.png)
+3. Now scroll down and look for `red` text describing the error(s) in the test log.
+
+Pull requests will __not__ be merged if the Travis CI tests are failing.
+
+If anything is unclear, please read through [CONTRIBUTING.md](CONTRIBUTING.md) and attempt to run the failing tests on your computer before asking for assistance.
diff --git a/images/Travis_CI_fail_1.png b/images/Travis_CI_fail_1.png
new file mode 100644
index 0000000000000000000000000000000000000000..451e54e4844a0b9f7d501c3d7682869d9acd97fc
GIT binary patch
literal 80257
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

literal 0
HcmV?d00001

diff --git a/images/Travis_CI_fail_2.png b/images/Travis_CI_fail_2.png
new file mode 100644
index 0000000000000000000000000000000000000000..caa406099da12215efb783b13ae780c4c052fe7d
GIT binary patch
literal 45660
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

literal 0
HcmV?d00001


From 3fc276ca2c53a158619d33104931183833c796a7 Mon Sep 17 00:00:00 2001
From: Du YuanChao <shellhub.me@gmail.com>
Date: Mon, 28 Oct 2019 20:50:36 +0800
Subject: [PATCH 320/348] rename and add doctest (#1501)

---
 maths/find_max.py |  8 ++++----
 maths/find_min.py | 30 +++++++++++++++++++-----------
 2 files changed, 23 insertions(+), 15 deletions(-)

diff --git a/maths/find_max.py b/maths/find_max.py
index 8b5ab48e6185..4d92e37eb2e1 100644
--- a/maths/find_max.py
+++ b/maths/find_max.py
@@ -10,11 +10,11 @@ def find_max(nums):
     True
     True
     """
-    max = nums[0]
+    max_num = nums[0]
     for x in nums:
-        if x > max:
-            max = x
-    return max
+        if x > max_num:
+            max_num = x
+    return max_num
 
 
 def main():
diff --git a/maths/find_min.py b/maths/find_min.py
index e24982a9369b..4d721ce82194 100644
--- a/maths/find_min.py
+++ b/maths/find_min.py
@@ -1,17 +1,25 @@
-"""Find Minimum Number in a List."""
+def find_min(nums):
+    """
+    Find Minimum Number in a List
+    :param nums: contains elements
+    :return: max number in list
 
+    >>> for nums in ([3, 2, 1], [-3, -2, -1], [3, -3, 0], [3.0, 3.1, 2.9]):
+    ...     find_min(nums) == min(nums)
+    True
+    True
+    True
+    True
+    """
+    min_num = nums[0]
+    for num in nums:
+        if min_num > num:
+            min_num = num
+    return min_num
 
-def main():
-    """Find Minimum Number in a List."""
-
-    def find_min(x):
-        min_num = x[0]
-        for i in x:
-            if min_num > i:
-                min_num = i
-        return min_num
 
-    print(find_min([0, 1, 2, 3, 4, 5, -3, 24, -56]))  # = -56
+def main():
+    assert find_min([0, 1, 2, 3, 4, 5, -3, 24, -56]) == -56
 
 
 if __name__ == "__main__":

From 1da1ab0773e8cb74693dc53b29a0511f83c94098 Mon Sep 17 00:00:00 2001
From: John Law <johnlaw.po@gmail.com>
Date: Tue, 29 Oct 2019 00:44:57 +0800
Subject: [PATCH 321/348] Improve doctest and comment for maximum sub-array
 problem (#1503)

* Doctest and comment for maximum sub-array problem

More examples and description for max_sub_array.py

* Update max_sub_array.py

* Update max_sub_array.py

* Fix doctest
---
 dynamic_programming/max_sub_array.py | 25 ++++++++++++++++++-------
 1 file changed, 18 insertions(+), 7 deletions(-)

diff --git a/dynamic_programming/max_sub_array.py b/dynamic_programming/max_sub_array.py
index eb6ab41bf52d..f7c8209718ef 100644
--- a/dynamic_programming/max_sub_array.py
+++ b/dynamic_programming/max_sub_array.py
@@ -2,9 +2,6 @@
 author : Mayank Kumar Jha (mk9440)
 """
 from typing import List
-import time
-import matplotlib.pyplot as plt
-from random import randint
 
 
 def find_max_sub_array(A, low, high):
@@ -43,15 +40,23 @@ def find_max_cross_sum(A, low, mid, high):
 
 def max_sub_array(nums: List[int]) -> int:
     """
-     Finds the contiguous subarray (can be empty array)
-     which has the largest sum and return its sum.
+    Finds the contiguous subarray which has the largest sum and return its sum.
 
-    >>> max_sub_array([-2,1,-3,4,-1,2,1,-5,4])
+    >>> max_sub_array([-2, 1, -3, 4, -1, 2, 1, -5, 4])
     6
+    
+    An empty (sub)array has sum 0.
     >>> max_sub_array([])
     0
-    >>> max_sub_array([-1,-2,-3])
+    
+    If all elements are negative, the largest subarray would be the empty array, 
+    having the sum 0.
+    >>> max_sub_array([-1, -2, -3])
     0
+    >>> max_sub_array([5, -2, -3])
+    5
+    >>> max_sub_array([31, -41, 59, 26, -53, 58, 97, -93, -23, 84])
+    187
     """
     best = 0
     current = 0
@@ -64,6 +69,12 @@ def max_sub_array(nums: List[int]) -> int:
 
 
 if __name__ == "__main__":
+    """
+    A random simulation of this algorithm.
+    """
+    import time
+    import matplotlib.pyplot as plt
+    from random import randint
     inputs = [10, 100, 1000, 10000, 50000, 100000, 200000, 300000, 400000, 500000]
     tim = []
     for i in inputs:

From 3ada8bb580d64a06d88a3613ba31e41b010f2a45 Mon Sep 17 00:00:00 2001
From: Phileas <phileas.hocquard@gmail.com>
Date: Mon, 28 Oct 2019 14:04:26 -0400
Subject: [PATCH 322/348] Page replacement algorithm, LRU (#871)

* Page replacement algorithm, LRU

* small rectifications

* Rename paging/LRU.py to other/least_recently_used.py
---
 other/least_recently_used.py | 62 ++++++++++++++++++++++++++++++++++++
 1 file changed, 62 insertions(+)
 create mode 100644 other/least_recently_used.py

diff --git a/other/least_recently_used.py b/other/least_recently_used.py
new file mode 100644
index 000000000000..2932e9c185e8
--- /dev/null
+++ b/other/least_recently_used.py
@@ -0,0 +1,62 @@
+from abc import abstractmethod
+import sys
+from collections import deque
+
+class LRUCache:
+    """ Page Replacement Algorithm, Least Recently Used (LRU) Caching."""
+
+    dq_store = object() # Cache store of keys
+    key_reference_map = object() # References of the keys in cache
+    _MAX_CAPACITY: int = 10 # Maximum capacity of cache
+
+    @abstractmethod
+    def __init__(self, n: int):
+        """ Creates an empty store and map for the keys.
+        The LRUCache is set the size n.
+        """
+        self.dq_store = deque()
+        self.key_reference_map = set()
+        if not n:
+            LRUCache._MAX_CAPACITY = sys.maxsize
+        elif n < 0:
+            raise ValueError('n should be an integer greater than 0.')
+        else:
+            LRUCache._MAX_CAPACITY = n
+
+    def refer(self, x):
+        """
+            Looks for a page in the cache store and adds reference to the set.
+            Remove the least recently used key if the store is full.
+            Update store to reflect recent access.
+        """
+        if x not in self.key_reference_map:
+            if len(self.dq_store) == LRUCache._MAX_CAPACITY:
+                last_element = self.dq_store.pop()
+                self.key_reference_map.remove(last_element)
+        else:
+            index_remove = 0
+            for idx, key in enumerate(self.dq_store):
+                if key == x:
+                    index_remove = idx
+                    break
+            self.dq_store.remove(index_remove)
+
+        self.dq_store.appendleft(x)
+        self.key_reference_map.add(x)
+
+    def display(self):
+        """
+            Prints all the elements in the store.
+        """
+        for k in self.dq_store:
+            print(k)
+
+if __name__ == "__main__":
+    lru_cache = LRUCache(4)
+    lru_cache.refer(1)
+    lru_cache.refer(2)
+    lru_cache.refer(3)
+    lru_cache.refer(1)
+    lru_cache.refer(4)
+    lru_cache.refer(5)
+    lru_cache.display()

From f8a30b42cea154d190544216b92d204c832de784 Mon Sep 17 00:00:00 2001
From: dimgrichr <32580033+dimgrichr@users.noreply.github.com>
Date: Mon, 28 Oct 2019 20:27:00 +0200
Subject: [PATCH 323/348] Addition of Secant Method (#876)

* Add files via upload

* Update secant_method.py

* Remove unused import

* Remove unused import
---
 arithmetic_analysis/secant_method.py | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 arithmetic_analysis/secant_method.py

diff --git a/arithmetic_analysis/secant_method.py b/arithmetic_analysis/secant_method.py
new file mode 100644
index 000000000000..b05d44c627d8
--- /dev/null
+++ b/arithmetic_analysis/secant_method.py
@@ -0,0 +1,28 @@
+# Implementing Secant method in Python
+# Author: dimgrichr
+
+
+from math import exp
+
+
+def f(x):
+    """
+    >>> f(5)
+    39.98652410600183
+    """
+    return 8 * x - 2 * exp(-x)
+
+
+def SecantMethod(lower_bound, upper_bound, repeats):
+    """
+    >>> SecantMethod(1, 3, 2)
+    0.2139409276214589
+    """
+    x0 = lower_bound
+    x1 = upper_bound
+    for i in range(0, repeats):
+        x0, x1 = x1, x1 - (f(x1) * (x1 - x0)) / (f(x1) - f(x0))
+    return x1
+
+
+print(f"The solution is: {SecantMethod(1, 3, 2)}")

From 4f86f5848275bf87437a698531b6069f8e4938b8 Mon Sep 17 00:00:00 2001
From: Devil Lord <46564519+DevilLord9967@users.noreply.github.com>
Date: Mon, 28 Oct 2019 23:59:08 +0530
Subject: [PATCH 324/348] Create GAN.py (#1445)

* Create GAN.py

* gan update

* Delete train-labels-idx1-ubyte.gz

* Update GAN.py

* Update GAN.py

* Delete GAN.py

* Create gan.py

* Update gan.py

* input_data import file
---
 neural_network/gan.py        | 391 +++++++++++++++++++++++++++++++++++
 neural_network/input_data.py | 332 +++++++++++++++++++++++++++++
 2 files changed, 723 insertions(+)
 create mode 100644 neural_network/gan.py
 create mode 100644 neural_network/input_data.py

diff --git a/neural_network/gan.py b/neural_network/gan.py
new file mode 100644
index 000000000000..edfff420547b
--- /dev/null
+++ b/neural_network/gan.py
@@ -0,0 +1,391 @@
+import matplotlib.gridspec as gridspec
+import matplotlib.pyplot as plt
+import numpy as np
+from sklearn.utils import shuffle
+import input_data
+
+random_numer = 42
+
+np.random.seed(random_numer)
+def ReLu(x):
+    mask = (x>0) * 1.0
+    return mask *x
+def d_ReLu(x):
+    mask = (x>0) * 1.0
+    return mask
+
+def arctan(x):
+    return np.arctan(x)
+def d_arctan(x):
+    return 1 / (1 + x ** 2)
+
+def log(x):
+    return 1 / ( 1+ np.exp(-1*x))
+def d_log(x):
+    return log(x) * (1 - log(x))
+
+def tanh(x):
+    return np.tanh(x)
+def d_tanh(x):
+    return 1 - np.tanh(x) ** 2
+
+def plot(samples):
+    fig = plt.figure(figsize=(4, 4))
+    gs = gridspec.GridSpec(4, 4)
+    gs.update(wspace=0.05, hspace=0.05)
+
+    for i, sample in enumerate(samples):
+        ax = plt.subplot(gs[i])
+        plt.axis('off')
+        ax.set_xticklabels([])
+        ax.set_yticklabels([])
+        ax.set_aspect('equal')
+        plt.imshow(sample.reshape(28, 28), cmap='Greys_r')
+
+    return fig
+
+
+
+# 1. Load Data and declare hyper
+print('--------- Load Data ----------')
+mnist = input_data.read_data_sets('MNIST_data', one_hot=False)
+temp = mnist.test
+images, labels = temp.images, temp.labels
+images, labels = shuffle(np.asarray(images),np.asarray(labels))
+num_epoch = 10
+learing_rate = 0.00009
+G_input = 100
+hidden_input,hidden_input2,hidden_input3 = 128,256,346
+hidden_input4,hidden_input5,hidden_input6 = 480,560,686
+
+
+
+print('--------- Declare Hyper Parameters ----------')
+# 2. Declare Weights
+D_W1 = np.random.normal(size=(784,hidden_input),scale=(1. / np.sqrt(784 / 2.)))   *0.002
+# D_b1 = np.random.normal(size=(128),scale=(1. / np.sqrt(128 / 2.)))       *0.002
+D_b1 = np.zeros(hidden_input)
+
+D_W2 = np.random.normal(size=(hidden_input,1),scale=(1. / np.sqrt(hidden_input / 2.)))     *0.002
+# D_b2 = np.random.normal(size=(1),scale=(1. / np.sqrt(1 / 2.)))           *0.002
+D_b2 = np.zeros(1)
+
+
+G_W1 = np.random.normal(size=(G_input,hidden_input),scale=(1. / np.sqrt(G_input / 2.)))   *0.002
+# G_b1 = np.random.normal(size=(128),scale=(1. / np.sqrt(128 / 2.)))      *0.002
+G_b1 = np.zeros(hidden_input)
+
+G_W2 = np.random.normal(size=(hidden_input,hidden_input2),scale=(1. / np.sqrt(hidden_input / 2.)))   *0.002
+# G_b1 = np.random.normal(size=(128),scale=(1. / np.sqrt(128 / 2.)))      *0.002
+G_b2 = np.zeros(hidden_input2)
+
+G_W3 = np.random.normal(size=(hidden_input2,hidden_input3),scale=(1. / np.sqrt(hidden_input2 / 2.)))   *0.002
+# G_b1 = np.random.normal(size=(128),scale=(1. / np.sqrt(128 / 2.)))      *0.002
+G_b3 = np.zeros(hidden_input3)
+
+G_W4 = np.random.normal(size=(hidden_input3,hidden_input4),scale=(1. / np.sqrt(hidden_input3 / 2.)))   *0.002
+# G_b1 = np.random.normal(size=(128),scale=(1. / np.sqrt(128 / 2.)))      *0.002
+G_b4 = np.zeros(hidden_input4)
+
+G_W5 = np.random.normal(size=(hidden_input4,hidden_input5),scale=(1. / np.sqrt(hidden_input4 / 2.)))   *0.002
+# G_b1 = np.random.normal(size=(128),scale=(1. / np.sqrt(128 / 2.)))      *0.002
+G_b5 = np.zeros(hidden_input5)
+
+G_W6 = np.random.normal(size=(hidden_input5,hidden_input6),scale=(1. / np.sqrt(hidden_input5 / 2.)))   *0.002
+# G_b1 = np.random.normal(size=(128),scale=(1. / np.sqrt(128 / 2.)))      *0.002
+G_b6 = np.zeros(hidden_input6)
+
+G_W7 = np.random.normal(size=(hidden_input6,784),scale=(1. / np.sqrt(hidden_input6 / 2.)))  *0.002
+# G_b2 = np.random.normal(size=(784),scale=(1. / np.sqrt(784 / 2.)))      *0.002
+G_b7 = np.zeros(784)
+
+# 3. For Adam Optimzier
+v1,m1 = 0,0
+v2,m2 = 0,0
+v3,m3 = 0,0
+v4,m4 = 0,0
+
+v5,m5 = 0,0
+v6,m6 = 0,0
+v7,m7 = 0,0
+v8,m8 = 0,0
+v9,m9 = 0,0
+v10,m10 = 0,0
+v11,m11 = 0,0
+v12,m12 = 0,0
+
+v13,m13 = 0,0
+v14,m14 = 0,0
+
+v15,m15 = 0,0
+v16,m16 = 0,0
+
+v17,m17 = 0,0
+v18,m18 = 0,0
+
+
+beta_1,beta_2,eps = 0.9,0.999,0.00000001
+
+print('--------- Started Training ----------')
+for iter in range(num_epoch):
+
+    random_int = np.random.randint(len(images) - 5)
+    current_image = np.expand_dims(images[random_int],axis=0)
+
+    # Func: Generate The first Fake Data
+    Z = np.random.uniform(-1., 1., size=[1, G_input])
+    Gl1 = Z.dot(G_W1) + G_b1
+    Gl1A = arctan(Gl1)
+    Gl2 = Gl1A.dot(G_W2) + G_b2
+    Gl2A = ReLu(Gl2)
+    Gl3 = Gl2A.dot(G_W3) + G_b3
+    Gl3A = arctan(Gl3)
+
+    Gl4 = Gl3A.dot(G_W4) + G_b4
+    Gl4A = ReLu(Gl4)
+    Gl5 = Gl4A.dot(G_W5) + G_b5
+    Gl5A = tanh(Gl5)
+    Gl6 = Gl5A.dot(G_W6) + G_b6
+    Gl6A = ReLu(Gl6)
+    Gl7 = Gl6A.dot(G_W7) + G_b7
+
+    current_fake_data = log(Gl7)
+
+    # Func: Forward Feed for Real data
+    Dl1_r = current_image.dot(D_W1) + D_b1
+    Dl1_rA = ReLu(Dl1_r)
+    Dl2_r = Dl1_rA.dot(D_W2) + D_b2
+    Dl2_rA = log(Dl2_r)
+
+    # Func: Forward Feed for Fake Data
+    Dl1_f = current_fake_data.dot(D_W1) + D_b1
+    Dl1_fA = ReLu(Dl1_f)
+    Dl2_f = Dl1_fA.dot(D_W2) + D_b2
+    Dl2_fA = log(Dl2_f)
+
+    # Func: Cost D
+    D_cost = -np.log(Dl2_rA) + np.log(1.0- Dl2_fA)
+
+    # Func: Gradient
+    grad_f_w2_part_1 =  1/(1.0- Dl2_fA)
+    grad_f_w2_part_2 =  d_log(Dl2_f)
+    grad_f_w2_part_3 =   Dl1_fA
+    grad_f_w2 =       grad_f_w2_part_3.T.dot(grad_f_w2_part_1 * grad_f_w2_part_2)
+    grad_f_b2 = grad_f_w2_part_1 * grad_f_w2_part_2
+
+    grad_f_w1_part_1 =  (grad_f_w2_part_1 * grad_f_w2_part_2).dot(D_W2.T)
+    grad_f_w1_part_2 =  d_ReLu(Dl1_f)
+    grad_f_w1_part_3 =   current_fake_data
+    grad_f_w1 =       grad_f_w1_part_3.T.dot(grad_f_w1_part_1 * grad_f_w1_part_2)
+    grad_f_b1 =      grad_f_w1_part_1 * grad_f_w1_part_2
+
+    grad_r_w2_part_1 =  - 1/Dl2_rA
+    grad_r_w2_part_2 =  d_log(Dl2_r)
+    grad_r_w2_part_3 =   Dl1_rA
+    grad_r_w2 =       grad_r_w2_part_3.T.dot(grad_r_w2_part_1 * grad_r_w2_part_2)
+    grad_r_b2 =       grad_r_w2_part_1 * grad_r_w2_part_2
+
+    grad_r_w1_part_1 =  (grad_r_w2_part_1 * grad_r_w2_part_2).dot(D_W2.T)
+    grad_r_w1_part_2 =  d_ReLu(Dl1_r)
+    grad_r_w1_part_3 =   current_image
+    grad_r_w1 =       grad_r_w1_part_3.T.dot(grad_r_w1_part_1 * grad_r_w1_part_2)
+    grad_r_b1 =       grad_r_w1_part_1 * grad_r_w1_part_2
+
+    grad_w1 =grad_f_w1 + grad_r_w1
+    grad_b1 =grad_f_b1 + grad_r_b1
+
+    grad_w2 =grad_f_w2 + grad_r_w2
+    grad_b2 =grad_f_b2 + grad_r_b2
+
+    # ---- Update Gradient ----
+    m1 = beta_1 * m1 + (1 - beta_1) * grad_w1
+    v1 = beta_2 * v1 + (1 - beta_2) * grad_w1 ** 2
+
+    m2 = beta_1 * m2 + (1 - beta_1) * grad_b1
+    v2 = beta_2 * v2 + (1 - beta_2) * grad_b1 ** 2
+
+    m3 = beta_1 * m3 + (1 - beta_1) * grad_w2
+    v3 = beta_2 * v3 + (1 - beta_2) * grad_w2 ** 2
+
+    m4 = beta_1 * m4 + (1 - beta_1) * grad_b2
+    v4 = beta_2 * v4 + (1 - beta_2) * grad_b2 ** 2
+
+    D_W1 = D_W1 - (learing_rate / (np.sqrt(v1 /(1-beta_2) ) + eps)) * (m1/(1-beta_1))
+    D_b1 = D_b1 - (learing_rate / (np.sqrt(v2 /(1-beta_2) ) + eps)) * (m2/(1-beta_1))
+
+    D_W2 = D_W2 - (learing_rate / (np.sqrt(v3 /(1-beta_2) ) + eps)) * (m3/(1-beta_1))
+    D_b2 = D_b2 - (learing_rate / (np.sqrt(v4 /(1-beta_2) ) + eps)) * (m4/(1-beta_1))
+
+    # Func: Forward Feed for G
+    Z = np.random.uniform(-1., 1., size=[1, G_input])
+    Gl1 = Z.dot(G_W1) + G_b1
+    Gl1A = arctan(Gl1)
+    Gl2 = Gl1A.dot(G_W2) + G_b2
+    Gl2A = ReLu(Gl2)
+    Gl3 = Gl2A.dot(G_W3) + G_b3
+    Gl3A = arctan(Gl3)
+
+    Gl4 = Gl3A.dot(G_W4) + G_b4
+    Gl4A = ReLu(Gl4)
+    Gl5 = Gl4A.dot(G_W5) + G_b5
+    Gl5A = tanh(Gl5)
+    Gl6 = Gl5A.dot(G_W6) + G_b6
+    Gl6A = ReLu(Gl6)
+    Gl7 = Gl6A.dot(G_W7) + G_b7
+
+    current_fake_data = log(Gl7)
+
+    Dl1 = current_fake_data.dot(D_W1) + D_b1
+    Dl1_A = ReLu(Dl1)
+    Dl2 = Dl1_A.dot(D_W2) + D_b2
+    Dl2_A = log(Dl2)
+
+    # Func: Cost G
+    G_cost = -np.log(Dl2_A)
+
+    # Func: Gradient
+    grad_G_w7_part_1 = ((-1/Dl2_A) * d_log(Dl2).dot(D_W2.T) * (d_ReLu(Dl1))).dot(D_W1.T)
+    grad_G_w7_part_2 = d_log(Gl7)
+    grad_G_w7_part_3 = Gl6A
+    grad_G_w7 = grad_G_w7_part_3.T.dot(grad_G_w7_part_1 * grad_G_w7_part_1)
+    grad_G_b7 = grad_G_w7_part_1 * grad_G_w7_part_2
+
+    grad_G_w6_part_1 = (grad_G_w7_part_1 * grad_G_w7_part_2).dot(G_W7.T)
+    grad_G_w6_part_2 = d_ReLu(Gl6)
+    grad_G_w6_part_3 = Gl5A
+    grad_G_w6 = grad_G_w6_part_3.T.dot(grad_G_w6_part_1 * grad_G_w6_part_2)
+    grad_G_b6 = (grad_G_w6_part_1 * grad_G_w6_part_2)
+
+    grad_G_w5_part_1 = (grad_G_w6_part_1 * grad_G_w6_part_2).dot(G_W6.T)
+    grad_G_w5_part_2 = d_tanh(Gl5)
+    grad_G_w5_part_3 = Gl4A
+    grad_G_w5 = grad_G_w5_part_3.T.dot(grad_G_w5_part_1 * grad_G_w5_part_2)
+    grad_G_b5 = (grad_G_w5_part_1 * grad_G_w5_part_2)
+
+    grad_G_w4_part_1 = (grad_G_w5_part_1 * grad_G_w5_part_2).dot(G_W5.T)
+    grad_G_w4_part_2 = d_ReLu(Gl4)
+    grad_G_w4_part_3 = Gl3A
+    grad_G_w4 = grad_G_w4_part_3.T.dot(grad_G_w4_part_1 * grad_G_w4_part_2)
+    grad_G_b4 = (grad_G_w4_part_1 * grad_G_w4_part_2)
+
+    grad_G_w3_part_1 = (grad_G_w4_part_1 * grad_G_w4_part_2).dot(G_W4.T)
+    grad_G_w3_part_2 = d_arctan(Gl3)
+    grad_G_w3_part_3 = Gl2A
+    grad_G_w3 = grad_G_w3_part_3.T.dot(grad_G_w3_part_1 * grad_G_w3_part_2)
+    grad_G_b3 = (grad_G_w3_part_1 * grad_G_w3_part_2)
+
+    grad_G_w2_part_1 = (grad_G_w3_part_1 * grad_G_w3_part_2).dot(G_W3.T)
+    grad_G_w2_part_2 = d_ReLu(Gl2)
+    grad_G_w2_part_3 = Gl1A
+    grad_G_w2 = grad_G_w2_part_3.T.dot(grad_G_w2_part_1 * grad_G_w2_part_2)
+    grad_G_b2 = (grad_G_w2_part_1 * grad_G_w2_part_2)
+
+    grad_G_w1_part_1 = (grad_G_w2_part_1 * grad_G_w2_part_2).dot(G_W2.T)
+    grad_G_w1_part_2 = d_arctan(Gl1)
+    grad_G_w1_part_3 = Z
+    grad_G_w1 = grad_G_w1_part_3.T.dot(grad_G_w1_part_1 * grad_G_w1_part_2)
+    grad_G_b1 = grad_G_w1_part_1 * grad_G_w1_part_2
+
+    # ---- Update Gradient ----
+    m5 = beta_1 * m5 + (1 - beta_1) * grad_G_w1
+    v5 = beta_2 * v5 + (1 - beta_2) * grad_G_w1 ** 2
+
+    m6 = beta_1 * m6 + (1 - beta_1) * grad_G_b1
+    v6 = beta_2 * v6 + (1 - beta_2) * grad_G_b1 ** 2
+
+    m7 = beta_1 * m7 + (1 - beta_1) * grad_G_w2
+    v7 = beta_2 * v7 + (1 - beta_2) * grad_G_w2 ** 2
+
+    m8 = beta_1 * m8 + (1 - beta_1) * grad_G_b2
+    v8 = beta_2 * v8 + (1 - beta_2) * grad_G_b2 ** 2
+
+    m9 = beta_1 * m9 + (1 - beta_1) * grad_G_w3
+    v9 = beta_2 * v9 + (1 - beta_2) * grad_G_w3 ** 2
+
+    m10 = beta_1 * m10 + (1 - beta_1) * grad_G_b3
+    v10 = beta_2 * v10 + (1 - beta_2) * grad_G_b3 ** 2
+
+    m11 = beta_1 * m11 + (1 - beta_1) * grad_G_w4
+    v11 = beta_2 * v11 + (1 - beta_2) * grad_G_w4 ** 2
+
+    m12 = beta_1 * m12 + (1 - beta_1) * grad_G_b4
+    v12 = beta_2 * v12 + (1 - beta_2) * grad_G_b4 ** 2
+
+    m13 = beta_1 * m13 + (1 - beta_1) * grad_G_w5
+    v13 = beta_2 * v13 + (1 - beta_2) * grad_G_w5 ** 2
+
+    m14 = beta_1 * m14 + (1 - beta_1) * grad_G_b5
+    v14 = beta_2 * v14 + (1 - beta_2) * grad_G_b5 ** 2
+
+    m15 = beta_1 * m15 + (1 - beta_1) * grad_G_w6
+    v15 = beta_2 * v15 + (1 - beta_2) * grad_G_w6 ** 2
+
+    m16 = beta_1 * m16 + (1 - beta_1) * grad_G_b6
+    v16 = beta_2 * v16 + (1 - beta_2) * grad_G_b6 ** 2
+
+    m17 = beta_1 * m17 + (1 - beta_1) * grad_G_w7
+    v17 = beta_2 * v17 + (1 - beta_2) * grad_G_w7 ** 2
+
+    m18 = beta_1 * m18 + (1 - beta_1) * grad_G_b7
+    v18 = beta_2 * v18 + (1 - beta_2) * grad_G_b7 ** 2
+
+    G_W1 = G_W1 - (learing_rate / (np.sqrt(v5 /(1-beta_2) ) + eps)) * (m5/(1-beta_1))
+    G_b1 = G_b1 - (learing_rate / (np.sqrt(v6 /(1-beta_2) ) + eps)) * (m6/(1-beta_1))
+
+    G_W2 = G_W2 - (learing_rate / (np.sqrt(v7 /(1-beta_2) ) + eps)) * (m7/(1-beta_1))
+    G_b2 = G_b2 - (learing_rate / (np.sqrt(v8 /(1-beta_2) ) + eps)) * (m8/(1-beta_1))
+
+    G_W3 = G_W3 - (learing_rate / (np.sqrt(v9 /(1-beta_2) ) + eps)) * (m9/(1-beta_1))
+    G_b3 = G_b3 - (learing_rate / (np.sqrt(v10 /(1-beta_2) ) + eps)) * (m10/(1-beta_1))
+
+    G_W4 = G_W4 - (learing_rate / (np.sqrt(v11 /(1-beta_2) ) + eps)) * (m11/(1-beta_1))
+    G_b4 = G_b4 - (learing_rate / (np.sqrt(v12 /(1-beta_2) ) + eps)) * (m12/(1-beta_1))
+
+    G_W5 = G_W5 - (learing_rate / (np.sqrt(v13 /(1-beta_2) ) + eps)) * (m13/(1-beta_1))
+    G_b5 = G_b5 - (learing_rate / (np.sqrt(v14 /(1-beta_2) ) + eps)) * (m14/(1-beta_1))
+
+    G_W6 = G_W6 - (learing_rate / (np.sqrt(v15 /(1-beta_2) ) + eps)) * (m15/(1-beta_1))
+    G_b6 = G_b6 - (learing_rate / (np.sqrt(v16 /(1-beta_2) ) + eps)) * (m16/(1-beta_1))
+
+    G_W7 = G_W7 - (learing_rate / (np.sqrt(v17 /(1-beta_2) ) + eps)) * (m17/(1-beta_1))
+    G_b7 = G_b7 - (learing_rate / (np.sqrt(v18 /(1-beta_2) ) + eps)) * (m18/(1-beta_1))
+
+    # --- Print Error ----
+    #print("Current Iter: ",iter, " Current D cost:",D_cost, " Current G cost: ", G_cost,end='\r')
+
+    if iter == 0:
+        learing_rate = learing_rate * 0.01
+    if iter == 40:
+        learing_rate = learing_rate * 0.01
+
+    # ---- Print to Out put ----
+    if iter%10 == 0:
+
+        print("Current Iter: ",iter, " Current D cost:",D_cost, " Current G cost: ", G_cost,end='\r')
+        print('--------- Show Example Result See Tab Above ----------')
+        print('--------- Wait for the image to load ---------')
+        Z = np.random.uniform(-1., 1., size=[16, G_input])
+
+        Gl1 = Z.dot(G_W1) + G_b1
+        Gl1A = arctan(Gl1)
+        Gl2 = Gl1A.dot(G_W2) + G_b2
+        Gl2A = ReLu(Gl2)
+        Gl3 = Gl2A.dot(G_W3) + G_b3
+        Gl3A = arctan(Gl3)
+
+        Gl4 = Gl3A.dot(G_W4) + G_b4
+        Gl4A = ReLu(Gl4)
+        Gl5 = Gl4A.dot(G_W5) + G_b5
+        Gl5A = tanh(Gl5)
+        Gl6 = Gl5A.dot(G_W6) + G_b6
+        Gl6A = ReLu(Gl6)
+        Gl7 = Gl6A.dot(G_W7) + G_b7
+
+        current_fake_data = log(Gl7)
+
+        fig = plot(current_fake_data)
+        fig.savefig('Click_Me_{}.png'.format(str(iter).zfill(3)+"_Ginput_"+str(G_input)+ \
+        "_hiddenone"+str(hidden_input) + "_hiddentwo"+str(hidden_input2) + "_LR_" + str(learing_rate)
+        ), bbox_inches='tight')
+#for complete explanation visit https://towardsdatascience.com/only-numpy-implementing-gan-general-adversarial-networks-and-adam-optimizer-using-numpy-with-2a7e4e032021
+# -- end code --
diff --git a/neural_network/input_data.py b/neural_network/input_data.py
new file mode 100644
index 000000000000..983063f0b72d
--- /dev/null
+++ b/neural_network/input_data.py
@@ -0,0 +1,332 @@
+# Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Functions for downloading and reading MNIST data (deprecated).
+
+This module and all its submodules are deprecated.
+"""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import collections
+import gzip
+import os
+
+import numpy
+from six.moves import urllib
+from six.moves import xrange  # pylint: disable=redefined-builtin
+
+from tensorflow.python.framework import dtypes
+from tensorflow.python.framework import random_seed
+from tensorflow.python.platform import gfile
+from tensorflow.python.util.deprecation import deprecated
+
+_Datasets = collections.namedtuple('_Datasets', ['train', 'validation', 'test'])
+
+# CVDF mirror of http://yann.lecun.com/exdb/mnist/
+DEFAULT_SOURCE_URL = 'https://storage.googleapis.com/cvdf-datasets/mnist/'
+
+
+def _read32(bytestream):
+  dt = numpy.dtype(numpy.uint32).newbyteorder('>')
+  return numpy.frombuffer(bytestream.read(4), dtype=dt)[0]
+
+
+@deprecated(None, 'Please use tf.data to implement this functionality.')
+def _extract_images(f):
+  """Extract the images into a 4D uint8 numpy array [index, y, x, depth].
+
+  Args:
+    f: A file object that can be passed into a gzip reader.
+
+  Returns:
+    data: A 4D uint8 numpy array [index, y, x, depth].
+
+  Raises:
+    ValueError: If the bytestream does not start with 2051.
+
+  """
+  print('Extracting', f.name)
+  with gzip.GzipFile(fileobj=f) as bytestream:
+    magic = _read32(bytestream)
+    if magic != 2051:
+      raise ValueError('Invalid magic number %d in MNIST image file: %s' %
+                       (magic, f.name))
+    num_images = _read32(bytestream)
+    rows = _read32(bytestream)
+    cols = _read32(bytestream)
+    buf = bytestream.read(rows * cols * num_images)
+    data = numpy.frombuffer(buf, dtype=numpy.uint8)
+    data = data.reshape(num_images, rows, cols, 1)
+    return data
+
+
+@deprecated(None, 'Please use tf.one_hot on tensors.')
+def _dense_to_one_hot(labels_dense, num_classes):
+  """Convert class labels from scalars to one-hot vectors."""
+  num_labels = labels_dense.shape[0]
+  index_offset = numpy.arange(num_labels) * num_classes
+  labels_one_hot = numpy.zeros((num_labels, num_classes))
+  labels_one_hot.flat[index_offset + labels_dense.ravel()] = 1
+  return labels_one_hot
+
+
+@deprecated(None, 'Please use tf.data to implement this functionality.')
+def _extract_labels(f, one_hot=False, num_classes=10):
+  """Extract the labels into a 1D uint8 numpy array [index].
+
+  Args:
+    f: A file object that can be passed into a gzip reader.
+    one_hot: Does one hot encoding for the result.
+    num_classes: Number of classes for the one hot encoding.
+
+  Returns:
+    labels: a 1D uint8 numpy array.
+
+  Raises:
+    ValueError: If the bystream doesn't start with 2049.
+  """
+  print('Extracting', f.name)
+  with gzip.GzipFile(fileobj=f) as bytestream:
+    magic = _read32(bytestream)
+    if magic != 2049:
+      raise ValueError('Invalid magic number %d in MNIST label file: %s' %
+                       (magic, f.name))
+    num_items = _read32(bytestream)
+    buf = bytestream.read(num_items)
+    labels = numpy.frombuffer(buf, dtype=numpy.uint8)
+    if one_hot:
+      return _dense_to_one_hot(labels, num_classes)
+    return labels
+
+
+class _DataSet(object):
+  """Container class for a _DataSet (deprecated).
+
+  THIS CLASS IS DEPRECATED.
+  """
+
+  @deprecated(None, 'Please use alternatives such as official/mnist/_DataSet.py'
+              ' from tensorflow/models.')
+  def __init__(self,
+               images,
+               labels,
+               fake_data=False,
+               one_hot=False,
+               dtype=dtypes.float32,
+               reshape=True,
+               seed=None):
+    """Construct a _DataSet.
+
+    one_hot arg is used only if fake_data is true.  `dtype` can be either
+    `uint8` to leave the input as `[0, 255]`, or `float32` to rescale into
+    `[0, 1]`.  Seed arg provides for convenient deterministic testing.
+
+    Args:
+      images: The images
+      labels: The labels
+      fake_data: Ignore inages and labels, use fake data.
+      one_hot: Bool, return the labels as one hot vectors (if True) or ints (if
+        False).
+      dtype: Output image dtype. One of [uint8, float32]. `uint8` output has
+        range [0,255]. float32 output has range [0,1].
+      reshape: Bool. If True returned images are returned flattened to vectors.
+      seed: The random seed to use.
+    """
+    seed1, seed2 = random_seed.get_seed(seed)
+    # If op level seed is not set, use whatever graph level seed is returned
+    numpy.random.seed(seed1 if seed is None else seed2)
+    dtype = dtypes.as_dtype(dtype).base_dtype
+    if dtype not in (dtypes.uint8, dtypes.float32):
+      raise TypeError('Invalid image dtype %r, expected uint8 or float32' %
+                      dtype)
+    if fake_data:
+      self._num_examples = 10000
+      self.one_hot = one_hot
+    else:
+      assert images.shape[0] == labels.shape[0], (
+          'images.shape: %s labels.shape: %s' % (images.shape, labels.shape))
+      self._num_examples = images.shape[0]
+
+      # Convert shape from [num examples, rows, columns, depth]
+      # to [num examples, rows*columns] (assuming depth == 1)
+      if reshape:
+        assert images.shape[3] == 1
+        images = images.reshape(images.shape[0],
+                                images.shape[1] * images.shape[2])
+      if dtype == dtypes.float32:
+        # Convert from [0, 255] -> [0.0, 1.0].
+        images = images.astype(numpy.float32)
+        images = numpy.multiply(images, 1.0 / 255.0)
+    self._images = images
+    self._labels = labels
+    self._epochs_completed = 0
+    self._index_in_epoch = 0
+
+  @property
+  def images(self):
+    return self._images
+
+  @property
+  def labels(self):
+    return self._labels
+
+  @property
+  def num_examples(self):
+    return self._num_examples
+
+  @property
+  def epochs_completed(self):
+    return self._epochs_completed
+
+  def next_batch(self, batch_size, fake_data=False, shuffle=True):
+    """Return the next `batch_size` examples from this data set."""
+    if fake_data:
+      fake_image = [1] * 784
+      if self.one_hot:
+        fake_label = [1] + [0] * 9
+      else:
+        fake_label = 0
+      return [fake_image for _ in xrange(batch_size)
+             ], [fake_label for _ in xrange(batch_size)]
+    start = self._index_in_epoch
+    # Shuffle for the first epoch
+    if self._epochs_completed == 0 and start == 0 and shuffle:
+      perm0 = numpy.arange(self._num_examples)
+      numpy.random.shuffle(perm0)
+      self._images = self.images[perm0]
+      self._labels = self.labels[perm0]
+    # Go to the next epoch
+    if start + batch_size > self._num_examples:
+      # Finished epoch
+      self._epochs_completed += 1
+      # Get the rest examples in this epoch
+      rest_num_examples = self._num_examples - start
+      images_rest_part = self._images[start:self._num_examples]
+      labels_rest_part = self._labels[start:self._num_examples]
+      # Shuffle the data
+      if shuffle:
+        perm = numpy.arange(self._num_examples)
+        numpy.random.shuffle(perm)
+        self._images = self.images[perm]
+        self._labels = self.labels[perm]
+      # Start next epoch
+      start = 0
+      self._index_in_epoch = batch_size - rest_num_examples
+      end = self._index_in_epoch
+      images_new_part = self._images[start:end]
+      labels_new_part = self._labels[start:end]
+      return numpy.concatenate((images_rest_part, images_new_part),
+                               axis=0), numpy.concatenate(
+                                   (labels_rest_part, labels_new_part), axis=0)
+    else:
+      self._index_in_epoch += batch_size
+      end = self._index_in_epoch
+      return self._images[start:end], self._labels[start:end]
+
+
+@deprecated(None, 'Please write your own downloading logic.')
+def _maybe_download(filename, work_directory, source_url):
+  """Download the data from source url, unless it's already here.
+
+  Args:
+      filename: string, name of the file in the directory.
+      work_directory: string, path to working directory.
+      source_url: url to download from if file doesn't exist.
+
+  Returns:
+      Path to resulting file.
+  """
+  if not gfile.Exists(work_directory):
+    gfile.MakeDirs(work_directory)
+  filepath = os.path.join(work_directory, filename)
+  if not gfile.Exists(filepath):
+    urllib.request.urlretrieve(source_url, filepath)
+    with gfile.GFile(filepath) as f:
+      size = f.size()
+    print('Successfully downloaded', filename, size, 'bytes.')
+  return filepath
+
+
+@deprecated(None, 'Please use alternatives such as:'
+            ' tensorflow_datasets.load(\'mnist\')')
+def read_data_sets(train_dir,
+                   fake_data=False,
+                   one_hot=False,
+                   dtype=dtypes.float32,
+                   reshape=True,
+                   validation_size=5000,
+                   seed=None,
+                   source_url=DEFAULT_SOURCE_URL):
+  if fake_data:
+
+    def fake():
+      return _DataSet([], [],
+                      fake_data=True,
+                      one_hot=one_hot,
+                      dtype=dtype,
+                      seed=seed)
+
+    train = fake()
+    validation = fake()
+    test = fake()
+    return _Datasets(train=train, validation=validation, test=test)
+
+  if not source_url:  # empty string check
+    source_url = DEFAULT_SOURCE_URL
+
+  train_images_file = 'train-images-idx3-ubyte.gz'
+  train_labels_file = 'train-labels-idx1-ubyte.gz'
+  test_images_file = 't10k-images-idx3-ubyte.gz'
+  test_labels_file = 't10k-labels-idx1-ubyte.gz'
+
+  local_file = _maybe_download(train_images_file, train_dir,
+                               source_url + train_images_file)
+  with gfile.Open(local_file, 'rb') as f:
+    train_images = _extract_images(f)
+
+  local_file = _maybe_download(train_labels_file, train_dir,
+                               source_url + train_labels_file)
+  with gfile.Open(local_file, 'rb') as f:
+    train_labels = _extract_labels(f, one_hot=one_hot)
+
+  local_file = _maybe_download(test_images_file, train_dir,
+                               source_url + test_images_file)
+  with gfile.Open(local_file, 'rb') as f:
+    test_images = _extract_images(f)
+
+  local_file = _maybe_download(test_labels_file, train_dir,
+                               source_url + test_labels_file)
+  with gfile.Open(local_file, 'rb') as f:
+    test_labels = _extract_labels(f, one_hot=one_hot)
+
+  if not 0 <= validation_size <= len(train_images):
+    raise ValueError(
+        'Validation size should be between 0 and {}. Received: {}.'.format(
+            len(train_images), validation_size))
+
+  validation_images = train_images[:validation_size]
+  validation_labels = train_labels[:validation_size]
+  train_images = train_images[validation_size:]
+  train_labels = train_labels[validation_size:]
+
+  options = dict(dtype=dtype, reshape=reshape, seed=seed)
+
+  train = _DataSet(train_images, train_labels, **options)
+  validation = _DataSet(validation_images, validation_labels, **options)
+  test = _DataSet(test_images, test_labels, **options)
+
+  return _Datasets(train=train, validation=validation, test=test)

From e463c0b5739ccabe2694829d410ef095d794b91c Mon Sep 17 00:00:00 2001
From: Kumar-Nishchay <56668486+Kumar-Nishchay@users.noreply.github.com>
Date: Tue, 29 Oct 2019 12:16:29 +0530
Subject: [PATCH 325/348] Update dictionary.txt (#1507)

Added a new word Microfinance. This is one of the recently added word in oxford dictionary
---
 other/dictionary.txt | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/other/dictionary.txt b/other/dictionary.txt
index 14528efe844f..75838996ba08 100644
--- a/other/dictionary.txt
+++ b/other/dictionary.txt
@@ -26131,6 +26131,7 @@ MICROECONOMICS
 MICROELECTRONICS
 MICROFILM
 MICROFILMS
+MICROFINANCE
 MICROGRAMMING
 MICROINSTRUCTION
 MICROINSTRUCTIONS
@@ -45330,4 +45331,4 @@ ZOROASTER
 ZOROASTRIAN
 ZULU
 ZULUS
-ZURICH
\ No newline at end of file
+ZURICH

From e3d4d2bb57ac3d5dabe93cac3957981782bd7d96 Mon Sep 17 00:00:00 2001
From: percy07 <56677891+percy07@users.noreply.github.com>
Date: Tue, 29 Oct 2019 15:36:37 +0530
Subject: [PATCH 326/348] Update greatest_common_divisor.py (#1513)

Add Doctests.
---
 maths/greatest_common_divisor.py | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/maths/greatest_common_divisor.py b/maths/greatest_common_divisor.py
index 07dddab9aeff..21c427d5b227 100644
--- a/maths/greatest_common_divisor.py
+++ b/maths/greatest_common_divisor.py
@@ -10,6 +10,16 @@ def greatest_common_divisor(a, b):
     Calculate Greatest Common Divisor (GCD).
     >>> greatest_common_divisor(24, 40)
     8
+    >>> greatest_common_divisor(1, 1)
+    1
+    >>> greatest_common_divisor(1, 800)
+    1
+    >>> greatest_common_divisor(11, 37)
+    1
+    >>> greatest_common_divisor(3, 5)
+    1
+    >>> greatest_common_divisor(16, 4)
+    4
     """
     return b if a == 0 else greatest_common_divisor(b % a, a)
 

From 1ed47ad6f4b1f38d4d0a52b7f69d43c4a4294cc9 Mon Sep 17 00:00:00 2001
From: percy07 <56677891+percy07@users.noreply.github.com>
Date: Tue, 29 Oct 2019 15:52:49 +0530
Subject: [PATCH 327/348] Update palindrome.py (#1509)

* Update palindrome.py

Add Doctests.

* Use test_data to drive the testing
---
 other/palindrome.py | 63 +++++++++++++++++++++++++++++++++++----------
 1 file changed, 49 insertions(+), 14 deletions(-)

diff --git a/other/palindrome.py b/other/palindrome.py
index 2ca453b64702..dd1fe316f479 100644
--- a/other/palindrome.py
+++ b/other/palindrome.py
@@ -1,9 +1,31 @@
-# Program to find whether given string is palindrome or not
-def is_palindrome(str):
+# Algorithms to determine if a string is palindrome
+
+test_data = {
+    "MALAYALAM": True,
+    "String": False,
+    "rotor": True,
+    "level": True,
+    "A": True,
+    "BB": True,
+    "ABC": False,
+    "amanaplanacanalpanama": True,  # "a man a plan a canal panama"
+}
+# Ensure our test data is valid
+assert all((key == key[::-1]) is value for key, value in test_data.items())
+
+
+def is_palindrome(s: str) -> bool:
+    """
+    Return True if s is a palindrome otherwise return False.
+
+    >>> all(is_palindrome(key) is value for key, value in test_data.items())
+    True
+    """
+
     start_i = 0
-    end_i = len(str) - 1
+    end_i = len(s) - 1
     while start_i < end_i:
-        if str[start_i] == str[end_i]:
+        if s[start_i] == s[end_i]:
             start_i += 1
             end_i -= 1
         else:
@@ -11,21 +33,34 @@ def is_palindrome(str):
     return True
 
 
-# Recursive method
-def recursive_palindrome(str):
-    if len(str) <= 1:
+def is_palindrome_recursive(s: str) -> bool:
+    """
+    Return True if s is a palindrome otherwise return False.
+
+    >>> all(is_palindrome_recursive(key) is value for key, value in test_data.items())
+    True
+    """
+    if len(s) <= 1:
         return True
-    if str[0] == str[len(str) - 1]:
-        return recursive_palindrome(str[1:-1])
+    if s[0] == s[len(s) - 1]:
+        return is_palindrome_recursive(s[1:-1])
     else:
         return False
 
 
-def main():
-    str = "ama"
-    print(recursive_palindrome(str.lower()))
-    print(is_palindrome(str.lower()))
+def is_palindrome_slice(s: str) -> bool:
+    """
+    Return True if s is a palindrome otherwise return False.
+
+    >>> all(is_palindrome_slice(key) is value for key, value in test_data.items())
+    True
+    """
+    return s == s[::-1]
 
 
 if __name__ == "__main__":
-    main()
+    for key, value in test_data.items():
+        assert is_palindrome(key) is is_palindrome_recursive(key)
+        assert is_palindrome(key) is is_palindrome_slice(key)
+        print(f"{key:21} {value}")
+    print("a man a plan a canal panama")

From dfea6f3f0b0dc3ad834c45b1c3a322827b9e1bbf Mon Sep 17 00:00:00 2001
From: Janith Wanniarachchi <janithcwanni@gmail.com>
Date: Tue, 29 Oct 2019 16:23:29 +0530
Subject: [PATCH 328/348] :white_check_mark: added tests for Perceptron in
 Neural Networks (#1506)

* :white_check_mark: added tests for Perceptron in Neural Networks

* Space

* Format code with psf/black
---
 neural_network/perceptron.py | 113 +++++++++++++++++++++++++++--------
 1 file changed, 88 insertions(+), 25 deletions(-)

diff --git a/neural_network/perceptron.py b/neural_network/perceptron.py
index 5feb8610a911..d64c0a5c4341 100644
--- a/neural_network/perceptron.py
+++ b/neural_network/perceptron.py
@@ -1,29 +1,53 @@
 """
-
     Perceptron
     w = w + N * (d(k) - y) * x(k)
 
-    Using perceptron network for oil analysis,
-    with Measuring of 3 parameters that represent chemical characteristics we can classify the oil, in p1 or p2
+    Using perceptron network for oil analysis, with Measuring of 3 parameters
+    that represent chemical characteristics we can classify the oil, in p1 or p2
     p1 = -1
     p2 = 1
-
 """
 import random
 
 
 class Perceptron:
-    def __init__(self, sample, exit, learn_rate=0.01, epoch_number=1000, bias=-1):
+    def __init__(self, sample, target, learning_rate=0.01, epoch_number=1000, bias=-1):
+        """
+        Initializes a Perceptron network for oil analysis
+        :param sample: sample dataset of 3 parameters with shape [30,3]
+        :param target: variable for classification with two possible states -1 or 1
+        :param learning_rate: learning rate used in optimizing.
+        :param epoch_number: number of epochs to train network on.
+        :param bias: bias value for the network.
+        """
         self.sample = sample
-        self.exit = exit
-        self.learn_rate = learn_rate
+        if len(self.sample) == 0:
+            raise AttributeError("Sample data can not be empty")
+        self.target = target
+        if len(self.target) == 0:
+            raise AttributeError("Target data can not be empty")
+        if len(self.sample) != len(self.target):
+            raise AttributeError(
+                "Sample data and Target data do not have matching lengths"
+            )
+        self.learning_rate = learning_rate
         self.epoch_number = epoch_number
         self.bias = bias
         self.number_sample = len(sample)
-        self.col_sample = len(sample[0])
+        self.col_sample = len(sample[0])  # number of columns in dataset
         self.weight = []
 
-    def training(self):
+    def training(self) -> None:
+        """
+        Trains perceptron for epochs <= given number of epochs
+        :return: None
+        >>> data = [[2.0149, 0.6192, 10.9263]]
+        >>> targets = [-1]
+        >>> perceptron = Perceptron(data,targets)
+        >>> perceptron.training() # doctest: +ELLIPSIS
+        ('\\nEpoch:\\n', ...)
+        ...
+        """
         for sample in self.sample:
             sample.insert(0, self.bias)
 
@@ -35,31 +59,47 @@ def training(self):
         epoch_count = 0
 
         while True:
-            erro = False
+            has_misclassified = False
             for i in range(self.number_sample):
                 u = 0
                 for j in range(self.col_sample + 1):
                     u = u + self.weight[j] * self.sample[i][j]
                 y = self.sign(u)
-                if y != self.exit[i]:
-
+                if y != self.target[i]:
                     for j in range(self.col_sample + 1):
-
                         self.weight[j] = (
                             self.weight[j]
-                            + self.learn_rate * (self.exit[i] - y) * self.sample[i][j]
+                            + self.learning_rate
+                            * (self.target[i] - y)
+                            * self.sample[i][j]
                         )
-                    erro = True
+                    has_misclassified = True
             # print('Epoch: \n',epoch_count)
             epoch_count = epoch_count + 1
             # if you want controle the epoch or just by erro
-            if erro == False:
+            if not has_misclassified:
                 print(("\nEpoch:\n", epoch_count))
                 print("------------------------\n")
                 # if epoch_count > self.epoch_number or not erro:
                 break
 
-    def sort(self, sample):
+    def sort(self, sample) -> None:
+        """
+        :param sample: example row to classify as P1 or P2
+        :return: None
+        >>> data = [[2.0149, 0.6192, 10.9263]]
+        >>> targets = [-1]
+        >>> perceptron = Perceptron(data,targets)
+        >>> perceptron.training() # doctest:+ELLIPSIS
+        ('\\nEpoch:\\n', ...)
+        ...
+        >>> perceptron.sort([-0.6508, 0.1097, 4.0009]) # doctest: +ELLIPSIS
+        ('Sample: ', ...)
+        classification: P1
+
+        """
+        if len(self.sample) == 0:
+            raise AttributeError("Sample data can not be empty")
         sample.insert(0, self.bias)
         u = 0
         for i in range(self.col_sample + 1):
@@ -74,7 +114,21 @@ def sort(self, sample):
             print(("Sample: ", sample))
             print("classification: P2")
 
-    def sign(self, u):
+    def sign(self, u: float) -> int:
+        """
+        threshold function for classification
+        :param u: input number
+        :return: 1 if the input is greater than 0, otherwise -1
+        >>> data = [[0],[-0.5],[0.5]]
+        >>> targets = [1,-1,1]
+        >>> perceptron = Perceptron(data,targets)
+        >>> perceptron.sign(0)
+        1
+        >>> perceptron.sign(-0.5)
+        -1
+        >>> perceptron.sign(0.5)
+        1
+        """
         return 1 if u >= 0 else -1
 
 
@@ -144,15 +198,24 @@ def sign(self, u):
     1,
 ]
 
-network = Perceptron(
-    sample=samples, exit=exit, learn_rate=0.01, epoch_number=1000, bias=-1
-)
-
-network.training()
 
 if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()
+
+    network = Perceptron(
+        sample=samples, target=exit, learning_rate=0.01, epoch_number=1000, bias=-1
+    )
+    network.training()
+    print("Finished training perceptron")
+    print("Enter values to predict or q to exit")
     while True:
         sample = []
-        for i in range(3):
-            sample.insert(i, float(input("value: ")))
+        for i in range(len(samples[0])):
+            observation = input("value: ").strip()
+            if observation == "q":
+                break
+            observation = float(observation)
+            sample.insert(i, observation)
         network.sort(sample)

From bfac867e27328eeedf28b3cd4d8f8195d15e44a4 Mon Sep 17 00:00:00 2001
From: Christian Clauss <cclauss@me.com>
Date: Tue, 29 Oct 2019 21:05:36 +0100
Subject: [PATCH 329/348] Add doctests to other/word_patterns.py (#1518)

---
 other/word_patterns.py | 63 ++++++++++++++++++++++--------------------
 1 file changed, 33 insertions(+), 30 deletions(-)

diff --git a/other/word_patterns.py b/other/word_patterns.py
index 16089019704b..d229954dea93 100644
--- a/other/word_patterns.py
+++ b/other/word_patterns.py
@@ -1,41 +1,44 @@
-import pprint, time
-
-
-def getWordPattern(word):
+def get_word_pattern(word: str) -> str:
+    """
+    >>> get_word_pattern("pattern")
+    '0.1.2.2.3.4.5'
+    >>> get_word_pattern("word pattern")
+    '0.1.2.3.4.5.6.7.7.8.2.9'
+    >>> get_word_pattern("get word pattern")
+    '0.1.2.3.4.5.6.7.3.8.9.2.2.1.6.10'
+    """
     word = word.upper()
-    nextNum = 0
-    letterNums = {}
-    wordPattern = []
+    next_num = 0
+    letter_nums = {}
+    word_pattern = []
 
     for letter in word:
-        if letter not in letterNums:
-            letterNums[letter] = str(nextNum)
-            nextNum += 1
-        wordPattern.append(letterNums[letter])
-    return ".".join(wordPattern)
+        if letter not in letter_nums:
+            letter_nums[letter] = str(next_num)
+            next_num += 1
+        word_pattern.append(letter_nums[letter])
+    return ".".join(word_pattern)
 
 
-def main():
-    startTime = time.time()
-    allPatterns = {}
+if __name__ == "__main__":
+    import pprint
+    import time
 
-    with open("Dictionary.txt") as fo:
-        wordList = fo.read().split("\n")
+    start_time = time.time()
+    with open("dictionary.txt") as in_file:
+        wordList = in_file.read().splitlines()
 
+    all_patterns = {}
     for word in wordList:
-        pattern = getWordPattern(word)
-
-        if pattern not in allPatterns:
-            allPatterns[pattern] = [word]
+        pattern = get_word_pattern(word)
+        if pattern in all_patterns:
+            all_patterns[pattern].append(word)
         else:
-            allPatterns[pattern].append(word)
+            all_patterns[pattern] = [word]
 
-    with open("Word Patterns.txt", "w") as fo:
-        fo.write(pprint.pformat(allPatterns))
+    with open("word_patterns.txt", "w") as out_file:
+        out_file.write(pprint.pformat(all_patterns))
 
-    totalTime = round(time.time() - startTime, 2)
-    print(("Done! [", totalTime, "seconds ]"))
-
-
-if __name__ == "__main__":
-    main()
+    totalTime = round(time.time() - start_time, 2)
+    print(f"Done!  {len(all_patterns):,} word patterns found in {totalTime} seconds.")
+    # Done!  9,581 word patterns found in 0.58 seconds.

From 4880e5479a85fd106d2b2f9c06755a3350c3db2a Mon Sep 17 00:00:00 2001
From: 5ur3 <43802815+5ur3@users.noreply.github.com>
Date: Wed, 30 Oct 2019 00:28:51 +0400
Subject: [PATCH 330/348] Create prime_numbers.py (#1519)

* Create prime_numbers.py

* Update prime_numbers.py
---
 maths/prime_numbers.py | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 maths/prime_numbers.py

diff --git a/maths/prime_numbers.py b/maths/prime_numbers.py
new file mode 100644
index 000000000000..aafbebe07be9
--- /dev/null
+++ b/maths/prime_numbers.py
@@ -0,0 +1,28 @@
+"""Prime numbers calculation."""
+
+
+def primes(max: int) -> int:
+    """
+    Return a list of all primes up to max.
+    >>> primes(10)
+    [2, 3, 5, 7]
+    >>> primes(11)
+    [2, 3, 5, 7, 11]
+    >>> primes(25)
+    [2, 3, 5, 7, 11, 13, 17, 19, 23]
+    >>> primes(1_000_000)[-1]
+    999983
+    """
+    max += 1
+    numbers = [False] * max
+    ret = []
+    for i in range(2, max):
+        if not numbers[i]:
+            for j in range(i, max, i):
+                numbers[j] = True
+            ret.append(i)
+    return ret
+
+
+if __name__ == "__main__":
+    print(primes(int(input("Calculate primes up to:\n>> "))))

From f8e97aa597e71ed7f9d4683d00cc910cdaab3a99 Mon Sep 17 00:00:00 2001
From: percy07 <56677891+percy07@users.noreply.github.com>
Date: Wed, 30 Oct 2019 02:24:31 +0530
Subject: [PATCH 331/348] Update basic_maths.py (#1517)

* Update basic_maths.py

Add Doctests.

* Update basic_maths.py

* Add a space to fix the doctest
---
 maths/basic_maths.py         | 52 +++++++++++++++++-------------------
 neural_network/perceptron.py |  2 +-
 2 files changed, 26 insertions(+), 28 deletions(-)

diff --git a/maths/basic_maths.py b/maths/basic_maths.py
index 34ffd1031527..d493ca7eb6c9 100644
--- a/maths/basic_maths.py
+++ b/maths/basic_maths.py
@@ -2,55 +2,56 @@
 import math
 
 
-def prime_factors(n):
-    """Find Prime Factors."""
+def prime_factors(n: int) -> list:
+    """Find Prime Factors.
+    >>> prime_factors(100)
+    [2, 2, 5, 5]
+    """
     pf = []
     while n % 2 == 0:
         pf.append(2)
         n = int(n / 2)
-
     for i in range(3, int(math.sqrt(n)) + 1, 2):
         while n % i == 0:
             pf.append(i)
             n = int(n / i)
-
     if n > 2:
         pf.append(n)
-
     return pf
 
 
-def number_of_divisors(n):
-    """Calculate Number of Divisors of an Integer."""
+def number_of_divisors(n: int) -> int:
+    """Calculate Number of Divisors of an Integer.
+    >>> number_of_divisors(100)
+    9
+    """
     div = 1
-
     temp = 1
     while n % 2 == 0:
         temp += 1
         n = int(n / 2)
-    div = div * (temp)
-
+    div *= temp
     for i in range(3, int(math.sqrt(n)) + 1, 2):
         temp = 1
         while n % i == 0:
             temp += 1
             n = int(n / i)
-        div = div * (temp)
-
+        div *= temp
     return div
 
 
-def sum_of_divisors(n):
-    """Calculate Sum of Divisors."""
+def sum_of_divisors(n: int) -> int:
+    """Calculate Sum of Divisors.
+    >>> sum_of_divisors(100)
+    217
+    """
     s = 1
-
     temp = 1
     while n % 2 == 0:
         temp += 1
         n = int(n / 2)
     if temp > 1:
         s *= (2 ** temp - 1) / (2 - 1)
-
     for i in range(3, int(math.sqrt(n)) + 1, 2):
         temp = 1
         while n % i == 0:
@@ -58,27 +59,24 @@ def sum_of_divisors(n):
             n = int(n / i)
         if temp > 1:
             s *= (i ** temp - 1) / (i - 1)
-
-    return s
+    return int(s)
 
 
-def euler_phi(n):
-    """Calculte Euler's Phi Function."""
+def euler_phi(n: int) -> int:
+    """Calculte Euler's Phi Function.
+    >>> euler_phi(100)
+    40
+    """
     l = prime_factors(n)
     l = set(l)
     s = n
     for x in l:
         s *= (x - 1) / x
-    return s
+    return int(s)
 
 
-def main():
-    """Print the Results of Basic Math Operations."""
+if __name__ == "__main__":
     print(prime_factors(100))
     print(number_of_divisors(100))
     print(sum_of_divisors(100))
     print(euler_phi(100))
-
-
-if __name__ == "__main__":
-    main()
diff --git a/neural_network/perceptron.py b/neural_network/perceptron.py
index d64c0a5c4341..26d48506254b 100644
--- a/neural_network/perceptron.py
+++ b/neural_network/perceptron.py
@@ -90,7 +90,7 @@ def sort(self, sample) -> None:
         >>> data = [[2.0149, 0.6192, 10.9263]]
         >>> targets = [-1]
         >>> perceptron = Perceptron(data,targets)
-        >>> perceptron.training() # doctest:+ELLIPSIS
+        >>> perceptron.training() # doctest: +ELLIPSIS
         ('\\nEpoch:\\n', ...)
         ...
         >>> perceptron.sort([-0.6508, 0.1097, 4.0009]) # doctest: +ELLIPSIS

From 53ff735701db42d2609416ff6772db17383c3f10 Mon Sep 17 00:00:00 2001
From: himanshujain171 <43314193+himanshujain171@users.noreply.github.com>
Date: Wed, 30 Oct 2019 04:24:31 +0530
Subject: [PATCH 332/348] Factors of a number (#1493)

* Factors of a number

* Update factors.py

* Fix mypy issue in basic_maths.py

* Fix mypy error in perceptron.py

* def primes(max: int) -> List[int]:

* Update binomial_heap.py

* Add a space

* Remove a space

* Add a space
---
 data_structures/heap/binomial_heap.py | 177 +++++++++++++-------------
 maths/basic_maths.py                  |   4 +-
 maths/factors.py                      |  18 +++
 maths/prime_numbers.py                |   6 +-
 neural_network/perceptron.py          |   3 +-
 5 files changed, 109 insertions(+), 99 deletions(-)
 create mode 100644 maths/factors.py

diff --git a/data_structures/heap/binomial_heap.py b/data_structures/heap/binomial_heap.py
index e1a005487e34..7f570f1c755b 100644
--- a/data_structures/heap/binomial_heap.py
+++ b/data_structures/heap/binomial_heap.py
@@ -1,7 +1,6 @@
 """
-    Binomial Heap 
-    
-    Reference: Advanced Data Structures, Peter Brass   
+Binomial Heap
+Reference: Advanced Data Structures, Peter Brass
 """
 
 
@@ -10,7 +9,7 @@ class Node:
     Node in a doubly-linked binomial tree, containing:
         - value
         - size of left subtree
-        - link to left, right and parent nodes    
+        - link to left, right and parent nodes
     """
 
     def __init__(self, val):
@@ -23,8 +22,8 @@ def __init__(self, val):
 
     def mergeTrees(self, other):
         """
-            In-place merge of two binomial trees of equal size. 
-            Returns the root of the resulting tree
+        In-place merge of two binomial trees of equal size.
+        Returns the root of the resulting tree
         """
         assert self.left_tree_size == other.left_tree_size, "Unequal Sizes of Blocks"
 
@@ -47,83 +46,79 @@ def mergeTrees(self, other):
 
 
 class BinomialHeap:
-    """
-        Min-oriented priority queue implemented with the Binomial Heap data 
-        structure implemented with the BinomialHeap class. It supports:
-    
+    r"""
+    Min-oriented priority queue implemented with the Binomial Heap data
+    structure implemented with the BinomialHeap class. It supports:
         - Insert element in a heap with n elemnts: Guaranteed logn, amoratized 1
         - Merge (meld) heaps of size m and n: O(logn + logm)
-        - Delete Min: O(logn) 
+        - Delete Min: O(logn)
         - Peek (return min without deleting it): O(1)
-            
-        Example:
-            
-        Create a random permutation of 30 integers to be inserted and 
-        19 of them deleted
-        >>> import numpy as np
-        >>> permutation = np.random.permutation(list(range(30)))
-
-        Create a Heap and insert the 30 integers 
-        
-        __init__() test
-        >>> first_heap = BinomialHeap()
-
-        30 inserts - insert() test
-        >>> for number in permutation:
-        ...     first_heap.insert(number)
-        
-        Size test
-        >>> print(first_heap.size)  
-        30
-        
-        Deleting - delete() test
-        >>> for i in range(25):
-        ...     print(first_heap.deleteMin(), end=" ")
-        0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 
-
-        Create a new Heap
-        >>> second_heap = BinomialHeap()
-        >>> vals = [17, 20, 31, 34]
-        >>> for value in vals:
-        ...     second_heap.insert(value)
-        
-        
-        The heap should have the following structure:
-            
-                        17
-                       /  \
-                      #    31
-                          /  \
-                        20    34
-                       /  \  /  \
-                      #    # #   #
-        
-        preOrder() test
-        >>> print(second_heap.preOrder())
-        [(17, 0), ('#', 1), (31, 1), (20, 2), ('#', 3), ('#', 3), (34, 2), ('#', 3), ('#', 3)]
-        
-        printing Heap - __str__() test
-        >>> print(second_heap)
-        17
-        -#
-        -31
-        --20
-        ---#
-        ---#
-        --34
-        ---#
-        ---#
-
-        mergeHeaps() test
-        >>> merged = second_heap.mergeHeaps(first_heap)
-        >>> merged.peek()
-        17
-        
-        values in merged heap; (merge is inplace) 
-        >>> while not first_heap.isEmpty():
-        ...     print(first_heap.deleteMin(), end=" ")
-        17 20 25 26 27 28 29 31 34 
-        
+
+    Example:
+
+    Create a random permutation of 30 integers to be inserted and 19 of them deleted
+    >>> import numpy as np
+    >>> permutation = np.random.permutation(list(range(30)))
+
+    Create a Heap and insert the 30 integers
+    __init__() test
+    >>> first_heap = BinomialHeap()
+
+    30 inserts - insert() test
+    >>> for number in permutation:
+    ...     first_heap.insert(number)
+
+    Size test
+    >>> print(first_heap.size)
+    30
+
+    Deleting - delete() test
+    >>> for i in range(25):
+    ...     print(first_heap.deleteMin(), end=" ")
+    0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 
+
+    Create a new Heap
+    >>> second_heap = BinomialHeap()
+    >>> vals = [17, 20, 31, 34]
+    >>> for value in vals:
+    ...     second_heap.insert(value)
+
+
+    The heap should have the following structure:
+
+                    17
+                   /  \
+                  #    31
+                      /  \
+                    20    34
+                   /  \  /  \
+                  #    # #   #
+
+    preOrder() test
+    >>> print(second_heap.preOrder())
+    [(17, 0), ('#', 1), (31, 1), (20, 2), ('#', 3), ('#', 3), (34, 2), ('#', 3), ('#', 3)]
+
+    printing Heap - __str__() test
+    >>> print(second_heap)
+    17
+    -#
+    -31
+    --20
+    ---#
+    ---#
+    --34
+    ---#
+    ---#
+
+    mergeHeaps() test
+    >>> merged = second_heap.mergeHeaps(first_heap)
+    >>> merged.peek()
+    17
+
+    values in merged heap; (merge is inplace)
+    >>> while not first_heap.isEmpty():
+    ...     print(first_heap.deleteMin(), end=" ")
+    17 20 25 26 27 28 29 31 34 
     """
 
     def __init__(self, bottom_root=None, min_node=None, heap_size=0):
@@ -133,8 +128,8 @@ def __init__(self, bottom_root=None, min_node=None, heap_size=0):
 
     def mergeHeaps(self, other):
         """
-            In-place merge of two binomial heaps. 
-            Both of them become the resulting merged heap
+        In-place merge of two binomial heaps.
+        Both of them become the resulting merged heap
         """
 
         # Empty heaps corner cases
@@ -209,7 +204,7 @@ def mergeHeaps(self, other):
 
     def insert(self, val):
         """
-            insert a value in the heap
+        insert a value in the heap
         """
         if self.size == 0:
             self.bottom_root = Node(val)
@@ -251,7 +246,7 @@ def insert(self, val):
 
     def peek(self):
         """
-            return min element without deleting it
+        return min element without deleting it
         """
         return self.min_node.val
 
@@ -260,7 +255,7 @@ def isEmpty(self):
 
     def deleteMin(self):
         """
-            delete min element and return it
+        delete min element and return it
         """
         # assert not self.isEmpty(), "Empty Heap"
 
@@ -363,9 +358,9 @@ def deleteMin(self):
 
     def preOrder(self):
         """
-            Returns the Pre-order representation of the heap including 
-            values of nodes plus their level distance from the root;
-            Empty nodes appear as #
+        Returns the Pre-order representation of the heap including
+        values of nodes plus their level distance from the root;
+        Empty nodes appear as #
         """
         # Find top root
         top_root = self.bottom_root
@@ -378,7 +373,7 @@ def preOrder(self):
 
     def __traversal(self, curr_node, preorder, level=0):
         """
-            Pre-order traversal of nodes 
+        Pre-order traversal of nodes
         """
         if curr_node:
             preorder.append((curr_node.val, level))
@@ -389,8 +384,8 @@ def __traversal(self, curr_node, preorder, level=0):
 
     def __str__(self):
         """
-            Overwriting str for a pre-order print of nodes in heap; 
-            Performance is poor, so use only for small examples
+        Overwriting str for a pre-order print of nodes in heap;
+        Performance is poor, so use only for small examples
         """
         if self.isEmpty():
             return ""
diff --git a/maths/basic_maths.py b/maths/basic_maths.py
index d493ca7eb6c9..5dbfd250d308 100644
--- a/maths/basic_maths.py
+++ b/maths/basic_maths.py
@@ -67,10 +67,8 @@ def euler_phi(n: int) -> int:
     >>> euler_phi(100)
     40
     """
-    l = prime_factors(n)
-    l = set(l)
     s = n
-    for x in l:
+    for x in set(prime_factors(n)):
         s *= (x - 1) / x
     return int(s)
 
diff --git a/maths/factors.py b/maths/factors.py
new file mode 100644
index 000000000000..e2fdc4063a13
--- /dev/null
+++ b/maths/factors.py
@@ -0,0 +1,18 @@
+def factors_of_a_number(num: int) -> list:
+    """
+    >>> factors_of_a_number(1)
+    [1]
+    >>> factors_of_a_number(5)
+    [1, 5]
+    >>> factors_of_a_number(24)
+    [1, 2, 3, 4, 6, 8, 12, 24]
+    >>> factors_of_a_number(-24)
+    []
+    """
+    return [i for i in range(1, num + 1) if num % i == 0]
+
+
+if __name__ == "__main__":
+    num = int(input("Enter a number to find its factors: "))
+    factors = factors_of_a_number(num)
+    print(f"{num} has {len(factors)} factors: {', '.join(str(f) for f in factors)}")
diff --git a/maths/prime_numbers.py b/maths/prime_numbers.py
index aafbebe07be9..a29a95ea2280 100644
--- a/maths/prime_numbers.py
+++ b/maths/prime_numbers.py
@@ -1,9 +1,9 @@
-"""Prime numbers calculation."""
+from typing import List
 
 
-def primes(max: int) -> int:
+def primes(max: int) -> List[int]:
     """
-    Return a list of all primes up to max.
+    Return a list of all primes numbers up to max.
     >>> primes(10)
     [2, 3, 5, 7]
     >>> primes(11)
diff --git a/neural_network/perceptron.py b/neural_network/perceptron.py
index 26d48506254b..3610dd2ab227 100644
--- a/neural_network/perceptron.py
+++ b/neural_network/perceptron.py
@@ -95,8 +95,7 @@ def sort(self, sample) -> None:
         ...
         >>> perceptron.sort([-0.6508, 0.1097, 4.0009]) # doctest: +ELLIPSIS
         ('Sample: ', ...)
-        classification: P1
-
+        classification: P...
         """
         if len(self.sample) == 0:
             raise AttributeError("Sample data can not be empty")

From 63433616c9a8f690e416c32dc01ff00bc515d9e2 Mon Sep 17 00:00:00 2001
From: LokiUvaraj <54948079+LokiUvaraj@users.noreply.github.com>
Date: Wed, 30 Oct 2019 04:56:28 +0530
Subject: [PATCH 333/348] average_mode.py (#1491)

* Add files via upload

Finds the mode in the input data.

* Update average_mode.py

* Update average_mode.py

* Update average_mode.py

* Update average_mode.py

* Update average_mode.py

* Update average_mode.py

* Tabs do not belong in Python files!
---
 maths/average_mode.py | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 maths/average_mode.py

diff --git a/maths/average_mode.py b/maths/average_mode.py
new file mode 100644
index 000000000000..c1a4b3521448
--- /dev/null
+++ b/maths/average_mode.py
@@ -0,0 +1,31 @@
+import statistics
+
+
+def mode(input_list):  # Defining function "mode."
+    """This function returns the mode(Mode as in the measures of
+    central tendency) of the input data.
+
+    The input list may contain any Datastructure or any Datatype.
+
+    >>> input_list = [2, 3, 4, 5, 3, 4, 2, 5, 2, 2, 4, 2, 2, 2]
+    >>> mode(input_list)
+    2
+    >>> input_list = [2, 3, 4, 5, 3, 4, 2, 5, 2, 2, 4, 2, 2, 2]
+    >>> mode(input_list) == statistics.mode(input_list)
+    True
+    """
+    # Copying inputlist to check with the index number later.
+    check_list = input_list.copy()
+    result = list()  # Empty list to store the counts of elements in input_list
+    for x in input_list:
+        result.append(input_list.count(x))
+        input_list.remove(x)
+        y = max(result)  # Gets the maximum value in the result list.
+        # Returns the value with the maximum number of repetitions.
+        return check_list[result.index(y)]
+
+
+if __name__ == "__main__":
+    data = [2, 3, 4, 5, 3, 4, 2, 5, 2, 2, 4, 2, 2, 2]
+    print(mode(data))
+    print(statistics.mode(data))

From fc533a759878f90f38c4d8226a9e828724fc2a2e Mon Sep 17 00:00:00 2001
From: Sri Suma <41474384+srisumapasumarthi@users.noreply.github.com>
Date: Wed, 30 Oct 2019 17:22:20 +0530
Subject: [PATCH 334/348] Simplified DES (#1382)

* Simplified DES

* Add files via upload

Diffie Hellman algorithm to generate a secret key.

* Update sdes.py

* Format code with psf/black and add doctests
---
 ciphers/diffie.py | 26 +++++++++++++
 other/sdes.py     | 97 +++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 123 insertions(+)
 create mode 100644 ciphers/diffie.py
 create mode 100644 other/sdes.py

diff --git a/ciphers/diffie.py b/ciphers/diffie.py
new file mode 100644
index 000000000000..6b0cca1f45e6
--- /dev/null
+++ b/ciphers/diffie.py
@@ -0,0 +1,26 @@
+def find_primitive(n):
+    for r in range(1, n):
+        li = []
+        for x in range(n-1):
+            val = pow(r,x,n)
+            if val in li:
+                break
+            li.append(val)
+        else:
+            return r
+
+
+if __name__ == "__main__":
+    q = int(input('Enter a prime number q: '))
+    a = find_primitive(q)
+    a_private = int(input('Enter private key of A: '))
+    a_public = pow(a, a_private, q)
+    b_private = int(input('Enter private key of B: '))
+    b_public = pow(a, b_private, q)
+
+    a_secret = pow(b_public, a_private, q)
+    b_secret = pow(a_public, b_private, q)
+
+    print('The key value generated by A is: ', a_secret)
+    print('The key value generated by B is: ', b_secret)
+    
diff --git a/other/sdes.py b/other/sdes.py
new file mode 100644
index 000000000000..3038ff193ae9
--- /dev/null
+++ b/other/sdes.py
@@ -0,0 +1,97 @@
+def apply_table(inp, table):
+    """
+    >>> apply_table("0123456789", list(range(10)))
+    '9012345678'
+    >>> apply_table("0123456789", list(range(9, -1, -1)))
+    '8765432109'
+    """
+    res = ""
+    for i in table:
+        res += inp[i - 1]
+    return res
+
+
+def left_shift(data):
+    """
+    >>> left_shift("0123456789")
+    '1234567890'
+    """
+    return data[1:] + data[0]
+
+
+def XOR(a, b):
+    """
+    >>> XOR("01010101", "00001111")
+    '01011010'
+    """
+    res = ""
+    for i in range(len(a)):
+        if a[i] == b[i]:
+            res += "0"
+        else:
+            res += "1"
+    return res
+
+
+def apply_sbox(s, data):
+    row = int("0b" + data[0] + data[-1], 2)
+    col = int("0b" + data[1:3], 2)
+    return bin(s[row][col])[2:]
+
+
+def function(expansion, s0, s1, key, message):
+    left = message[:4]
+    right = message[4:]
+    temp = apply_table(right, expansion)
+    temp = XOR(temp, key)
+    l = apply_sbox(s0, temp[:4])
+    r = apply_sbox(s1, temp[4:])
+    l = "0" * (2 - len(l)) + l
+    r = "0" * (2 - len(r)) + r
+    temp = apply_table(l + r, p4_table)
+    temp = XOR(left, temp)
+    return temp + right
+
+
+if __name__ == "__main__":
+
+    key = input("Enter 10 bit key: ")
+    message = input("Enter 8 bit message: ")
+
+    p8_table = [6, 3, 7, 4, 8, 5, 10, 9]
+    p10_table = [3, 5, 2, 7, 4, 10, 1, 9, 8, 6]
+    p4_table = [2, 4, 3, 1]
+    IP = [2, 6, 3, 1, 4, 8, 5, 7]
+    IP_inv = [4, 1, 3, 5, 7, 2, 8, 6]
+    expansion = [4, 1, 2, 3, 2, 3, 4, 1]
+    s0 = [[1, 0, 3, 2], [3, 2, 1, 0], [0, 2, 1, 3], [3, 1, 3, 2]]
+    s1 = [[0, 1, 2, 3], [2, 0, 1, 3], [3, 0, 1, 0], [2, 1, 0, 3]]
+
+    # key generation
+    temp = apply_table(key, p10_table)
+    left = temp[:5]
+    right = temp[5:]
+    left = left_shift(left)
+    right = left_shift(right)
+    key1 = apply_table(left + right, p8_table)
+    left = left_shift(left)
+    right = left_shift(right)
+    left = left_shift(left)
+    right = left_shift(right)
+    key2 = apply_table(left + right, p8_table)
+
+    # encryption
+    temp = apply_table(message, IP)
+    temp = function(expansion, s0, s1, key1, temp)
+    temp = temp[4:] + temp[:4]
+    temp = function(expansion, s0, s1, key2, temp)
+    CT = apply_table(temp, IP_inv)
+    print("Cipher text is:", CT)
+
+    # decryption
+    temp = apply_table(CT, IP)
+    temp = function(expansion, s0, s1, key2, temp)
+    temp = temp[4:] + temp[:4]
+    temp = function(expansion, s0, s1, key1, temp)
+    PT = apply_table(temp, IP_inv)
+    print("Plain text after decypting is:", PT)

From df95f439072fc055f0611a5006bf2006c62536e7 Mon Sep 17 00:00:00 2001
From: percy07 <56677891+percy07@users.noreply.github.com>
Date: Wed, 30 Oct 2019 20:40:30 +0530
Subject: [PATCH 335/348] Update quick_select.py (#1523)

* Update quick_select.py

Add Doctests.

* Add typehints

* Don't pre-allocate "smaller" and "larger"
---
 searches/quick_select.py | 44 ++++++++++++++++++++++++----------------
 1 file changed, 27 insertions(+), 17 deletions(-)

diff --git a/searches/quick_select.py b/searches/quick_select.py
index 6b70562bd78f..17dca395f73c 100644
--- a/searches/quick_select.py
+++ b/searches/quick_select.py
@@ -1,12 +1,13 @@
-import random
-
 """
-A python implementation of the quick select algorithm, which is efficient for calculating the value that would appear in the index of a list if it would be sorted, even if it is not already sorted
+A Python implementation of the quick select algorithm, which is efficient for
+calculating the value that would appear in the index of a list if it would be
+sorted, even if it is not already sorted
 https://en.wikipedia.org/wiki/Quickselect
 """
+import random
 
 
-def _partition(data, pivot):
+def _partition(data: list, pivot) -> tuple:
     """
     Three way partition the data into smaller, equal and greater lists,
     in relationship to the pivot
@@ -25,28 +26,37 @@ def _partition(data, pivot):
     return less, equal, greater
 
 
-def quickSelect(list, k):
-    # k = len(list) // 2 when trying to find the median (index that value would be when list is sorted)
+def quick_select(items: list, index: int):
+    """
+    >>> quick_select([2, 4, 5, 7, 899, 54, 32], 5)
+    54
+    >>> quick_select([2, 4, 5, 7, 899, 54, 32], 1)
+    4
+    >>> quick_select([5, 4, 3, 2], 2)
+    4
+    >>> quick_select([3, 5, 7, 10, 2, 12], 3)
+    7
+    """
+    # index = len(items) // 2 when trying to find the median
+    #   (value of index when items is sorted)
 
     # invalid input
-    if k >= len(list) or k < 0:
+    if index >= len(items) or index < 0:
         return None
 
-    smaller = []
-    larger = []
-    pivot = random.randint(0, len(list) - 1)
-    pivot = list[pivot]
+    pivot = random.randint(0, len(items) - 1)
+    pivot = items[pivot]
     count = 0
-    smaller, equal, larger = _partition(list, pivot)
+    smaller, equal, larger = _partition(items, pivot)
     count = len(equal)
     m = len(smaller)
 
-    # k is the pivot
-    if m <= k < m + count:
+    # index is the pivot
+    if m <= index < m + count:
         return pivot
     # must be in smaller
-    elif m > k:
-        return quickSelect(smaller, k)
+    elif m > index:
+        return quick_select(smaller, index)
     # must be in larger
     else:
-        return quickSelect(larger, k - (m + count))
+        return quick_select(larger, index - (m + count))

From 357dbd4ada738ed9d4b814eeec99bcc833e94aff Mon Sep 17 00:00:00 2001
From: John Law <johnlaw.po@gmail.com>
Date: Thu, 31 Oct 2019 01:06:07 +0800
Subject: [PATCH 336/348] Doctest, type hints and bug in LIS_O(nlogn) (#1525)

* Update longest_increasing_subsequence_o(nlogn).py

* Update longest_increasing_subsequence_o(nlogn).py
---
 ...longest_increasing_subsequence_o(nlogn).py | 21 ++++++++++++++-----
 1 file changed, 16 insertions(+), 5 deletions(-)

diff --git a/dynamic_programming/longest_increasing_subsequence_o(nlogn).py b/dynamic_programming/longest_increasing_subsequence_o(nlogn).py
index f7b2c6915bcb..4b06e0d885f2 100644
--- a/dynamic_programming/longest_increasing_subsequence_o(nlogn).py
+++ b/dynamic_programming/longest_increasing_subsequence_o(nlogn).py
@@ -4,18 +4,29 @@
 # comments: This programme outputs the Longest Strictly Increasing Subsequence in O(NLogN)
 #           Where N is the Number of elements in the list
 #############################
+from typing import List
+
 def CeilIndex(v, l, r, key):
     while r - l > 1:
-        m = (l + r) / 2
+        m = (l + r) // 2
         if v[m] >= key:
             r = m
         else:
             l = m
-
     return r
 
 
-def LongestIncreasingSubsequenceLength(v):
+def LongestIncreasingSubsequenceLength(v: List[int]) -> int:
+    """
+    >>> LongestIncreasingSubsequenceLength([2, 5, 3, 7, 11, 8, 10, 13, 6])
+    6
+    >>> LongestIncreasingSubsequenceLength([])
+    0
+    >>> LongestIncreasingSubsequenceLength([0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15])
+    6
+    >>> LongestIncreasingSubsequenceLength([5, 4, 3, 2, 1])
+    1
+    """
     if len(v) == 0:
         return 0
 
@@ -37,5 +48,5 @@ def LongestIncreasingSubsequenceLength(v):
 
 
 if __name__ == "__main__":
-    v = [2, 5, 3, 7, 11, 8, 10, 13, 6]
-    print(LongestIncreasingSubsequenceLength(v))
+    import doctest
+    doctest.testmod()

From 8a5633a23376d2eb16f48f583890fde4c1b27e3b Mon Sep 17 00:00:00 2001
From: RitwickGhosh <56272528+RitwickGhosh@users.noreply.github.com>
Date: Thu, 31 Oct 2019 12:49:10 +0530
Subject: [PATCH 337/348] Euler Problem 27 solution script Added (#1466)

* Add files via upload

* Update DIRECTORY.md

* Create sol1.py

* Update sol1.py

* Create __init__.py

* Update DIRECTORY.md

* Delete isotonic.py

* Update sol1.py

* Problem_27_project_euler

* project_euler/Problem_27/sol1.py

* project_euler/Problem_27/sol1.py

* project_euler/problem_27/

* project_euler/problem_27

* project_euler/problem_27

* update sol1 of Euler Problem 27 solution script Added

* Remove slow test, wrap long comments, format with psf/black

* Delete __init__.py

* Add type hints

* Add doctests to function is_prime()

* Rename project_euler/problem_27/project_euler/problem_27/sol1.pysol1.py to project_euler/problem_27/problem_27_sol1.py
---
 project_euler/problem_27/problem_27_sol1.py | 69 +++++++++++++++++++++
 1 file changed, 69 insertions(+)
 create mode 100644 project_euler/problem_27/problem_27_sol1.py

diff --git a/project_euler/problem_27/problem_27_sol1.py b/project_euler/problem_27/problem_27_sol1.py
new file mode 100644
index 000000000000..dbd07f81b713
--- /dev/null
+++ b/project_euler/problem_27/problem_27_sol1.py
@@ -0,0 +1,69 @@
+"""
+Euler discovered the remarkable quadratic formula:
+n2 + n + 41
+It turns out that the formula will produce 40 primes for the consecutive values
+n = 0 to 39. However, when n = 40, 402 + 40 + 41 = 40(40 + 1) + 41 is divisible
+by 41, and certainly when n = 41, 412 + 41 + 41 is clearly divisible by 41.
+The incredible formula  n2 − 79n + 1601 was discovered, which produces 80 primes
+for the consecutive values n = 0 to 79. The product of the coefficients, −79 and
+1601, is −126479.
+Considering quadratics of the form:
+n² + an + b, where |a| &lt; 1000 and |b| &lt; 1000
+where |n| is the modulus/absolute value of ne.g. |11| = 11 and |−4| = 4
+Find the product of the coefficients, a and b, for the quadratic expression that
+produces the maximum number of primes for consecutive values of n, starting with
+n = 0.
+"""
+
+import math
+
+
+def is_prime(k: int) -> bool:
+    """
+    Determine if a number is prime
+    >>> is_prime(10)
+    False
+    >>> is_prime(11)
+    True
+    """
+    if k < 2 or k % 2 == 0:
+        return False
+    elif k == 2:
+        return True
+    else:
+        for x in range(3, int(math.sqrt(k) + 1), 2):
+            if k % x == 0:
+                return False
+    return True
+
+
+def solution(a_limit: int, b_limit: int) -> int:
+    """
+	>>> solution(1000, 1000)
+	-59231
+	>>> solution(200, 1000)
+	-59231
+	>>> solution(200, 200)
+	-4925
+	>>> solution(-1000, 1000)
+	0
+	>>> solution(-1000, -1000)
+	0
+	"""
+    longest = [0, 0, 0]  # length, a, b
+    for a in range((a_limit * -1) + 1, a_limit):
+        for b in range(2, b_limit):
+            if is_prime(b):
+                count = 0
+                n = 0
+                while is_prime((n ** 2) + (a * n) + b):
+                    count += 1
+                    n += 1
+                if count > longest[0]:
+                    longest = [count, a, b]
+    ans = longest[1] * longest[2]
+    return ans
+
+
+if __name__ == "__main__":
+    print(solution(1000, 1000))

From 6d44cdd315e1fbff10fb03d9d8b4645183a6a8e5 Mon Sep 17 00:00:00 2001
From: Du YuanChao <shellhub.me@gmail.com>
Date: Thu, 31 Oct 2019 19:33:40 +0800
Subject: [PATCH 338/348] perfect square (#1534)

* perfect square

* perfect square
---
 maths/perfect_square.py | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 maths/perfect_square.py

diff --git a/maths/perfect_square.py b/maths/perfect_square.py
new file mode 100644
index 000000000000..9b868c5de98a
--- /dev/null
+++ b/maths/perfect_square.py
@@ -0,0 +1,27 @@
+import math
+
+
+def perfect_square(num: int) -> bool:
+    """
+    Check if a number is perfect square number or not
+    :param num: the number to be checked
+    :return: True if number is square number, otherwise False
+
+    >>> perfect_square(9)
+    True
+    >>> perfect_square(16)
+    True
+    >>> perfect_square(1)
+    True
+    >>> perfect_square(0)
+    True
+    >>> perfect_square(10)
+    False
+    """
+    return math.sqrt(num) * math.sqrt(num) == num
+
+
+if __name__ == '__main__':
+    import doctest
+
+    doctest.testmod()

From 80e1c8748a947cd2818aa3d8cdf2d224fd13bda1 Mon Sep 17 00:00:00 2001
From: Charley <56961474+pingings@users.noreply.github.com>
Date: Thu, 31 Oct 2019 12:20:39 +0000
Subject: [PATCH 339/348] Added Problem 33 (#1440)

* Create sol1.py

* Create __init__.py

* Update sol1.py

* corrected range

* Update sol1.py
---
 project_euler/problem_33/__init__.py |  1 +
 project_euler/problem_33/sol1.py     | 55 ++++++++++++++++++++++++++++
 2 files changed, 56 insertions(+)
 create mode 100644 project_euler/problem_33/__init__.py
 create mode 100644 project_euler/problem_33/sol1.py

diff --git a/project_euler/problem_33/__init__.py b/project_euler/problem_33/__init__.py
new file mode 100644
index 000000000000..8b137891791f
--- /dev/null
+++ b/project_euler/problem_33/__init__.py
@@ -0,0 +1 @@
+
diff --git a/project_euler/problem_33/sol1.py b/project_euler/problem_33/sol1.py
new file mode 100644
index 000000000000..0992c96935f5
--- /dev/null
+++ b/project_euler/problem_33/sol1.py
@@ -0,0 +1,55 @@
+"""
+Problem:
+
+The fraction 49/98 is a curious fraction, as an inexperienced
+mathematician in attempting to simplify it may incorrectly believe
+that 49/98 = 4/8, which is correct, is obtained by cancelling the 9s.
+
+We shall consider fractions like, 30/50 = 3/5, to be trivial examples.
+
+There are exactly four non-trivial examples of this type of fraction,
+less than one in value, and containing two digits in the numerator
+and denominator.
+
+If the product of these four fractions is given in its lowest common
+terms, find the value of the denominator.
+"""
+
+
+def isDigitCancelling(num, den):
+    if num != den:
+        if num % 10 == den // 10:
+            if (num // 10) / (den % 10) == num / den:
+                return True
+
+
+def solve(digit_len: int) -> str:
+    """
+    >>> solve(2)
+    '16/64 , 19/95 , 26/65 , 49/98'
+    >>> solve(3)
+    '16/64 , 19/95 , 26/65 , 49/98'
+    >>> solve(4)
+    '16/64 , 19/95 , 26/65 , 49/98'
+    >>> solve(0)
+    ''
+    >>> solve(5)
+    '16/64 , 19/95 , 26/65 , 49/98'
+    """
+    solutions = []
+    den = 11
+    last_digit = int("1" + "0" * digit_len)
+    for num in range(den, last_digit):
+        while den <= 99:
+            if (num != den) and (num % 10 == den // 10) and (den % 10 != 0):
+                if isDigitCancelling(num, den):
+                    solutions.append("{}/{}".format(num, den))
+            den += 1
+        num += 1
+        den = 10
+    solutions = " , ".join(solutions)
+    return solutions
+
+
+if __name__ == "__main__":
+    print(solve(2))

From 814750e637ff3a28442808dc10b2c23170abc85b Mon Sep 17 00:00:00 2001
From: Du YuanChao <shellhub.me@gmail.com>
Date: Thu, 31 Oct 2019 20:45:32 +0800
Subject: [PATCH 340/348] update factorial (#1535)

* update factorial

* update factorial
---
 maths/factorial_python.py    | 43 +++++++++++++++++++++++-------------
 maths/factorial_recursive.py | 36 +++++++++++++++++++++---------
 2 files changed, 54 insertions(+), 25 deletions(-)

diff --git a/maths/factorial_python.py b/maths/factorial_python.py
index ab97cd41e681..b9adfdbaeaff 100644
--- a/maths/factorial_python.py
+++ b/maths/factorial_python.py
@@ -1,21 +1,34 @@
 def factorial(input_number: int) -> int:
     """
-        Non-recursive algorithm of finding factorial of the
-        input number.
-        >>> factorial(1)
-        1
-        >>> factorial(6)
-        720
-        >>> factorial(0)
-        1
+    Calculate the factorial of specified number
+
+    >>> factorial(1)
+    1
+    >>> factorial(6)
+    720
+    >>> factorial(0)
+    1
+    >>> factorial(-1)
+    Traceback (most recent call last):
+        ...
+    ValueError: factorial() not defined for negative values
+    >>> factorial(0.1)
+    Traceback (most recent call last):
+        ...
+    ValueError: factorial() only accepts integral values
     """
 
     if input_number < 0:
-        raise ValueError("Input input_number should be non-negative")
-    elif input_number == 0:
-        return 1
-    else:
-        result = 1
-        for i in range(input_number):
-            result = result * (i + 1)
+        raise ValueError("factorial() not defined for negative values")
+    if not isinstance(input_number, int):
+        raise ValueError("factorial() only accepts integral values")
+    result = 1
+    for i in range(1, input_number):
+        result = result * (i + 1)
     return result
+
+
+if __name__ == '__main__':
+    import doctest
+
+    doctest.testmod()
diff --git a/maths/factorial_recursive.py b/maths/factorial_recursive.py
index f346c65f1962..013560b28b42 100644
--- a/maths/factorial_recursive.py
+++ b/maths/factorial_recursive.py
@@ -1,14 +1,30 @@
-def fact(n):
+def factorial(n: int) -> int:
     """
-    Return 1, if n is 1 or below,
-    otherwise, return n * fact(n-1).
+    Calculate the factorial of specified number
+
+    >>> factorial(1)
+    1
+    >>> factorial(6)
+    720
+    >>> factorial(0)
+    1
+    >>> factorial(-1)
+    Traceback (most recent call last):
+        ...
+    ValueError: factorial() not defined for negative values
+    >>> factorial(0.1)
+    Traceback (most recent call last):
+        ...
+    ValueError: factorial() only accepts integral values
     """
-    return 1 if n <= 1 else n * fact(n - 1)
+    if n < 0:
+        raise ValueError("factorial() not defined for negative values")
+    if not isinstance(n, int):
+        raise ValueError("factorial() only accepts integral values")
+    return 1 if n == 0 or n == 1 else n * factorial(n - 1)
+
 
+if __name__ == '__main__':
+    import doctest
 
-"""
-Show factorial for i,
-where i ranges from 1 to 20.
-"""
-for i in range(1, 21):
-    print(i, ": ", fact(i), sep="")
+    doctest.testmod()

From c717f8d86091011013d4731a91161143fa61b7d7 Mon Sep 17 00:00:00 2001
From: Taufik Algi F <43858377+taufikalgi@users.noreply.github.com>
Date: Fri, 1 Nov 2019 00:45:01 +0700
Subject: [PATCH 341/348] add max sum contigous subsequence (#1537)

* add max sum contigous subsequence

* fix typo

* Add doctest and type hints

* Create autoblack.yml
---
 .github/workflows/autoblack.yml               | 34 +++++++++++++++++++
 .../max_sum_contigous_subsequence.py          | 20 +++++++++++
 2 files changed, 54 insertions(+)
 create mode 100644 .github/workflows/autoblack.yml
 create mode 100644 dynamic_programming/max_sum_contigous_subsequence.py

diff --git a/.github/workflows/autoblack.yml b/.github/workflows/autoblack.yml
new file mode 100644
index 000000000000..98310ac80b11
--- /dev/null
+++ b/.github/workflows/autoblack.yml
@@ -0,0 +1,34 @@
+# GitHub Action that uses Black to reformat the Python code in an incoming pull request.
+# If all Python code in the pull request is complient with Black then this Action does nothing.
+# Othewrwise, Black is run and its changes are committed back to the incoming pull request.
+# https://github.com/cclauss/autoblack
+
+name: autoblack
+on: [pull_request]
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      max-parallel: 1
+      matrix:
+        python-version: [3.7]
+    steps:
+      - uses: actions/checkout@v1
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v1
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install psf/black
+        run: pip install black
+      - name: Run black --check .
+        run: black --check .
+      - name: If needed, commit black changes to the pull request
+        if: failure()
+        run: |
+          black .
+          git config --global user.name 'autoblack'
+          git config --global user.email 'cclauss@users.noreply.github.com'
+          git remote set-url origin https://x-access-token:${{ secrets.GITHUB_TOKEN }}@github.com/$GITHUB_REPOSITORY
+          git checkout $GITHUB_HEAD_REF
+          git commit -am "fixup: Format Python code with psf/black"
+          git push
diff --git a/dynamic_programming/max_sum_contigous_subsequence.py b/dynamic_programming/max_sum_contigous_subsequence.py
new file mode 100644
index 000000000000..2cbdb97a1759
--- /dev/null
+++ b/dynamic_programming/max_sum_contigous_subsequence.py
@@ -0,0 +1,20 @@
+def max_subarray_sum(nums: list) -> int:
+    """
+    >>> max_subarray_sum([6 , 9, -1, 3, -7, -5, 10])
+    17
+    """
+    if not nums:
+        return 0
+    n = len(nums)
+    s = [0] * n
+    res, s, s_pre = nums[0], nums[0], nums[0]
+    for i in range(1, n):
+        s = max(nums[i], s_pre + nums[i])
+        s_pre = s
+        res = max(res, s)
+    return res
+
+
+if __name__ == "__main__":
+    nums = [6, 9, -1, 3, -7, -5, 10]
+    print(max_subarray_sum(nums))

From 62e51fe48753a93a6c38834fd0b22eda1941644f Mon Sep 17 00:00:00 2001
From: Metehan <metehaansever@gmail.com>
Date: Thu, 31 Oct 2019 21:49:25 +0300
Subject: [PATCH 342/348] recursive quick sort (#1536)

* recursive quick sort

* recursive quick sort

* Delete recursive-quick-sort

* Update recursive-quick-sort.py
---
 sorts/recursive-quick-sort.py | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 sorts/recursive-quick-sort.py

diff --git a/sorts/recursive-quick-sort.py b/sorts/recursive-quick-sort.py
new file mode 100644
index 000000000000..c28a14e37ebd
--- /dev/null
+++ b/sorts/recursive-quick-sort.py
@@ -0,0 +1,22 @@
+def quick_sort(data: list) -> list:
+    """
+    >>> for data in ([2, 1, 0], [2.2, 1.1, 0], "quick_sort"):
+    ...     quick_sort(data) == sorted(data)
+    True
+    True
+    True
+    """
+    if len(data) <= 1:
+        return data
+    else:
+        return (
+            quick_sort([e for e in data[1:] if e <= data[0]])
+            + [data[0]]
+            + quick_sort([e for e in data[1:] if e > data[0]])
+        )
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()

From 7bc0462e7936675d9c4f6435d42afa915eef0248 Mon Sep 17 00:00:00 2001
From: Jonathan Alberth Quispe Fuentes <qf.jonathan@gmail.com>
Date: Thu, 31 Oct 2019 22:00:46 -0500
Subject: [PATCH 343/348] Non-recursive Segment Tree implementation (#1543)

* Non-recursive Segment Tree implementation

* Added type hints and explanations links
---
 .../binary_tree/non_recursive_segment_tree.py | 153 ++++++++++++++++++
 1 file changed, 153 insertions(+)
 create mode 100644 data_structures/binary_tree/non_recursive_segment_tree.py

diff --git a/data_structures/binary_tree/non_recursive_segment_tree.py b/data_structures/binary_tree/non_recursive_segment_tree.py
new file mode 100644
index 000000000000..877ee45b5baa
--- /dev/null
+++ b/data_structures/binary_tree/non_recursive_segment_tree.py
@@ -0,0 +1,153 @@
+"""
+A non-recursive Segment Tree implementation with range query and single element update,
+works virtually with any list of the same type of elements with a "commutative" combiner.
+
+Explanation:
+https://www.geeksforgeeks.org/iterative-segment-tree-range-minimum-query/
+https://www.geeksforgeeks.org/segment-tree-efficient-implementation/
+
+>>> SegmentTree([1, 2, 3], lambda a, b: a + b).query(0, 2)
+6
+>>> SegmentTree([3, 1, 2], min).query(0, 2)
+1
+>>> SegmentTree([2, 3, 1], max).query(0, 2)
+3
+>>> st = SegmentTree([1, 5, 7, -1, 6], lambda a, b: a + b)
+>>> st.update(1, -1)
+>>> st.update(2, 3)
+>>> st.query(1, 2)
+2
+>>> st.query(1, 1)
+-1
+>>> st.update(4, 1)
+>>> st.query(3, 4)
+0
+>>> st = SegmentTree([[1, 2, 3], [3, 2, 1], [1, 1, 1]], lambda a, b: [a[i] + b[i] for i in range(len(a))])
+>>> st.query(0, 1)
+[4, 4, 4]
+>>> st.query(1, 2)
+[4, 3, 2]
+>>> st.update(1, [-1, -1, -1])
+>>> st.query(1, 2)
+[0, 0, 0]
+>>> st.query(0, 2)
+[1, 2, 3]
+"""
+from typing import List, Callable, TypeVar
+
+T = TypeVar("T")
+
+
+class SegmentTree:
+    def __init__(self, arr: List[T], fnc: Callable[[T, T], T]) -> None:
+        """
+        Segment Tree constructor, it works just with commutative combiner.
+        :param arr: list of elements for the segment tree
+        :param fnc: commutative function for combine two elements
+
+        >>> SegmentTree(['a', 'b', 'c'], lambda a, b: '{}{}'.format(a, b)).query(0, 2)
+        'abc'
+        >>> SegmentTree([(1, 2), (2, 3), (3, 4)], lambda a, b: (a[0] + b[0], a[1] + b[1])).query(0, 2)
+        (6, 9)
+        """
+        self.N = len(arr)
+        self.st = [None for _ in range(len(arr))] + arr
+        self.fn = fnc
+        self.build()
+
+    def build(self) -> None:
+        for p in range(self.N - 1, 0, -1):
+            self.st[p] = self.fn(self.st[p * 2], self.st[p * 2 + 1])
+
+    def update(self, p: int, v: T) -> None:
+        """
+        Update an element in log(N) time
+        :param p: position to be update
+        :param v: new value
+
+        >>> st = SegmentTree([3, 1, 2, 4], min)
+        >>> st.query(0, 3)
+        1
+        >>> st.update(2, -1)
+        >>> st.query(0, 3)
+        -1
+        """
+        p += self.N
+        self.st[p] = v
+        while p > 1:
+            p = p // 2
+            self.st[p] = self.fn(self.st[p * 2], self.st[p * 2 + 1])
+
+    def query(self, l: int, r: int) -> T:
+        """
+        Get range query value in log(N) time
+        :param l: left element index
+        :param r: right element index
+        :return: element combined in the range [l, r]
+
+        >>> st = SegmentTree([1, 2, 3, 4], lambda a, b: a + b)
+        >>> st.query(0, 2)
+        6
+        >>> st.query(1, 2)
+        5
+        >>> st.query(0, 3)
+        10
+        >>> st.query(2, 3)
+        7
+        """
+        l, r = l + self.N, r + self.N
+        res = None
+        while l <= r:
+            if l % 2 == 1:
+                res = self.st[l] if res is None else self.fn(res, self.st[l])
+            if r % 2 == 0:
+                res = self.st[r] if res is None else self.fn(res, self.st[r])
+            l, r = (l + 1) // 2, (r - 1) // 2
+        return res
+
+
+if __name__ == "__main__":
+    from functools import reduce
+
+    test_array = [1, 10, -2, 9, -3, 8, 4, -7, 5, 6, 11, -12]
+
+    test_updates = {
+        0: 7,
+        1: 2,
+        2: 6,
+        3: -14,
+        4: 5,
+        5: 4,
+        6: 7,
+        7: -10,
+        8: 9,
+        9: 10,
+        10: 12,
+        11: 1,
+    }
+
+    min_segment_tree = SegmentTree(test_array, min)
+    max_segment_tree = SegmentTree(test_array, max)
+    sum_segment_tree = SegmentTree(test_array, lambda a, b: a + b)
+
+    def test_all_segments():
+        """
+        Test all possible segments
+        """
+        for i in range(len(test_array)):
+            for j in range(i, len(test_array)):
+                min_range = reduce(min, test_array[i : j + 1])
+                max_range = reduce(max, test_array[i : j + 1])
+                sum_range = reduce(lambda a, b: a + b, test_array[i : j + 1])
+                assert min_range == min_segment_tree.query(i, j)
+                assert max_range == max_segment_tree.query(i, j)
+                assert sum_range == sum_segment_tree.query(i, j)
+
+    test_all_segments()
+
+    for index, value in test_updates.items():
+        test_array[index] = value
+        min_segment_tree.update(index, value)
+        max_segment_tree.update(index, value)
+        sum_segment_tree.update(index, value)
+        test_all_segments()

From 8107548cc11d226d35a343bb14f8b8a9cc2fb32b Mon Sep 17 00:00:00 2001
From: "Marvin M. Michum" <11682032+mrvnmchm@users.noreply.github.com>
Date: Thu, 31 Oct 2019 23:06:20 -0400
Subject: [PATCH 344/348] Travis CI: Write & print DIRECTORY.md on one line
 (#1542)

* travis test

* travis pull ID test

* get pr branch test

* retry pr build

* test pushing back - probable git error for origin 'not found'

* github auth?

* add .sh

* chmod

* add index update for permission fix

* run sh for script

* add all

* add pull directory

* fetch pr branch

* swap placement of adding commits

* rotate

* quit trying to update Travis

* formatting leftovers

* Travis CI: Write & print DIRECTORY.md on one line
---
 .travis.yml | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index 877dbee9ade2..0c7c9fd0e1c7 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -11,5 +11,4 @@ script:
   - mypy --ignore-missing-imports .
   - pytest . --doctest-modules
 after_success:
-  - scripts/build_directory_md.py > DIRECTORY.md
-  - cat DIRECTORY.md
+  - scripts/build_directory_md.py 2>&1 | tee DIRECTORY.md

From 0e3357ae35314740e9f5e5515dca924b20d39492 Mon Sep 17 00:00:00 2001
From: vinayak <itssvinayak@gmail.com>
Date: Fri, 1 Nov 2019 13:57:16 +0530
Subject: [PATCH 345/348] added solution 1 for problem_99 in project_euler
 (#1545)

* Create sol1.py

* Create __init__.py

* Update sol1.py

* corrected range

* Add files via upload

* Update DIRECTORY.md

* Create sol1.py

* Update sol1.py

* Create __init__.py

* Update DIRECTORY.md

* Delete isotonic.py

* Update sol1.py

* Problem_27_project_euler

* project_euler/Problem_27/sol1.py

* project_euler/Problem_27/sol1.py

* project_euler/problem_27/

* project_euler/problem_27

* project_euler/problem_27

* update sol1 of Euler Problem 27 solution script Added

* Remove slow test, wrap long comments, format with psf/black

* Delete __init__.py

* Add type hints

* Add doctests to function is_prime()

* Rename project_euler/problem_27/project_euler/problem_27/sol1.pysol1.py to project_euler/problem_27/problem_27_sol1.py

* Added Problem 33

* added solution 1 for problem_99

* update added solution 1 for problem_99

* update

* Update sol1.py
---
 project_euler/problem_99/__init__.py  |    0
 project_euler/problem_99/base_exp.txt | 1000 +++++++++++++++++++++++++
 project_euler/problem_99/sol1.py      |   33 +
 3 files changed, 1033 insertions(+)
 create mode 100644 project_euler/problem_99/__init__.py
 create mode 100644 project_euler/problem_99/base_exp.txt
 create mode 100644 project_euler/problem_99/sol1.py

diff --git a/project_euler/problem_99/__init__.py b/project_euler/problem_99/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/project_euler/problem_99/base_exp.txt b/project_euler/problem_99/base_exp.txt
new file mode 100644
index 000000000000..abe95aa86036
--- /dev/null
+++ b/project_euler/problem_99/base_exp.txt
@@ -0,0 +1,1000 @@
+519432,525806
+632382,518061
+78864,613712
+466580,530130
+780495,510032
+525895,525320
+15991,714883
+960290,502358
+760018,511029
+166800,575487
+210884,564478
+555151,523163
+681146,515199
+563395,522587
+738250,512126
+923525,503780
+595148,520429
+177108,572629
+750923,511482
+440902,532446
+881418,505504
+422489,534197
+979858,501616
+685893,514935
+747477,511661
+167214,575367
+234140,559696
+940238,503122
+728969,512609
+232083,560102
+900971,504694
+688801,514772
+189664,569402
+891022,505104
+445689,531996
+119570,591871
+821453,508118
+371084,539600
+911745,504251
+623655,518600
+144361,582486
+352442,541775
+420726,534367
+295298,549387
+6530,787777
+468397,529976
+672336,515696
+431861,533289
+84228,610150
+805376,508857
+444409,532117
+33833,663511
+381850,538396
+402931,536157
+92901,604930
+304825,548004
+731917,512452
+753734,511344
+51894,637373
+151578,580103
+295075,549421
+303590,548183
+333594,544123
+683952,515042
+60090,628880
+951420,502692
+28335,674991
+714940,513349
+343858,542826
+549279,523586
+804571,508887
+260653,554881
+291399,549966
+402342,536213
+408889,535550
+40328,652524
+375856,539061
+768907,510590
+165993,575715
+976327,501755
+898500,504795
+360404,540830
+478714,529095
+694144,514472
+488726,528258
+841380,507226
+328012,544839
+22389,690868
+604053,519852
+329514,544641
+772965,510390
+492798,527927
+30125,670983
+895603,504906
+450785,531539
+840237,507276
+380711,538522
+63577,625673
+76801,615157
+502694,527123
+597706,520257
+310484,547206
+944468,502959
+121283,591152
+451131,531507
+566499,522367
+425373,533918
+40240,652665
+39130,654392
+714926,513355
+469219,529903
+806929,508783
+287970,550487
+92189,605332
+103841,599094
+671839,515725
+452048,531421
+987837,501323
+935192,503321
+88585,607450
+613883,519216
+144551,582413
+647359,517155
+213902,563816
+184120,570789
+258126,555322
+502546,527130
+407655,535678
+401528,536306
+477490,529193
+841085,507237
+732831,512408
+833000,507595
+904694,504542
+581435,521348
+455545,531110
+873558,505829
+94916,603796
+720176,513068
+545034,523891
+246348,557409
+556452,523079
+832015,507634
+173663,573564
+502634,527125
+250732,556611
+569786,522139
+216919,563178
+521815,525623
+92304,605270
+164446,576167
+753413,511364
+11410,740712
+448845,531712
+925072,503725
+564888,522477
+7062,780812
+641155,517535
+738878,512100
+636204,517828
+372540,539436
+443162,532237
+571192,522042
+655350,516680
+299741,548735
+581914,521307
+965471,502156
+513441,526277
+808682,508700
+237589,559034
+543300,524025
+804712,508889
+247511,557192
+543486,524008
+504383,526992
+326529,545039
+792493,509458
+86033,609017
+126554,589005
+579379,521481
+948026,502823
+404777,535969
+265767,554022
+266876,553840
+46631,643714
+492397,527958
+856106,506581
+795757,509305
+748946,511584
+294694,549480
+409781,535463
+775887,510253
+543747,523991
+210592,564536
+517119,525990
+520253,525751
+247926,557124
+592141,520626
+346580,542492
+544969,523902
+506501,526817
+244520,557738
+144745,582349
+69274,620858
+292620,549784
+926027,503687
+736320,512225
+515528,526113
+407549,535688
+848089,506927
+24141,685711
+9224,757964
+980684,501586
+175259,573121
+489160,528216
+878970,505604
+969546,502002
+525207,525365
+690461,514675
+156510,578551
+659778,516426
+468739,529945
+765252,510770
+76703,615230
+165151,575959
+29779,671736
+928865,503569
+577538,521605
+927555,503618
+185377,570477
+974756,501809
+800130,509093
+217016,563153
+365709,540216
+774508,510320
+588716,520851
+631673,518104
+954076,502590
+777828,510161
+990659,501222
+597799,520254
+786905,509727
+512547,526348
+756449,511212
+869787,505988
+653747,516779
+84623,609900
+839698,507295
+30159,670909
+797275,509234
+678136,515373
+897144,504851
+989554,501263
+413292,535106
+55297,633667
+788650,509637
+486748,528417
+150724,580377
+56434,632490
+77207,614869
+588631,520859
+611619,519367
+100006,601055
+528924,525093
+190225,569257
+851155,506789
+682593,515114
+613043,519275
+514673,526183
+877634,505655
+878905,505602
+1926,914951
+613245,519259
+152481,579816
+841774,507203
+71060,619442
+865335,506175
+90244,606469
+302156,548388
+399059,536557
+478465,529113
+558601,522925
+69132,620966
+267663,553700
+988276,501310
+378354,538787
+529909,525014
+161733,576968
+758541,511109
+823425,508024
+149821,580667
+269258,553438
+481152,528891
+120871,591322
+972322,501901
+981350,501567
+676129,515483
+950860,502717
+119000,592114
+392252,537272
+191618,568919
+946699,502874
+289555,550247
+799322,509139
+703886,513942
+194812,568143
+261823,554685
+203052,566221
+217330,563093
+734748,512313
+391759,537328
+807052,508777
+564467,522510
+59186,629748
+113447,594545
+518063,525916
+905944,504492
+613922,519213
+439093,532607
+445946,531981
+230530,560399
+297887,549007
+459029,530797
+403692,536075
+855118,506616
+963127,502245
+841711,507208
+407411,535699
+924729,503735
+914823,504132
+333725,544101
+176345,572832
+912507,504225
+411273,535308
+259774,555036
+632853,518038
+119723,591801
+163902,576321
+22691,689944
+402427,536212
+175769,572988
+837260,507402
+603432,519893
+313679,546767
+538165,524394
+549026,523608
+61083,627945
+898345,504798
+992556,501153
+369999,539727
+32847,665404
+891292,505088
+152715,579732
+824104,507997
+234057,559711
+730507,512532
+960529,502340
+388395,537687
+958170,502437
+57105,631806
+186025,570311
+993043,501133
+576770,521664
+215319,563513
+927342,503628
+521353,525666
+39563,653705
+752516,511408
+110755,595770
+309749,547305
+374379,539224
+919184,503952
+990652,501226
+647780,517135
+187177,570017
+168938,574877
+649558,517023
+278126,552016
+162039,576868
+658512,516499
+498115,527486
+896583,504868
+561170,522740
+747772,511647
+775093,510294
+652081,516882
+724905,512824
+499707,527365
+47388,642755
+646668,517204
+571700,522007
+180430,571747
+710015,513617
+435522,532941
+98137,602041
+759176,511070
+486124,528467
+526942,525236
+878921,505604
+408313,535602
+926980,503640
+882353,505459
+566887,522345
+3326,853312
+911981,504248
+416309,534800
+392991,537199
+622829,518651
+148647,581055
+496483,527624
+666314,516044
+48562,641293
+672618,515684
+443676,532187
+274065,552661
+265386,554079
+347668,542358
+31816,667448
+181575,571446
+961289,502320
+365689,540214
+987950,501317
+932299,503440
+27388,677243
+746701,511701
+492258,527969
+147823,581323
+57918,630985
+838849,507333
+678038,515375
+27852,676130
+850241,506828
+818403,508253
+131717,587014
+850216,506834
+904848,504529
+189758,569380
+392845,537217
+470876,529761
+925353,503711
+285431,550877
+454098,531234
+823910,508003
+318493,546112
+766067,510730
+261277,554775
+421530,534289
+694130,514478
+120439,591498
+213308,563949
+854063,506662
+365255,540263
+165437,575872
+662240,516281
+289970,550181
+847977,506933
+546083,523816
+413252,535113
+975829,501767
+361540,540701
+235522,559435
+224643,561577
+736350,512229
+328303,544808
+35022,661330
+307838,547578
+474366,529458
+873755,505819
+73978,617220
+827387,507845
+670830,515791
+326511,545034
+309909,547285
+400970,536363
+884827,505352
+718307,513175
+28462,674699
+599384,520150
+253565,556111
+284009,551093
+343403,542876
+446557,531921
+992372,501160
+961601,502308
+696629,514342
+919537,503945
+894709,504944
+892201,505051
+358160,541097
+448503,531745
+832156,507636
+920045,503924
+926137,503675
+416754,534757
+254422,555966
+92498,605151
+826833,507873
+660716,516371
+689335,514746
+160045,577467
+814642,508425
+969939,501993
+242856,558047
+76302,615517
+472083,529653
+587101,520964
+99066,601543
+498005,527503
+709800,513624
+708000,513716
+20171,698134
+285020,550936
+266564,553891
+981563,501557
+846502,506991
+334,1190800
+209268,564829
+9844,752610
+996519,501007
+410059,535426
+432931,533188
+848012,506929
+966803,502110
+983434,501486
+160700,577267
+504374,526989
+832061,507640
+392825,537214
+443842,532165
+440352,532492
+745125,511776
+13718,726392
+661753,516312
+70500,619875
+436952,532814
+424724,533973
+21954,692224
+262490,554567
+716622,513264
+907584,504425
+60086,628882
+837123,507412
+971345,501940
+947162,502855
+139920,584021
+68330,621624
+666452,516038
+731446,512481
+953350,502619
+183157,571042
+845400,507045
+651548,516910
+20399,697344
+861779,506331
+629771,518229
+801706,509026
+189207,569512
+737501,512168
+719272,513115
+479285,529045
+136046,585401
+896746,504860
+891735,505067
+684771,514999
+865309,506184
+379066,538702
+503117,527090
+621780,518717
+209518,564775
+677135,515423
+987500,501340
+197049,567613
+329315,544673
+236756,559196
+357092,541226
+520440,525733
+213471,563911
+956852,502490
+702223,514032
+404943,535955
+178880,572152
+689477,514734
+691351,514630
+866669,506128
+370561,539656
+739805,512051
+71060,619441
+624861,518534
+261660,554714
+366137,540160
+166054,575698
+601878,519990
+153445,579501
+279899,551729
+379166,538691
+423209,534125
+675310,515526
+145641,582050
+691353,514627
+917468,504026
+284778,550976
+81040,612235
+161699,576978
+616394,519057
+767490,510661
+156896,578431
+427408,533714
+254849,555884
+737217,512182
+897133,504851
+203815,566051
+270822,553189
+135854,585475
+778805,510111
+784373,509847
+305426,547921
+733418,512375
+732087,512448
+540668,524215
+702898,513996
+628057,518328
+640280,517587
+422405,534204
+10604,746569
+746038,511733
+839808,507293
+457417,530938
+479030,529064
+341758,543090
+620223,518824
+251661,556451
+561790,522696
+497733,527521
+724201,512863
+489217,528217
+415623,534867
+624610,518548
+847541,506953
+432295,533249
+400391,536421
+961158,502319
+139173,584284
+421225,534315
+579083,521501
+74274,617000
+701142,514087
+374465,539219
+217814,562985
+358972,540995
+88629,607424
+288597,550389
+285819,550812
+538400,524385
+809930,508645
+738326,512126
+955461,502535
+163829,576343
+826475,507891
+376488,538987
+102234,599905
+114650,594002
+52815,636341
+434037,533082
+804744,508880
+98385,601905
+856620,506559
+220057,562517
+844734,507078
+150677,580387
+558697,522917
+621751,518719
+207067,565321
+135297,585677
+932968,503404
+604456,519822
+579728,521462
+244138,557813
+706487,513800
+711627,513523
+853833,506674
+497220,527562
+59428,629511
+564845,522486
+623621,518603
+242689,558077
+125091,589591
+363819,540432
+686453,514901
+656813,516594
+489901,528155
+386380,537905
+542819,524052
+243987,557841
+693412,514514
+488484,528271
+896331,504881
+336730,543721
+728298,512647
+604215,519840
+153729,579413
+595687,520398
+540360,524240
+245779,557511
+924873,503730
+509628,526577
+528523,525122
+3509,847707
+522756,525555
+895447,504922
+44840,646067
+45860,644715
+463487,530404
+398164,536654
+894483,504959
+619415,518874
+966306,502129
+990922,501212
+835756,507474
+548881,523618
+453578,531282
+474993,529410
+80085,612879
+737091,512193
+50789,638638
+979768,501620
+792018,509483
+665001,516122
+86552,608694
+462772,530469
+589233,520821
+891694,505072
+592605,520594
+209645,564741
+42531,649269
+554376,523226
+803814,508929
+334157,544042
+175836,572970
+868379,506051
+658166,516520
+278203,551995
+966198,502126
+627162,518387
+296774,549165
+311803,547027
+843797,507118
+702304,514032
+563875,522553
+33103,664910
+191932,568841
+543514,524006
+506835,526794
+868368,506052
+847025,506971
+678623,515342
+876139,505726
+571997,521984
+598632,520198
+213590,563892
+625404,518497
+726508,512738
+689426,514738
+332495,544264
+411366,535302
+242546,558110
+315209,546555
+797544,509219
+93889,604371
+858879,506454
+124906,589666
+449072,531693
+235960,559345
+642403,517454
+720567,513047
+705534,513858
+603692,519870
+488137,528302
+157370,578285
+63515,625730
+666326,516041
+619226,518883
+443613,532186
+597717,520257
+96225,603069
+86940,608450
+40725,651929
+460976,530625
+268875,553508
+270671,553214
+363254,540500
+384248,538137
+762889,510892
+377941,538833
+278878,551890
+176615,572755
+860008,506412
+944392,502967
+608395,519571
+225283,561450
+45095,645728
+333798,544090
+625733,518476
+995584,501037
+506135,526853
+238050,558952
+557943,522972
+530978,524938
+634244,517949
+177168,572616
+85200,609541
+953043,502630
+523661,525484
+999295,500902
+840803,507246
+961490,502312
+471747,529685
+380705,538523
+911180,504275
+334149,544046
+478992,529065
+325789,545133
+335884,543826
+426976,533760
+749007,511582
+667067,516000
+607586,519623
+674054,515599
+188534,569675
+565185,522464
+172090,573988
+87592,608052
+907432,504424
+8912,760841
+928318,503590
+757917,511138
+718693,513153
+315141,546566
+728326,512645
+353492,541647
+638429,517695
+628892,518280
+877286,505672
+620895,518778
+385878,537959
+423311,534113
+633501,517997
+884833,505360
+883402,505416
+999665,500894
+708395,513697
+548142,523667
+756491,511205
+987352,501340
+766520,510705
+591775,520647
+833758,507563
+843890,507108
+925551,503698
+74816,616598
+646942,517187
+354923,541481
+256291,555638
+634470,517942
+930904,503494
+134221,586071
+282663,551304
+986070,501394
+123636,590176
+123678,590164
+481717,528841
+423076,534137
+866246,506145
+93313,604697
+783632,509880
+317066,546304
+502977,527103
+141272,583545
+71708,618938
+617748,518975
+581190,521362
+193824,568382
+682368,515131
+352956,541712
+351375,541905
+505362,526909
+905165,504518
+128645,588188
+267143,553787
+158409,577965
+482776,528754
+628896,518282
+485233,528547
+563606,522574
+111001,595655
+115920,593445
+365510,540237
+959724,502374
+938763,503184
+930044,503520
+970959,501956
+913658,504176
+68117,621790
+989729,501253
+567697,522288
+820427,508163
+54236,634794
+291557,549938
+124961,589646
+403177,536130
+405421,535899
+410233,535417
+815111,508403
+213176,563974
+83099,610879
+998588,500934
+513640,526263
+129817,587733
+1820,921851
+287584,550539
+299160,548820
+860621,506386
+529258,525059
+586297,521017
+953406,502616
+441234,532410
+986217,501386
+781938,509957
+461247,530595
+735424,512277
+146623,581722
+839838,507288
+510667,526494
+935085,503327
+737523,512167
+303455,548204
+992779,501145
+60240,628739
+939095,503174
+794368,509370
+501825,527189
+459028,530798
+884641,505363
+512287,526364
+835165,507499
+307723,547590
+160587,577304
+735043,512300
+493289,527887
+110717,595785
+306480,547772
+318593,546089
+179810,571911
+200531,566799
+314999,546580
+197020,567622
+301465,548487
+237808,559000
+131944,586923
+882527,505449
+468117,530003
+711319,513541
+156240,578628
+965452,502162
+992756,501148
+437959,532715
+739938,512046
+614249,519196
+391496,537356
+62746,626418
+688215,514806
+75501,616091
+883573,505412
+558824,522910
+759371,511061
+173913,573489
+891351,505089
+727464,512693
+164833,576051
+812317,508529
+540320,524243
+698061,514257
+69149,620952
+471673,529694
+159092,577753
+428134,533653
+89997,606608
+711061,513557
+779403,510081
+203327,566155
+798176,509187
+667688,515963
+636120,517833
+137410,584913
+217615,563034
+556887,523038
+667229,515991
+672276,515708
+325361,545187
+172115,573985
+13846,725685
\ No newline at end of file
diff --git a/project_euler/problem_99/sol1.py b/project_euler/problem_99/sol1.py
new file mode 100644
index 000000000000..6729927dfa63
--- /dev/null
+++ b/project_euler/problem_99/sol1.py
@@ -0,0 +1,33 @@
+"""
+Problem:
+
+Comparing two numbers written in index form like 2'11 and 3'7 is not difficult, as any calculator would confirm that 2^11 = 2048 < 3^7 = 2187.
+
+However, confirming that 632382^518061 > 519432^525806 would be much more difficult, as both numbers contain over three million digits.
+
+Using base_exp.txt, a 22K text file containing one thousand lines with a base/exponent pair on each line, determine which line number has the greatest numerical value.
+
+NOTE: The first two lines in the file represent the numbers in the example given above.
+"""
+
+import os
+from math import log10
+
+
+def find_largest(data_file: str="base_exp.txt") -> int:
+    """
+    >>> find_largest()
+    709
+    """
+    largest = [0, 0]
+    for i, line in enumerate(
+        open(os.path.join(os.path.dirname(__file__), data_file))
+    ):
+        a, x = list(map(int, line.split(",")))
+        if x * log10(a) > largest[0]:
+            largest = [x * log10(a), i + 1]
+    return largest[1]
+
+
+if __name__ == "__main__":
+    print(find_largest())

From 8c443ccfad7ff98d72e017d2c7cb0482e981d184 Mon Sep 17 00:00:00 2001
From: Du YuanChao <shellhub.me@gmail.com>
Date: Mon, 4 Nov 2019 15:28:51 +0800
Subject: [PATCH 346/348] add floor() (#1551)

* ceil and floor

* ceil and floor
---
 maths/ceil.py  | 18 ++++++++++++++++++
 maths/floor.py | 18 ++++++++++++++++++
 2 files changed, 36 insertions(+)
 create mode 100644 maths/ceil.py
 create mode 100644 maths/floor.py

diff --git a/maths/ceil.py b/maths/ceil.py
new file mode 100644
index 000000000000..3e46f1474dcf
--- /dev/null
+++ b/maths/ceil.py
@@ -0,0 +1,18 @@
+def ceil(x) -> int:
+    """
+    Return the ceiling of x as an Integral.
+
+    :param x: the number
+    :return: the smallest integer >= x.
+
+    >>> import math
+    >>> all(ceil(n) == math.ceil(n) for n in (1, -1, 0, -0, 1.1, -1.1, 1.0, -1.0, 1_000_000_000))
+    True
+    """
+    return x if isinstance(x, int) or x - int(x) == 0 else int(x + 1) if x > 0 else int(x)
+
+
+if __name__ == '__main__':
+    import doctest
+
+    doctest.testmod()
diff --git a/maths/floor.py b/maths/floor.py
new file mode 100644
index 000000000000..a9b680b37b97
--- /dev/null
+++ b/maths/floor.py
@@ -0,0 +1,18 @@
+def floor(x) -> int:
+    """
+    Return the floor of x as an Integral.
+
+    :param x: the number
+    :return: the largest integer <= x.
+
+    >>> import math
+    >>> all(floor(n) == math.floor(n) for n in (1, -1, 0, -0, 1.1, -1.1, 1.0, -1.0, 1_000_000_000))
+    True
+    """
+    return x if isinstance(x, int) or x - int(x) == 0 else int(x) if x > 0 else int(x - 1)
+
+
+if __name__ == '__main__':
+    import doctest
+
+    doctest.testmod()

From 5452e94528ea357746f275c55bcdfd2e4604e19c Mon Sep 17 00:00:00 2001
From: "Marvin M. Michum" <11682032+mrvnmchm@users.noreply.github.com>
Date: Mon, 4 Nov 2019 02:45:29 -0500
Subject: [PATCH 347/348] Porta cipher (#1550)

* directory_writer

* add porta cipher for #1492

* formatting and one line comprehensions

* remove directory_writer

* indentions

* Wrap long lines
---
 ciphers/porta_cipher.py | 110 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 110 insertions(+)
 create mode 100644 ciphers/porta_cipher.py

diff --git a/ciphers/porta_cipher.py b/ciphers/porta_cipher.py
new file mode 100644
index 000000000000..a8e79415958d
--- /dev/null
+++ b/ciphers/porta_cipher.py
@@ -0,0 +1,110 @@
+alphabet = {
+    "A": ("ABCDEFGHIJKLM", "NOPQRSTUVWXYZ"),
+    "B": ("ABCDEFGHIJKLM", "NOPQRSTUVWXYZ"),
+    "C": ("ABCDEFGHIJKLM", "ZNOPQRSTUVWXY"),
+    "D": ("ABCDEFGHIJKLM", "ZNOPQRSTUVWXY"),
+    "E": ("ABCDEFGHIJKLM", "YZNOPQRSTUVWX"),
+    "F": ("ABCDEFGHIJKLM", "YZNOPQRSTUVWX"),
+    "G": ("ABCDEFGHIJKLM", "XYZNOPQRSTUVW"),
+    "H": ("ABCDEFGHIJKLM", "XYZNOPQRSTUVW"),
+    "I": ("ABCDEFGHIJKLM", "WXYZNOPQRSTUV"),
+    "J": ("ABCDEFGHIJKLM", "WXYZNOPQRSTUV"),
+    "K": ("ABCDEFGHIJKLM", "VWXYZNOPQRSTU"),
+    "L": ("ABCDEFGHIJKLM", "VWXYZNOPQRSTU"),
+    "M": ("ABCDEFGHIJKLM", "UVWXYZNOPQRST"),
+    "N": ("ABCDEFGHIJKLM", "UVWXYZNOPQRST"),
+    "O": ("ABCDEFGHIJKLM", "TUVWXYZNOPQRS"),
+    "P": ("ABCDEFGHIJKLM", "TUVWXYZNOPQRS"),
+    "Q": ("ABCDEFGHIJKLM", "STUVWXYZNOPQR"),
+    "R": ("ABCDEFGHIJKLM", "STUVWXYZNOPQR"),
+    "S": ("ABCDEFGHIJKLM", "RSTUVWXYZNOPQ"),
+    "T": ("ABCDEFGHIJKLM", "RSTUVWXYZNOPQ"),
+    "U": ("ABCDEFGHIJKLM", "QRSTUVWXYZNOP"),
+    "V": ("ABCDEFGHIJKLM", "QRSTUVWXYZNOP"),
+    "W": ("ABCDEFGHIJKLM", "PQRSTUVWXYZNO"),
+    "X": ("ABCDEFGHIJKLM", "PQRSTUVWXYZNO"),
+    "Y": ("ABCDEFGHIJKLM", "OPQRSTUVWXYZN"),
+    "Z": ("ABCDEFGHIJKLM", "OPQRSTUVWXYZN"),
+}
+
+
+def generate_table(key):
+    """
+    >>> generate_table('marvin')  # doctest: +NORMALIZE_WHITESPACE
+    [('ABCDEFGHIJKLM', 'UVWXYZNOPQRST'), ('ABCDEFGHIJKLM', 'NOPQRSTUVWXYZ'),
+     ('ABCDEFGHIJKLM', 'STUVWXYZNOPQR'), ('ABCDEFGHIJKLM', 'QRSTUVWXYZNOP'),
+     ('ABCDEFGHIJKLM', 'WXYZNOPQRSTUV'), ('ABCDEFGHIJKLM', 'UVWXYZNOPQRST')]
+    """
+    return [alphabet[char] for char in key.upper()]
+
+
+def encrypt(key, words):
+    """
+    >>> encrypt('marvin', 'jessica')
+    'QRACRWU'
+    """
+    cipher = ""
+    count = 0
+    table = generate_table(key)
+    for char in words.upper():
+        cipher += get_opponent(table[count], char)
+        count = (count + 1) % len(table)
+    return cipher
+
+
+def decrypt(key, words):
+    """
+    >>> decrypt('marvin', 'QRACRWU')
+    'JESSICA'
+    """
+    return encrypt(key, words)
+
+
+def get_position(table, char):
+    """
+    >>> table = [
+    ...     ('ABCDEFGHIJKLM', 'UVWXYZNOPQRST'), ('ABCDEFGHIJKLM', 'NOPQRSTUVWXYZ'),
+    ...     ('ABCDEFGHIJKLM', 'STUVWXYZNOPQR'), ('ABCDEFGHIJKLM', 'QRSTUVWXYZNOP'),
+    ...     ('ABCDEFGHIJKLM', 'WXYZNOPQRSTUV'), ('ABCDEFGHIJKLM', 'UVWXYZNOPQRST')]
+    >>> get_position(table, 'A')
+    (None, None)
+    """
+    if char in table[0]:
+        row = 0
+    else:
+        row = 1 if char in table[1] else -1
+    return (None, None) if row == -1 else (row, table[row].index(char))
+
+
+def get_opponent(table, char):
+    """
+    >>> table = [
+    ...     ('ABCDEFGHIJKLM', 'UVWXYZNOPQRST'), ('ABCDEFGHIJKLM', 'NOPQRSTUVWXYZ'),
+    ...     ('ABCDEFGHIJKLM', 'STUVWXYZNOPQR'), ('ABCDEFGHIJKLM', 'QRSTUVWXYZNOP'),
+    ...     ('ABCDEFGHIJKLM', 'WXYZNOPQRSTUV'), ('ABCDEFGHIJKLM', 'UVWXYZNOPQRST')]
+    >>> get_opponent(table, 'A')
+    'A'
+    """
+    row, col = get_position(table, char.upper())
+    if row == 1:
+        return table[0][col]
+    else:
+        return table[1][col] if row == 0 else char
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()  # Fist ensure that all our tests are passing...
+    """
+    ENTER KEY: marvin
+    ENTER TEXT TO ENCRYPT: jessica
+    ENCRYPTED: QRACRWU
+    DECRYPTED WITH KEY: JESSICA
+    """
+    key = input("ENTER KEY: ").strip()
+    text = input("ENTER TEXT TO ENCRYPT: ").strip()
+    cipher_text = encrypt(key, text)
+
+    print(f"ENCRYPTED: {cipher_text}")
+    print(f"DECRYPTED WITH KEY: {decrypt(key, cipher_text)}")

From a9d5378ce2251b43d4f2541283ff6f1a558a3bfa Mon Sep 17 00:00:00 2001
From: John Law <johnlaw.po@gmail.com>
Date: Tue, 5 Nov 2019 02:06:16 +0800
Subject: [PATCH 348/348] Doctest and typing for
 longest_increasing_subsequence.py (#1526)

* Update longest_increasing_subsequence.py

* Update longest_increasing_subsequence.py

* Format longest_increasing_subsequence.py to PEP8

* Update longest_increasing_subsequence.py
---
 .../longest_increasing_subsequence.py         | 62 +++++++++++--------
 1 file changed, 36 insertions(+), 26 deletions(-)

diff --git a/dynamic_programming/longest_increasing_subsequence.py b/dynamic_programming/longest_increasing_subsequence.py
index 3cb57806e06f..6d12f1c7caf0 100644
--- a/dynamic_programming/longest_increasing_subsequence.py
+++ b/dynamic_programming/longest_increasing_subsequence.py
@@ -4,42 +4,52 @@
 This is a pure Python implementation of Dynamic Programming solution to the longest increasing subsequence of a given sequence.
 
 The problem is  :
-Given an ARRAY, to find the longest and increasing sub ARRAY in that given ARRAY and return it.
+Given an array, to find the longest and increasing sub-array in that given array and return it.
 Example: [10, 22, 9, 33, 21, 50, 41, 60, 80] as input will return [10, 22, 33, 41, 60, 80] as output
 """
-
-
-def longestSub(ARRAY):  # This function is recursive
-
-    ARRAY_LENGTH = len(ARRAY)
+from typing import List
+
+
+def longest_subsequence(array: List[int]) -> List[int]:  # This function is recursive
+    """
+    Some examples
+    >>> longest_subsequence([10, 22, 9, 33, 21, 50, 41, 60, 80])
+    [10, 22, 33, 41, 60, 80]
+    >>> longest_subsequence([4, 8, 7, 5, 1, 12, 2, 3, 9])
+    [1, 2, 3, 9]
+    >>> longest_subsequence([9, 8, 7, 6, 5, 7])
+    [8]
+    >>> longest_subsequence([1, 1, 1])
+    [1, 1, 1]
+    """
+    array_length = len(array)
     if (
-        ARRAY_LENGTH <= 1
+        array_length <= 1
     ):  # If the array contains only one element, we return it (it's the stop condition of recursion)
-        return ARRAY
+        return array
         # Else
-    PIVOT = ARRAY[0]
+    pivot = array[0]
     isFound = False
     i = 1
-    LONGEST_SUB = []
-    while not isFound and i < ARRAY_LENGTH:
-        if ARRAY[i] < PIVOT:
+    longest_subseq = []
+    while not isFound and i < array_length:
+        if array[i] < pivot:
             isFound = True
-            TEMPORARY_ARRAY = [element for element in ARRAY[i:] if element >= ARRAY[i]]
-            TEMPORARY_ARRAY = longestSub(TEMPORARY_ARRAY)
-            if len(TEMPORARY_ARRAY) > len(LONGEST_SUB):
-                LONGEST_SUB = TEMPORARY_ARRAY
+            temp_array = [element for element in array[i:] if element >= array[i]]
+            temp_array = longest_subsequence(temp_array)
+            if len(temp_array) > len(longest_subseq):
+                longest_subseq = temp_array
         else:
             i += 1
 
-    TEMPORARY_ARRAY = [element for element in ARRAY[1:] if element >= PIVOT]
-    TEMPORARY_ARRAY = [PIVOT] + longestSub(TEMPORARY_ARRAY)
-    if len(TEMPORARY_ARRAY) > len(LONGEST_SUB):
-        return TEMPORARY_ARRAY
+    temp_array = [element for element in array[1:] if element >= pivot]
+    temp_array = [pivot] + longest_subsequence(temp_array)
+    if len(temp_array) > len(longest_subseq):
+        return temp_array
     else:
-        return LONGEST_SUB
-
-
-# Some examples
+        return longest_subseq
+    
 
-print(longestSub([4, 8, 7, 5, 1, 12, 2, 3, 9]))
-print(longestSub([9, 8, 7, 6, 5, 7]))
+if __name__ == "__main__":
+    import doctest
+    doctest.testmod()