Add files via upload

Author: danishkhanbx

Abstract Classes & Methods.py

@@ -0,0 +1,20 @@
+from abc import ABC, abstractmethod
+# ABC = Abstract Base Class. Abstract class which has least one abstract method in the class.
+# Abstract methods are which doesn't have any definition it only has a declaration.
+
+
+class Computer(ABC):  # abstract class Computer which have abstract method process
+    @abstractmethod
+    def process(self):
+        pass
+
+
+class Laptop(Computer):  # cls Laptop is inheriting abstract cls Computer, so it is compulsory to define abstract method
+    def process(self):
+        print('its running')
+
+
+#com = Computer()
+#com.process()
+com1 = Laptop()
+com1.process()

Algorithms/Binary Search.py

@@ -0,0 +1,51 @@
+# Iterative Binary Search Function.
+# It returns index of x in given array arr if present, else returns -1
+"""
+def search(arr, key):
+    low = 0
+    high = len(arr) - 1
+    mid = 0
+    while low <= high:
+        mid = (low + high) // 2
+        if arr[mid] < key:  # If x is greater, ignore left half
+            low = mid + 1
+        elif arr[mid] > key:  # If x is smaller, ignore right half
+            high = mid - 1
+        else:   # means x is present at mid
+            return mid
+
+    return -1
+
+
+arr = [1, 2, 3, 6, 9, 10]
+key = int(input('Enter the key to Searched: '))
+index = search(arr, key)
+if index == -1:
+    print('Key not found')
+else:
+    print('Key found at index', index + 1)
+"""
+
+
+# Recursive binary search.
+# Returns index of x in arr if present, else -1
+def search(arr, low, high, key):
+    if low <= high:
+        mid = (low + high) // 2
+        if arr[mid] == key:  # If element is present at the middle itself
+            return mid
+        elif arr[mid] > key:  # If element is smaller than mid, then it can only be present in left subarray
+            return search(arr, low, mid-1, key)
+        else:   # Else the element can only be present in right subarray
+            return search(arr, mid+1, high, key)
+    else:  # Element is not present in the array
+        return -1
+
+
+arr = [1, 2, 3, 6, 9, 10]
+key = int(input('Enter the key to Searched: '))
+index = search(arr, 0, len(arr)-1, key)
+if index == -1:
+    print('Key not found')
+else:
+    print('Key found at index', index + 1)

Algorithms/Boyer-Moore.py

@@ -0,0 +1,52 @@
+NO_OF_CHARS = 256
+
+
+# The preprocessing function for Boyer Moore's bad character heuristic
+def badCharHeuristic(string, size):
+    # Initialize all occurrence as -1
+    badChar = [-1] * NO_OF_CHARS
+
+    # Fill the actual value of last occurrence
+    for i in range(size):  # badChar = [-1, -1,...{65, 0},{66, 1}, {67, 2},...-1]
+        badChar[ord(string[i])] = i
+
+    # return initialized list
+    return badChar
+
+
+# A pattern searching function that uses Bad Character Heuristic of Boyer Moore Algorithm
+def search(txt, pat):
+    m = len(pat)
+    n = len(txt)
+
+    # create the bad character list by calling the preprocessing function badCharHeuristic() for given pattern
+    badChar = badCharHeuristic(pat, m)
+
+    # s is shift of the pattern with respect to text
+    s = 0
+    while s <= n - m:
+        j = m - 1
+
+        # Keep reducing index j of pattern while characters of pattern and text are matching at this shift s
+        while j >= 0 and pat[j] == txt[s + j]:
+            j -= 1
+
+        # If the pattern is present at current shift, then index j will become -1 after the above loop
+        if j < 0:
+            print("Pattern occur at shift = {}".format(s))
+            # Shift the pattern so that the next character in text aligns with the last occurrence of it in pattern.
+            # The condition s+m < n is necessary for the case when pattern occurs at the end of text
+            s += (m - badChar[ord(txt[s + m])] if s + m < n else 1)  # badChar[ord(txt[4+3=7]=D)=-1
+        else:
+            # Shift the pattern so that the bad character in text aligns with the last occurrence of it in pattern.
+            # The max function is used to make sure that we get a positive shift.
+            # We may get a negative shift if the last occurrence of bad character in pattern is on the right side of
+            # the current character.
+            s += max(1, j - badChar[ord(txt[s + j])])  # barChar[ ord (txt[0+2]=A) = 65] = 0
+
+
+# Driver program
+if __name__ == '__main__':
+    txt = "ABAAABCD"
+    pat = "ABC"
+    search(txt, pat)

