solved issue jainaman224#400 (jainaman224#401)

* issue solved jainaman224#400

* solving issue#400

* solving jainaman224#400

* solved issue jainaman224#400

* issue solved jainaman224#400

Author: Aniket965

Binary_Search/Binary_Search.py

@@ -1,28 +1,28 @@
 # Function for Binary Search
-def Binary_Search(array, desired):
+def Binary_Search(list, desired):
     left = 0
-    right = len(array) - 1
+    right = len(list) - 1
 
     while left <= right:
         # Return positon if found
         middle = left + int((right - left) / 2)
 
-        if array[middle] == desired:
+        if list[middle] == desired:
             return middle
-        elif desired < array[middle]:
+        elif desired < list[middle]:
             right = middle - 1
-        elif desired > array[middle]:
+        elif desired > list[middle]:
             left = middle + 1
 
     return -1
 
-array = [1, 2, 3, 4, 5, 6, 7]
+list = [1, 2, 3, 4, 5, 6, 7]
 
 # Element to be searched is 4
-print ("Found") if Binary_Search(array, 4) != -1 else ("Not Found")
+print ("Found") if Binary_Search(list, 4) != -1 else ("Not Found")
 
 # Element to be searched is 9
-print ("Found") if Binary_Search(array, 9) != -1 else ("Not Found")
+print ("Found") if Binary_Search(list, 9) != -1 else ("Not Found")
 
 
 ''' Output

Bubble_Sort/Bubble_Sort.py

@@ -1,23 +1,23 @@
 # function for bubble sort
-def Bubble_Sort(array):
-    for i in range(0, len(array) - 1):
-        for j in range(0, len(array) - i - 1):
+def Bubble_Sort(list):
+    for i in range(0, len(list) - 1):
+        for j in range(0, len(list) - i - 1):
             # do swapping
-            if array[j] > array[j + 1]:
-                array[j], array[j + 1] = array[j + 1], array[j]
+            if list[j] > list[j + 1]:
+                list[j], list[j + 1] = list[j + 1], list[j]
 
-# function to print array
-def Print_Array(array):
-    for i in range(0, len(array)):
-        print(array[i], end = " ")
+# function to print list
+def Print_list(list):
+    for i in range(0, len(list)):
+        print(list[i], end = " ")
 
     print()
 
-array = [2, 4, 3, 1, 6, 8, 4]
+list = [2, 4, 3, 1, 6, 8, 4]
 
-Bubble_Sort(array)
+Bubble_Sort(list)
 
-Print_Array(array)
+Print_list(list)
 
 # Output
 # 1 2 3 4 4 6 8

Counting_Sort/Counting_Sort.py

@@ -11,17 +11,17 @@ def counting_sort(input):
 
     k = max - min + 1
 
-    count_array = [0] * k
+    count_list = [0] * k
 
     for i in range(0, len(input)):
-        count_array[input[i] - min] += 1
+        count_list[input[i] - min] += 1
 
     for i in range(1, k):
-        count_array[i] += count_array[i - 1]
+        count_list[i] += count_list[i - 1]
 
     for i in range(0, len(input)):
-        output[count_array[input[i] - min] - 1] = input[i]
-        count_array[input[i] - min] -= 1
+        output[count_list[input[i] - min] - 1] = input[i]
+        count_list[input[i] - min] -= 1
 
     for i in range(0, len(input)):
         input[i] = output[i]
@@ -31,13 +31,13 @@ def counting_sort(input):
 
 counting_sort(input)
 
-print("Sorted array :", end = " ")
+print("Sorted list :", end = " ")
 for i in range(0, len(input)):
     print(input[i], end = " ")
 
 
 ''' Output
 
