Merge pull request #1622 from hashfx/issue-1519

fixes #1519

Author: avinashkranjan

DSA-Python/Algorithms/BigO.md

@@ -0,0 +1,96 @@
+# BigO Notation
+
+### Big O Notation is used to measure how running time or space requirements for your program grow as input size grows
+
+## Order of Magnitude
+
+### A Time Complexity does not tell the exact number of times the code inside a loop is executed, but it only shows the order of magnitude. Whether code inside loop is executed for 3n, n+5, n/2 times; the time complexity of each code is O(n)
+
+## Rules for BigO Notation
+```time = a * n + b```
++ ### Keep the fastest growing term
+     #### BigO refers to very large value of n. Hence, if you have a function like:
+```javascript
+let time = 5*n^2 + 3*n + 20
+// when value of n is very large (b*n + c) become irrelevant
+let n = 1000
+time = 5*1000^2 + 3*1000 + 20
+time = 5000000 + 3020
+time === 5000000  // terms other than 5*1000^2 contribute negligible
+```
+
+#### time = a * n  # being b a constant and static
++ ### Drop constant
+    #### `time = n  # a being constant`
+    `time = O(n)`
+
+## Measuring running time growth (Time Complexity)
+
++ ## Constant Time Complexity O(1)
+  ### Running time of Constant-time algorithm does not depend on the input size
+```js    
+time = a
+time = O(1)  // applying rules for Big O :: Keep fastest growing term (a)
+ ```
+
+```python
+def foo(arr):  # time is nearly constant with increase in input size
+    sizeof(arr) : 100   -> 0.22 milliseconds
+    sizeof(arr) : 1000  -> 0.23 milliseconds
+```
+
++ ## Logarithmic Time Complexity O(log n)
+  ### A logarithmic algorithm often halves the input size at each step. The running time of such an algorithm is logarithmic, because log2 n equals the number of times n must be divided by 2 to get 1
+
++ ## Square Root Algorithm O(sqrt(n))
+### A square root algorithm is slower than O(log n) but faster than O(n) A special property of square roots is that ```sqrt(n) = n/(sqrt(n))```, so the square root `(sqrt(n))` lies, in some sense, in the middle of the input
+
++ ## Linear Time Complexity O(n)
+  ### A linear algorithm goes through the input a constant number of times
+```js
+    time = a * n + b
+    time = O(n)  // applying rules for Big O :: Keep fastest growing term (a*n) ->->-> Drop Constants(a, b)
+```
+```python
+def foo(arr):
+    sizeof(arr) : 100   -> 0.22 milliseconds
+    sizeof(arr) : 1000  -> 2.30 milliseconds
+```
+
++ ## O(n log n)
+### This time complexity often indicates that the algorithm sorts the input, because the time complexity of efficient sorting algorithms is O(n log n)
+
++ ## Quadratic Time Complexity O(n^2)
+### A quadratic time complexity often contains two nested loops
+```js    
+time = a * (n^2) + b
+time = O(n^2)  // applying rules for Big O :: Keep fastest growing term (a*n^2) ->->-> Drop Constants(a, b)
+/*Exception O(n^2) not O(n^2 + n)*/
+time = a*(n^2) + (b * n) + c
+time = n^2  // applying rules for Big O :: Keep fastest growing term (a*n^2) ->->-> Drop Constants(a, b, c)
+```
+
++ ## Cubic Time Complexity O(n^3)
+### A cubic algorithm often contains three nested loops
+
++ ## O(2^n)
+### This time complexity often indicates that the algorithm iterates through all subsets of the input elements
+
++ ## O(n!)
+### This time complexity often indicates that the algorithm iterates through all permutations of the input elements
+
+### Note:
+  #### An algorithm is polynomial if its time complexity is at most O(nk) where k is a constant.
+#### All the above time complexities except O(2n) and O(n!) are polynomial
+
+### Given the input size, we can try to guess the required time complexity of the algorithm that solves the problem.
+### The following table contains some useful estimates assuming a time limit of one second
+
+|Input Size|Time Complexity|
+|---|---|
+|n <= 10|     O(n!)|
+|n <= 20|     O(2n)|
+|n <= 500|    O(n3)|
+|n <= 5000|   O(n2)|
+|n <= 106|    O(n logn) or O(n)|
+|n is large|  O(1) or O(log n)|

DSA-Python/Algorithms/BigO.py