Algorithms/Bubble Sort.py

@@ -0,0 +1,17 @@
+def sort(arr):
+    for i in range(len(arr) - 1):  # Traverse through all array elements, len - 1 because outer loop will repeat one
+        # time more than needed
+        swapped = False
+        for j in range(0, len(arr) - i - 1):  # Last i elements are already in place
+            if arr[j] > arr[j + 1]:  # Swap the element, if right is founded smaller than the left element
+                arr[j], arr[j + 1] = arr[j + 1], arr[j]
+                swapped = True
+        if not swapped:  # not swapped=not False=True, so if True it will break the i loop if no swap is done in j loop.
+            break  # Time = O(n) for already sorted array.
+
+    return arr
+
+
+arr = [15, 20, 35, 49, 5, 36, 77]
+sort(arr)
+print(arr)

Algorithms/Insertion Sort.py

@@ -0,0 +1,22 @@
+# To sort an array of size N in ascending order:
+# Iterate from arr[1] to arr[N] over the array.
+# Compare the current element (key) index i to its predecessor index j = i-1.
+# If the key element is smaller than its predecessor, compare it to the elements before j= i-2.
+# Store the first value(assuming it is the smallest) in temp and move the greater elements one position ahead.
+
+def sort(elements):
+    for i in range(len(elements)):  # at i=0 nothing will work, so lets take i=2 and j=1
+        small = elements[i]
+        j = i - 1
+        while j >= 0 and elements[j] > small:  # j index greater than -1 and index j=1 element > index i=2 element
+            elements[j + 1] = elements[j]      # storing j(1) value at j+1 = i = 2
+            j = j - 1  # j=0 now, so on the next iteration the while loop will check if j=0 > i or not, if it is then
+            # the swapping continues i.e. storing j value at j+1 = 1 until while one of conditions fails
+        elements[j + 1] = small  # while loop exists at j=-1, so at index 0 storing the smallest element
+
+
+if __name__ == '__main__':
+    elements = [99, 77, 66, 88, 33, 22, 11, 0]
+    sort(elements)
+    print(elements)
+

Algorithms/Linear Search.py

@@ -0,0 +1,15 @@
+def search(arr, key):
+    for i in range(len(arr)):
+        if arr[i] == key:
+            return i
+    return -1
+
+
+arr = [15, 20, 35, 49, 5, 36, 77]
+key = int(input('Enter the key to Searched: '))
+index = search(arr, key)
+if index == -1:
+    print('Key not found')
+else:
+    print('Key found at index', index+1)
+

Algorithms/Merge Sort.py

@@ -0,0 +1,49 @@
+def merge_sort(arr):
+    if len(arr) <= 1:  # when there is one or fewer elements
+        return
+
+    mid = len(arr) // 2
+    left = arr[:mid]   # 0 to mid-1
+    right = arr[mid:]  # mid to len(arr)
+
+    # Finding the mid of the passed array. The mid will lead to the creation of 2 separate array lists sending the first
+    # and second half separately of the array to get divided again and again till reaches 1 element in returning time we
+    # will start comparing the elements and sorting them. First 2-2 lists of elements then 4-4 lists of elements & so on
+    # Calling time we divide till 1 Returning time we compare(sort) and merge.
+
+    merge_sort(left)
+    merge_sort(right)
+
+    merge_two_sorted_lists(left, right, arr)
+
+
+def merge_two_sorted_lists(a, b, arr):
+    len_a = len(a)
+    len_b = len(b)
+
+    i = j = k = 0  # i,j,k are index pointers. i points to array a, j to array b, and k to array arr
+
+    while i < len_a and j < len_b:  # stopping when reached either end of the lists
+        if a[i] <= b[j]:          # array a value is less, than add it to the array arr and increment a++ index pointers
+            arr[k] = a[i]
+            i += 1
+        else:
+            arr[k] = b[j]
+            j += 1
+        k += 1        # of the two conditions one will be true, & in each array arr pointer k will be incremented++
+
+    while i < len_a:  # when either one of the lists ended, we copy the remaining elements of(either a or b) in arr
+        arr[k] = a[i]
+        i += 1
+        k += 1
+
+    while j < len_b:
+        arr[k] = b[j]
+        j += 1
+        k += 1
+
+
+if __name__ == '__main__':
+    elements = [11, 9, 29, 7, 2, 15, 28]
+    merge_sort(elements)
+    print(elements)

