Make Array code in accordance with PEP 8 style guide

Arrays/Arrays.py

@@ -1,53 +1,53 @@
 # Author: OMKAR PATHAK
 
 class Array(object):
-    ''' sizeOfArray: denotes the total size of the array to be initialized
-       arrayType: denotes the data type of the array(as all the elements of the array have same data type)
-       arrayItems: values at each position of array
+    ''' size_of_array: denotes the total size of the array to be initialized
+       array_type: denotes the data type of the array(as all the elements of the array have same data type)
+       array_items: values at each position of array
     '''
-    def __init__(self, sizeOfArray, arrayType = int):
-        self.sizeOfArray = len(list(map(arrayType, range(sizeOfArray))))
-        self.arrayItems =[arrayType(0)] * sizeOfArray    # initialize array with zeroes
-        self.arrayType = arrayType
+    def __init__(self, size_of_array, array_type = int):
+        self.size_of_array = len(list(map(array_type, range(size_of_array))))
+        self.array_items =[array_type(0)] * size_of_array    # initialize array with zeroes
+        self.array_type = array_type
 
     def __str__(self):
-        return ' '.join([str(i) for i in self.arrayItems])
+        return ' '.join([str(i) for i in self.array_items])
 
     def __len__(self):
-        return len(self.arrayItems)
+        return len(self.array_items)
 
     # magic methods to enable indexing
     def __setitem__(self, index, data):
-        self.arrayItems[index] = data
+        self.array_items[index] = data
 
     def __getitem__(self, index):
-        return self.arrayItems[index]
+        return self.array_items[index]
 
     # function for search
-    def search(self, keyToSearch):
-        for i in range(self.sizeOfArray):
-            if (self.arrayItems[i] == keyToSearch):      # brute-forcing
+    def search(self, key_to_search):
+        for i in range(self.size_of_array):
+            if (self.array_items[i] == key_to_search):      # brute-forcing
                 return i                                 # index at which element/ key was found
 
         return -1                                        # if key not found, return -1
 
     # function for inserting an element
-    def insert(self, keyToInsert, position):
-        if(self.sizeOfArray > position):
-            for i in range(self.sizeOfArray - 2, position - 1, -1):
-                self.arrayItems[i + 1] = self.arrayItems[i]
-            self.arrayItems[position] = keyToInsert
+    def insert(self, key_to_insert, position):
+        if(self.size_of_array > position):
+            for i in range(self.size_of_array - 2, position - 1, -1):
+                self.array_items[i + 1] = self.array_items[i]
+            self.array_items[position] = key_to_insert
         else:
-            print('Array size is:', self.sizeOfArray)
+            print('Array size is:', self.size_of_array)
 
     # function to delete an element
     def delete(self, keyToDelete, position):
-        if(self.sizeOfArray > position):
-            for i in range(position, self.sizeOfArray - 1):
-                self.arrayItems[i] = self.arrayItems[i + 1]
-            self.arrayItems[i + 1] = self.arrayType(0)
+        if(self.size_of_array > position):
+            for i in range(position, self.size_of_array - 1):
+                self.array_items[i] = self.array_items[i + 1]
+            self.array_items[i + 1] = self.array_type(0)
         else:
-            print('Array size is:', self.sizeOfArray)
+            print('Array size is:', self.size_of_array)
 
 if __name__ == '__main__':
     a = Array(10, int)

Arrays/P01_ReversingArray.py

@@ -2,17 +2,19 @@
 
 import Arrays
 
-def  reversingAnArray(start, end, myArray):
-    while(start < end):
-        myArray[start], myArray[end - 1] = myArray[end - 1], myArray[start]
+
+def reversing_an_array(start, end, my_array):
+    while (start < end):
+        my_array[start], my_array[end - 1] = my_array[end - 1], my_array[start]
         start += 1
         end -= 1
 
+
 if __name__ == '__main__':
-    myArray = Arrays.Array(10)
-    myArray.insert(2, 2)
-    myArray.insert(1, 3)
-    myArray.insert(3, 1)
-    print('Array before Reversing:',myArray)
-    reversingAnArray(0, len(myArray), myArray)
-    print('Array after Reversing:',myArray)
+    my_array = Arrays.Array(10)
+    my_array.insert(2, 2)
+    my_array.insert(1, 3)
+    my_array.insert(3, 1)
+    print('Array before Reversing:', my_array)
+    reversing_an_array(0, len(my_array), my_array)
+    print('Array after Reversing:', my_array)

Arrays/P02_ArrayRotation.py

@@ -2,22 +2,24 @@
 
 from Arrays import Array
 
-def rotation(rotateBy, myArray):
-    for i in range(0, rotateBy):
-        rotateOne(myArray)
-    return myArray
 
-def rotateOne(myArray):
-    for i in range(len(myArray) - 1):
-        myArray[i], myArray[i + 1] = myArray[i + 1], myArray[i]
+def rotation(rotate_by, my_array):
+    for i in range(0, rotate_by):
+        rotate_one(my_array)
+    return my_array
+
+
+def rotate_one(my_array):
+    for i in range(len(my_array) - 1):
+        my_array[i], my_array[i + 1] = my_array[i + 1], my_array[i]
 
 
 if __name__ == '__main__':
-    myArray = Array(10)
-    for i in range(len(myArray)):
-        myArray.insert(i, i)
-    print('Before Rotation:',myArray)
-    print('After Rotation:',rotation(3, myArray))
+    my_array = Array(10)
+    for i in range(len(my_array)):
+        my_array.insert(i, i)
+    print('Before Rotation:', my_array)
+    print('After Rotation:', rotation(3, my_array))
 
     # OUTPUT:
     # Before Rotation: 0 1 2 3 4 5 6 7 8 9

Arrays/P03_GetMissingNumber.py

@@ -2,21 +2,23 @@
 
 from Arrays import Array
 
-def findMissing(myArray, n):
+
+def find_missing(my_array, n):
     n = n - 1
-    totalSum = (n * (n + 1)) // 2
+    total_sum = (n * (n + 1)) // 2
     for i in range(0, n):
-        totalSum -= myArray[i]
+        total_sum -= my_array[i]
+
+    return total_sum
 
-    return totalSum
 
 if __name__ == '__main__':
-    myArray = Array(10)
-    for i in range(len(myArray)):
-        myArray.insert(i, i)
-    myArray.delete(4, 4)
-    print('Original Array:',myArray)
-    print('Missing Element:', findMissing(myArray, len(myArray)))
+    my_array = Array(10)
+    for i in range(len(my_array)):
+        my_array.insert(i, i)
+    my_array.delete(4, 4)
+    print('Original Array:', my_array)
+    print('Missing Element:', find_missing(my_array, len(my_array)))
 
     # OUTPUT:
     # Original Array: 0 1 2 3 5 6 7 8 9 0

Arrays/P04_OddNumberOfTimes.py

@@ -8,7 +8,7 @@
 
 # NOTE: This will only work when there is only one number with odd number of occurences.
 
-def printOddOccurences(array):
+def print_odd_occurences(array):
     odd = 0
 
     for element in array:
@@ -17,6 +17,7 @@ def printOddOccurences(array):
 
     return odd
 
+
 if __name__ == '__main__':
     myArray = [3, 4, 1, 2, 4, 1, 2, 5, 6, 4, 6, 5, 3]
-    print(printOddOccurences(myArray))      # 4
+    print(print_odd_occurences(myArray))  # 4

Arrays/P05_CheckForPairSum.py

@@ -1,27 +1,28 @@
 # Author: OMKAR PATHAK
 
 # Given an array A[] of n numbers and another number x, determines whether or not there exist two elements
-# in S whose sum is exactly x.
+# in S whose total is exactly x.
 
-def checkSum(array, sum):
+def check_sum(array, sum):
     # sort the array in ascending order
     # new changes : made use of Python's inbuilt Merge Sort method
     # Reason for such change : Worst case Time complexity of Quick Sort is O(n^2) whereas Worst Case Complexity of Merge Sort is O(nlog(n))
     array = sorted(array)
 
-    leftIndex = 0
-    rightIndex = len(array) - 1
+    left_index = 0
+    right_index = len(array) - 1
 
-    while leftIndex < rightIndex:
-        if (array[leftIndex] + array[rightIndex] ==  sum):
-            return array[leftIndex], array[rightIndex]
-        elif(array[leftIndex] + array[rightIndex] < sum):
-            leftIndex += 1
+    while left_index < right_index:
+        if (array[left_index] + array[right_index] == sum):
+            return array[left_index], array[right_index]
+        elif (array[left_index] + array[right_index] < sum):
+            left_index += 1
         else:
-            rightIndex += 1
+            right_index += 1
 
     return False, False
 
+
 ##def quickSort(array):
 ##    if len(array) <= 1:
 ##        return array
@@ -32,11 +33,11 @@ def checkSum(array, sum):
 ##    return quickSort(left) + middle + quickSort(right)
 
 if __name__ == '__main__':
-    myArray = [10, 20, 30, 40, 50]
-    sum = 80
+    my_array = [10, 20, 30, 40, 50]
+    total = 80
 
-    number1, number2 = checkSum(myArray, sum)
-    if(number1 and number2):
-        print('Array has elements:', number1, 'and', number2, 'with sum:', sum)
+    number1, number2 = check_sum(my_array, total)
+    if number1 and number2:
+        print('Array has elements:', number1, 'and', number2, 'with total:', total)
     else:
-        print('Array doesn\'t have elements with the sum:', sum)
+        print('Array doesn\'t have elements with the total:', total)