@@ -0,0 +1,158 @@
+"""
+BigO Notation
+    Big O Notation is used to measure hoe running time or space requirements for your program grow as input size grows
+Order of Magnitude
+    A Time Complexity does not tell the exact number of times the code inside a loop is executed,
+    but it only shows the order of magnitude. Whether code inside loop is executed for 3n, n+5, n/2 times;
+    the time complexity of each code is O(n)
+
+Rules for BigO Notation
+    time = a * n + b
+    > Keep fastest growing term
+            BigO refers to very large value of n. Hence if you have a function like:
+                time = 5*n^2 + 3*n + 20
+                when value of n is very large (b*n + c) become irrelevant
+                Example: n = 1000
+                time = 5*1000^2 + 3*1000 + 20
+                time = 5000000 + 3020
+                time ~= 5000000  # terms other than 5*1000^2 contribute negligible
+
+        time = a * n  # being b a constant and static
+
+    > Drop constant
+        time = n  # a being constant
+        time = O(n)
+
+Measuring running time growth (Time Complexity)
+
+    Constant Time Complexity O(1)
+        Running time of Constant-time algorithm does not depend on the input size
+        time = a
+        time = O(1)  # applying rules for Big O :: Keep fastest growing term (a) ->->-> Drop Constants(a)
+
+
+        def foo(a):  # time is nearly constant with increase in input size
+            size(arr) : 100   -> 0.22 milliseconds
+            size(arr) : 1000  -> 0.23 milliseconds
+
+    Logarithmic Time Complexity O(log n)
+        A logarithmic algorithm often halves the input size at each step. The running time of such an algorithm is
+        logarithmic, because log2 n equals the number of times n must be divided by 2 to get 1
+
+    Square Root Algorithm O(sqrt(n))
+        A square root algorithm is slower than O(log n) but faster than O(n) A special property of square roots is that
+        sqrt(n) = n/(sqrt(n)), so the square root (sqrt(n)) lies, in some sense, in the middle of the input
+
+    Linear Time Complexity O(n)
+        A linear algorithm goes through the input a constant number of times
+        time = a * n + b
+        time = O(n)  # applying rules for Big O :: Keep fastest growing term (a*n) ->->-> Drop Constants(a, b)
+
+        def foo(arr):
+            size(arr) : 100   -> 0.22 milliseconds
+            size(arr) : 1000  -> 2.30 milliseconds
+
+    O(n log n)
+        This time complexity often indicates that the algorithm sorts the input, because the time complexity of
+        efficient sorting algorithms is O(n logn)
+
+    Quadratic Time Complexity O(n^2)
+        A quadratic time complexity often contains two nested loops
+        time = a * (n^2) + b
+        time = O(n^2)  # applying rules for Big O :: Keep fastest growing term (a*n^2) ->->-> Drop Constants(a, b)
+        Exception O(n^2) not O(n^2 + n)
+            time = a*(n^2) + (b * n) + c
+            time = n^2  # applying rules for Big O :: Keep fastest growing term (a*n^2) ->->-> Drop Constants(a, b, c)
+
+    Cubic Time Complexity O(n^3)
+        A cubic algorithm often contains three nested loops
+
+    O(2^n)
+        This time complexity often indicates that the algorithm iterates through all subsets of the input elements
+
+    O(n!)
+        This time complexity often indicates that the algorithm iterates through all permutations of the input elements
+
+    Note:
+        An algorithm is polynomial if its time complexity is at most O(nk) where k is a constant.
+        All the above time complexities except O(2n) and O(n!) are polynomial
+
+Given the input size, we can try to guess the required time complexity of the algorithm that solves the problem.
+The following table contains some useful estimates assuming a time limit of one second
+
+    n <= 10     O(n!)
+    n <= 20     O(2n)
+    n <= 500    O(n3)
+    n <= 5000   O(n2)
+    n <= 106    O(n logn) or O(n)
+    n is large  O(1) or O(log n)
+
+
+"""
+""" Time Complexity """
+
+# Linear Time Complexity O(n)
+def squareNum(numbers):
+    """
+    Time Complexity: O(n)  :: loop will iterate n time linearly
+    """
+    sqNum = []  # empty array for squared numbers initialised
+    for n in numbers:  # loop will iterate n times
+        sqNum.append(n*n)
+    return sqNum
+
+
+# Constant Time Complexity O(1)
+def findPE(prices, eps, index):
+    pe = prices[index] / eps[index]
+    return pe
+
+
+# O(n^2)
+def duplicateInArray(numbers):
+    """ Running two for loops"""
+    duplicate = None
+    # (n^2) iterations
+    for i in range(len(numbers)):
+        for j in range(i+1, len(numbers)):
+            if numbers[i] == numbers[j]:
+                print(f"{numbers[i]} is duplicate")
+                duplicate = numbers[i]
+                break
+    # n iterations
+    for i in range(len(numbers)):
+        if numbers[i] == duplicate:
+            print(i)
+
+
+""" Space Complexity """
+def Search(numbers):
+    """
+    Search for 10 in list
+    Time Complexity: O(n)
+    """
+    for i in range(len(numbers)):
+        if numbers[i] == 10:
+            print(i)
+
+
+
+
+if __name__ == '__main__':
+    # O(n)
+    numbers = [2, 5, 7, 9]
+    print(squareNum(numbers))
+
+    # O(1)
+    prices = [250, 500, 450]
+    eps = [25, 50, 75]
+    index = 1
+    print(findPE(prices, eps, index))
+
+    # O(n^2)
+    numbers = [2, 4, 6, 8, 14, 9, 4]
+    duplicateInArray(numbers)
+
+    numbers = [1, 6, 8, 10, 4, 5]
+    Search(numbers)
+