Algorithms/Quick Sort.py

@@ -0,0 +1,53 @@
+# Algorithm:
+# Select pivot, low, and high elements.
+# Keep moving low & high pointers until we found the indexes which satisfies the conditions:
+#  A[low] > A[pivot] and A[high] <= A[pivot]
+#  If low < high then swap A[low] with A[high] and
+#  If low >= high then swap A[pivot] with A[high]
+
+def swap(a, b, arr):
+    if a != b:
+        arr[a], arr[b] = arr[b], arr[a]
+
+
+# Hoare partition
+def partition(elements, start, end):
+    pivot_index = start  # taking the first index(0) as a pivot in Hoare's partition
+    pivot = elements[pivot_index]  # pivot index value
+    while start < end:  # these while loops will stop at the index which satisfies the conditions
+        while start < len(elements) and elements[start] <= pivot:  # start < size and start value <= pivot value
+            start += 1  # incrementing start index pointer, i.e. start points to index 2 now, if it pointed to 1 before
+
+        while elements[end] > pivot:  # it will stop when pivot value > then end value, so we have found the index
+            end -= 1  # decrementing end index pointer, i.e. end points to index 5 now, if it pointed to 6 before
+
+        if start < end:
+            swap(start, end, elements)
+
+    swap(pivot_index, end, elements)  # when end >= start, swapping end with pivot, the pivot value at end index will be
+    return end  # sorted element, which is at its perfect index
+
+
+def partitions(elements, start, end):
+    pivot = elements[end]
+    pi = start
+    for i in range(start, end):
+        if elements[i] <= pivot:
+            swap(i, pi, elements)
+            pi += 1
+    swap(pi, end, elements)
+    return pi
+
+
+def quick_sort(elements, start, end):
+    if start < end:
+        pi = partition(elements, start, end)  # after finding the middle element we store that at pi index in the Array
+        quick_sort(elements, start, pi - 1)  # in the 0 to pi-1 array & pi +1 to end array, we will again find
+        quick_sort(elements, pi + 1, end)  # partition index(pi) and divide these arrays further till one element
+        # remains which is implicitly sorted
+
+
+if __name__ == '__main__':
+    elements = [11, 9, 29, 7, 2, 15, 28]
+    quick_sort(elements, 0, len(elements) - 1)
+    print(elements)

Algorithms/Rabin-Karp.py

@@ -0,0 +1,42 @@
+d = 10  # Let d be the number of characters in the input set
+
+
+def search(pattern, text, q):
+    m = len(pattern)
+    n = len(text)
+    p = 0
+    t = 0
+    h = 1
+    i = 0
+    j = 0
+
+    for i in range(m-1):  # i=0,1
+        h = (h*d) % q     # i=0 h=1*10%13=10, i=1 h=10*10%13=9
+
+    # Calculate hash value for pattern and text
+    for i in range(m):  # i=0,1,2
+        p = (d*p + ord(pattern[i])) % q  # i=0 p=10*0+67%13=2 t=10*0+65%13=0, i=1 p=10*2+68%13=10 t=10*0+66%13=1,
+        t = (d*t + ord(text[i])) % q   # i=2 p=10*10+68%13=12 t=10*1+67%13=12
+
+    # Find the match
+    for i in range(n-m+1):  # i=0,1,2,3,4,5,6,7
+        if p == t:
+            for j in range(m):  # j=0,1,2 now comparing text and pattern character by character
+                if text[i+j] != pattern[j]:  # if even one of them dosent match
+                    break
+
+            j += 1  # when all charcaters matched perfectly j will be 2, means we have a match
+            if j == m:  # after adding 1 to j, if j matches m means we have found patter at position i+1 and index i
+                print("Pattern is found at position: " + str(i+1))
+
+        if i < n-m:  # when current index is less than last position 8(index=7) to be checked
+            t = (d * (t - ord(text[i]) * h) + ord(text[i+m])) % q  # sliding window adding a new char and removing the first char
+            #   10 * (12 - ord(i=0(A)) * 9) + ord(i+m=3(C)) % 13 = (10 ( 12 - 65 * 9) + 67) % 13 = 5
+            if t < 0:  # if we get t in minus add the prime number to it
+                t = t+q
+
+
+text = "ABCCDDAEFG"
+pattern = "CDD"
+q = 13
+search(pattern, text, q)