-Sorted Array : 1  1  2  3  4  4  5  5  7
+Sorted list : 1  1  2  3  4  4  5  5  7
 
 '''

Heap_Sort/Heap_Sort.py

@@ -1,42 +1,42 @@
-def Heapify(array, root, size):
+def Heapify(list, root, size):
     left = 2 * root + 1
     right = left + 1
-    if left < size and array[left] > array[root]:
+    if left < size and list[left] > list[root]:
         largest = left
     else:
         largest = root
 
-    if right < size and array[right] > array[largest]:
+    if right < size and list[right] > list[largest]:
         largest = right
 
     if largest != root:
-        array[root], array[largest] = array[largest], array[root]
-        Heapify(array, largest, size)
+        list[root], list[largest] = list[largest], list[root]
+        Heapify(list, largest, size)
 
 
-def Build_Heap(array):
-    for i in range(int((len(array) - 1) / 2), -1, -1):
-        Heapify(array, i, len(array))
+def Build_Heap(list):
+    for i in range(int((len(list) - 1) / 2), -1, -1):
+        Heapify(list, i, len(list))
 
-def Heap_Sort(array):
-    Build_Heap(array)
+def Heap_Sort(list):
+    Build_Heap(list)
 
-    for i in range(len(array) - 1, 0, -1):
-        array[0], array[i] = array[i], array[0]
-        Heapify(array, 0, i)
+    for i in range(len(list) - 1, 0, -1):
+        list[0], list[i] = list[i], list[0]
+        Heapify(list, 0, i)
 
-# function to print array
-def Print_Array(array):
-    for i in range(0, len(array)):
-        print(array[i],end=" ")
+# function to print list
+def Print_list(list):
+    for i in range(0, len(list)):
+        print(list[i],end=" ")
 
     print()
 
-array = [2, 4, 3, 1, 6, 8, 4]
+list = [2, 4, 3, 1, 6, 8, 4]
 
-Heap_Sort(array)
+Heap_Sort(list)
 
-Print_Array(array)
+Print_list(list)
 
 # Output
 # 1 2 3 4 4 6 8

Insertion_Sort/Insertion_Sort.py

@@ -1,27 +1,27 @@
 # function for insertion sort
-def Insertion_Sort(array):
-    for i in range(1, len(array)):
-        temp = array[i]
+def Insertion_Sort(list):
+    for i in range(1, len(list)):
+        temp = list[i]
         j = i - 1
 
-        while j >= 0 and array[j] > temp:
-            array[j + 1] = array[j]
+        while j >= 0 and list[j] > temp:
+            list[j + 1] = list[j]
             j -= 1
 
-        array[j + 1] = temp
+        list[j + 1] = temp
 
-# function to print array
-def Print_Array(array):
-    for i in range(0, len(array)):
-        print(array[i],end=" ")
+# function to print list
+def Print_list(list):
+    for i in range(0, len(list)):
+        print(list[i],end=" ")
 
     print()
 
-array = [2, 4, 3, 1, 6, 8, 4]
+list = [2, 4, 3, 1, 6, 8, 4]
 
-Insertion_Sort(array)
+Insertion_Sort(list)
 
-Print_Array(array)
+Print_list(list)
 
 # Output
 # 1 2 3 4 4 6 8

Interpolation_Search/Interpolation_Search.py

@@ -1,25 +1,25 @@
-def interpolation(array, search_item):
-    high = len(array) - 1
+def interpolation(list, search_item):
+    high = len(list) - 1
     low = 0
 
-    while low <= high and search_item >= array[low] and search_item <= array[high]:
+    while low <= high and search_item >= list[low] and search_item <= list[high]:
         rise = high - low
-        run = array[high] - array[low]
-        x = search_item - array[low]
+        run = list[high] - list[low]
+        x = search_item - list[low]
         pos = low + int(rise / run) * x;
 
-        if array[pos] == search_item:
+        if list[pos] == search_item:
             return pos
-        elif search_item < array[pos]:
+        elif search_item < list[pos]:
             high = pos - 1
         else:
             low = pos + 1
 
     return -1
 
-array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
 search_item = 8
-index = interpolation(array, search_item)
+index = interpolation(list, search_item)
 
 if index == -1:
     print("Element not found")

Kadane_Algorithm/Kadane_Algorithm.py

@@ -25,15 +25,15 @@ def kadane(input):
         largest_in_negative = input[i]
 
 if flag == 1:
-    max_subarray_sum = kadane(input)
+    max_sublist_sum = kadane(input)
 else:
-    max_subarray_sum = largest_in_negative
+    max_sublist_sum = largest_in_negative
 
-print("Maximum Subarray Sum is " + str(max_subarray_sum))
+print("Maximum Sublist Sum is " + str(max_sublist_sum))
 
 
 ''' Output
 