DSA-Python/Algorithms/BinarySearch.py

@@ -0,0 +1,105 @@
+"""
+Binary Search Algorithm
+    Search Algorithm that finds the position of a target value within a sorted array(ASCE).
+    Binary search compares the target value to the middle element of the array.
+    Normal Zindagi (Linear Search):
+        To find an element from a list, compare elements from index[0] till the element is found
+    Mentos Zindagi (Binary Search):
+        To find an element k from a list:
+            > Sort the array in Ascending order
+            > Find the middle element from the list
+            > Compare it with key to be found
+                > If middle element is less than key, find the middle element of the list at right-side of the middle element
+                > If middle element is more than key, find the middle element of the list at left-side of the middle element
+                > Repeat above 2 steps until the key is found
+                > Return index of the key if it is found in the list
+                > If key is not found in the list, return -1 or false
+        With every iteration, search space is divided by 1/2
+            Iteration 1 = n/2
+            Iteration 2 = (n/2)/2 = n/2^2
+            Iteration 3 = (n/2^2) = n/2^3
+            Iteration k = (n/2^k)
+                1 = n/2^k
+                n = 2^k
+                log2(n) = log2(2^k)
+                log2(n) = k*log2(2)
+                k = log(n)
+            Time Complexity: O(log n)
+
+
+key: 18
+2 4 6 8 |10| 12 16 18 20    :: key not in {2, 4, 6, 8, 10}
+~2 4 6 8 10~ 12 |16| 18 20  :: key not in {12}
+~2 4 6 8 10 12 16~ |18| 20  :: key found in {18} at index[7]
+Output:
+7
+
+Linear Search   7 iterations    O(n)
+Binary Search   3 iterations    log(n)
+"""
+
+def LinearSearch(numList, key):
+    for index, element in enumerate(numList):  # return index as well as element
+        if element == key:
+            return index  # if key is found in list, return index of key
+    return -1
+
+def BinarySearch(numList, key):
+    left = 0  # index of elements at left of the mid value
+    right = len(numList) - 1  # index of elements at right of the mid value
+    mid_index = 0  # index of mid value
+
+    while left <= right:  # while index[left] <= index[right]
+        mid_index = (left + right)  // 2  # '//2' returns integer value
+        mid_num = numList[mid_index]
+
+        if mid_num == key:  # middle number is equal to key
+            return mid_index
+        if mid_num < key:
+            left = mid_index + 1
+        else:  # mid_num > key
+            right = mid_index - 1
+
+    return -1
+
+
+"""Binary Search using Recursion"""
+def BinarySearchRecursion(numList, key, leftIndex, rightIndex):  # will search within left and right
+    if rightIndex < leftIndex:  # won't iterate in reverse order
+        return -1
+
+    mid_index = (leftIndex + rightIndex) // 2  # '//2' returns integer value
+    if mid_index >= len(numList):  # if key is out of index of list, return -1
+        return -1
+
+    mid_num = numList[mid_index]
+    if mid_num == key:  # middle number is equal to key
+        return mid_index
+
+    if mid_num < key:
+        leftIndex = mid_index + 1
+    else:  # mid_num > key
+        rightIndex = mid_index - 1
+
+    return BinarySearchRecursion(numList, key, leftIndex, rightIndex)
+
+
+
+
+
+
+if __name__ == '__main__':
+    numList = [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
+    key = 18
+    # Linear Search
+    index = LinearSearch(numList, key)
+    print(f"Linear Search: Number found at index {index}")
+    # Binary Search
+    index = BinarySearch(numList, key)
+    print(f"Binary Search: Number found at index {index}")
+    # Binary Search using Recursion
+    index = BinarySearchRecursion(numList, key, 0, len(numList))
+    print(f"Binary Search Recursion: Number found at index {index}")
+
+
+