Algorithms/Selection Sort.py

@@ -0,0 +1,22 @@
+# The selection sort algorithm sorts an array by repeatedly finding the minimum element (considering ascending order)
+# from unsorted part and putting it at the beginning. The algorithm maintains two sub-arrays in a given array.
+# 1) The subarray which is already sorted.
+# 2) Remaining subarray which is unsorted.
+# In every iteration of selection sort, the minimum element (considering ascending order) from the
+# unsorted subarray is picked and moved to the sorted subarray.
+
+def sort(arr):
+    for i in range(len(arr)):  # after one phase is completed element present at i=0 will be a sorted element
+        # then i moves to the next index(i++) now only unsorted elements remains, i=0 will be excluded from now on
+        min_index = i  # Find the minimum element in remaining unsorted array
+        for j in range(i + 1, len(arr)):  # j=i+1 to j=len
+            if arr[min_index] > arr[j]:  # means if i=0 is greater than j=1
+                min_index = j  # then min will store value j index(1) value
+        arr[i], arr[min_index] = arr[min_index], arr[i]  # i=0, j=1 swapped by i=1 and j=0
+
+    return arr
+
+
+arr = [99, 77, 66, 88, 33, 22, 11, 0]
+sort(arr)
+print(arr)

Algorithms/Shell Sort.py

@@ -0,0 +1,20 @@
+def sort(arr):
+    size = len(arr)  # let size = 10 then the gap we go from 5, 2(floor value), 1
+    gap = size // 2  # at gap of 1 this algorithm will work same as Insertion sort
+
+    while gap > 0:
+        for i in range(gap, size):  # when gap=5, picking elements in array by the gap number for current i, i.e. i=0,5
+            anchor = arr[i]  # at i=0 the while loop will not start till i(5)=j i.e. gap=5 and j should be 5 or greater
+            j = i            # when i=5, anchor[5] = 9 will be compared with index(0) = 11
+            while j >= gap and arr[j - gap] > anchor:  # when j(5)>=5 & arr[5-5=0](11) > anchor(9), swap
+                arr[j] = arr[j - gap]                  # arr[5] = arr[0](11)
+                j -= gap                               # j=0 and while exists
+            arr[j] = anchor                            # at arr[0]= anchor(9)
+        gap = gap // 2  # now gap will be 2, so i=0,2,4,6,8 will be compared, starting with anchor(2)=7 and j=2
+        # first 0,2 will be compared then 0,2,6 then 0,2,6,8, @ gap=1 every element will be compared like Insertion sort
+
+
+if __name__ == '__main__':
+    arr = [11, 13, 7, 12, 16, 9, 24, 5, 10, 3]
+    sort(arr)
+    print(arr)

Algorithms/Swap.py

@@ -0,0 +1,21 @@
+# Using temporary location
+a = 1
+b = 2
+temp = a
+a = b
+b = temp
+print(a, " ", b)
+
+# Using XOR
+a = 3  # 0011
+b = 4  # 0100
+a = a ^ b
+b = a ^ b
+a = a ^ b
+print(a, " ", b)
+
+# Using Python's rotation of two function
+a = 5
+b = 6
+a, b = b, a
+print(a, " ", b)