-Maximum Subarray Sum is 6
+Maximum Sublist Sum is 6
 
 '''

Linear_Search/Linear_Search.py

@@ -1,22 +1,22 @@
 # Function for Linear Search
-def Linear_Search(array, desired):
-    for i in range(0, len(array)):
+def Linear_Search(list, desired):
+    for i in range(0, len(list)):
         # return positon if found
-        if(array[i] == desired):
+        if(list[i] == desired):
             return i
 
     return -1
 
-array = [2, 4, 6, 7, 3, 1, 5]
+list = [2, 4, 6, 7, 3, 1, 5]
 
 # Element to be searched is 4
-if(Linear_Search(array,4) != -1):
+if(Linear_Search(list,4) != -1):
     print("Found")
 else:
     print("Not Found")
 
 # Element to be searched is 9
-if(Linear_Search(array,9) != -1):
+if(Linear_Search(list,9) != -1):
     print("Found")
 else:
     print("Not Found")

Merge_Sort/Merge_Sort.py

@@ -1,63 +1,63 @@
 # Conquer
-def conquer_merge(array, left, right, mid):
-    #temp = [None] * len(array)
+def conquer_merge(list, left, right, mid):
+    #temp = [None] * len(list)
     i = left
     j = mid + 1
     k = left
 
     while i <= mid and j <= right:
-        if array[i] <= array[j]:
-            temp[k] = array[i]
+        if list[i] <= list[j]:
+            temp[k] = list[i]
             i += 1
         else:
-            temp[k] = array[j]
+            temp[k] = list[j]
             j += 1
 
         k += 1
 
     while i <= mid:
-        temp[k] = array[i]
+        temp[k] = list[i]
         i += 1
         k += 1
 
     while j <= right:
-        temp[k] = array[j]
+        temp[k] = list[j]
         j += 1
         k += 1
 
     while left <= right:
-        array[left] = temp[left]
+        list[left] = temp[left]
         left += 1
 
-# Divide array into halves
-def divide(array, left, right):
+# Divide list into halves
+def divide(list, left, right):
     if left < right:
         mid = left + (right - left) / 2;
         mid = int(mid)
 
-        divide(array, left, mid)
-        divide(array, mid + 1, right)
+        divide(list, left, mid)
+        divide(list, mid + 1, right)
 
-        conquer_merge(array, left, right, mid)
+        conquer_merge(list, left, right, mid)
 
-def Merge_Sort(array):
+def Merge_Sort(list):
     global temp
-    temp = [0] * len(array)
-    divide(array, 0, len(array) - 1)
+    temp = [0] * len(list)
+    divide(list, 0, len(list) - 1)
     del temp
 
-# function to print array
-def Print_Array(array):
-    for i in range(0, len(array)):
-        print(array[i],end=" ")
+# function to print list
+def Print_list(list):
+    for i in range(0, len(list)):
+        print(list[i],end=" ")
 
     print()
 
-array = [2, 4, 3, 1, 6, 8, 4]
+list = [2, 4, 3, 1, 6, 8, 4]
 
-Merge_Sort(array)
+Merge_Sort(list)
 
-Print_Array(array)
+Print_list(list)
 
 # Output
 # 1 2 3 4 4 6 8