Alignment

Author: PTHARRISH

DSA/Array.py

@@ -1,12 +1,12 @@
 # Array:
-# An array is a type of linear data structure 
-# that is defined as a collection of elements with same or different data types. 
-# They exist in both single dimension and multiple dimensions. 
-# These data structures come into picture when there is a necessity 
+# An array is a type of linear data structure
+# that is defined as a collection of elements with same or different data types.
+# They exist in both single dimension and multiple dimensions.
+# These data structures come into picture when there is a necessity
 # to store multiple elements of similar nature together(data type) at one place.
 
-# The difference between an array index and a memory address 
-# array index acts like a key value to label the elements in the array. 
+# The difference between an array index and a memory address
+# array index acts like a key value to label the elements in the array.
 # a memory address is the starting address of free memory available.
 
 # Following are the important terms to understand the concept of Array.
@@ -15,20 +15,20 @@
 # Index − Each location of an element in an array has a numerical index, which is used to identify the element.
 
 # An array is a collection of items stored at contiguous memory locations.
-# The idea is to store multiple items of the same type together. 
-# This makes it easier to calculate the position of each element by simply adding an offset to a base value, 
+# The idea is to store multiple items of the same type together.
+# This makes it easier to calculate the position of each element by simply adding an offset to a base value,
 # i.e., the memory location of the first element of the array (generally denoted by the name of the array).
 
 # Creating an Array
-# Array in Python can be created by importing an array module. 
-# array(data_type, value_list) is used to create an array with data type and value list specified in its arguments. 
+# Array in Python can be created by importing an array module.
+# array(data_type, value_list) is used to create an array with data type and value list specified in its arguments.
 
 # There are thre ways to import array module:
 # Using import (import array)
 # Using import and call alias name (import array as arr)
 # from modules import all methods ( from array import * )
 
-# Some of the data types are mentioned below which will help in creating an array of different data types. 
+# Some of the data types are mentioned below which will help in creating an array of different data types.
 # i - signed Int - allow positive and negative values
 # I - unsigned Int - allow only positive values
 # d - double - allow double values
@@ -40,13 +40,13 @@
 
 from array import *
 
-a=array('i',[-1,2,3,4,5])
+a = array("i", [-1, 2, 3, 4, 5])
 
-print(a) # array('i', [1, 2, 3, 4, 5])
+print(a)  # array('i', [1, 2, 3, 4, 5])
 
-a=array('I',[1,2,3,4,5])
+a = array("I", [1, 2, 3, 4, 5])
 
-print(a) # array('I', [1, 2, 3, 4, 5])
+print(a)  # array('I', [1, 2, 3, 4, 5])
 
 # a=array('i',[1,2,3,4,5,'a'])
 
@@ -56,21 +56,21 @@
 
 # print(a) OverflowError: can't convert negative value to unsigned int
 
-a=array('u',['a','b','c'])
+a = array("u", ["a", "b", "c"])
 
-print(a) # array('u', 'abc')
+print(a)  # array('u', 'abc')
 
-a=array('b',[-1,2,3,3]) # array('b', [-1, 2, 3, 3])
+a = array("b", [-1, 2, 3, 3])  # array('b', [-1, 2, 3, 3])
 
-print(a) #TypeError: 'str' object cannot be interpreted as an integer
+print(a)  # TypeError: 'str' object cannot be interpreted as an integer
 
-a=array('f',[-1,2,3,3.0]) # array('f', [-1.0, 2.0, 3.0, 3.0])
+a = array("f", [-1, 2, 3, 3.0])  # array('f', [-1.0, 2.0, 3.0, 3.0])
 
-print(a) # convert int to float
+print(a)  # convert int to float
 
-a=array('d',[-1,2,3,3.00500050]) # array('d', [-1.0, 2.0, 3.0, 3.0050005])
+a = array("d", [-1, 2, 3, 3.00500050])  # array('d', [-1.0, 2.0, 3.0, 3.0050005])
 
-print(a) # convert int to double
+print(a)  # convert int to double
 
 # a=array('B',[-1,2,3])
 
@@ -84,40 +84,42 @@
 # Seaching  - Best O(1) got in first position, Average O(n-i) may got in middle ,Worst O(n) got at last postion
 
 
-print("------------------------------------------ Adding Element to a array ------------------------------------------")
+print(
+    "------------------------------------------ Adding Element to a array ------------------------------------------"
+)
 # Adding Elements to a Array
-# Elements can be added to the Array by using built-in insert() function. 
+# Elements can be added to the Array by using built-in insert() function.
 
 # Insert():
-# Insert is used to insert one or more data elements into an array. 
-# a new element can be added at the beginning, end, or any given index of array. 
+# Insert is used to insert one or more data elements into an array.
+# a new element can be added at the beginning, end, or any given index of array.
 
-# append(): 
-# append() is also used to add the value mentioned in its arguments at the end of the array. 
+# append():
+# append() is also used to add the value mentioned in its arguments at the end of the array.
 
 
 import array as arr
-a = arr.array('i', [1, 2, 3])
+
+a = arr.array("i", [1, 2, 3])
 print("Array before insertion : ", end=" ")
 for i in range(0, 3):
-	print(a[i], end=" ")
+    print(a[i], end=" ")
 print()
 
 a.insert(1, 4)
 print("Array after insertion : ", end=" ")
-for i in (a):
-	print(i, end=" ")
+for i in a:
+    print(i, end=" ")
 print()
 
-b = arr.array('d', [2.5, 3.2, 3.3])
+b = arr.array("d", [2.5, 3.2, 3.3])
 print("Array before insertion : ", end=" ")
 for i in range(0, 3):
-	print(b[i], end=" ")
+    print(b[i], end=" ")
 print()
 
 b.append(4.4)
 print("Array after insertion : ", end=" ")
-for i in (b):
-	print(i, end=" ")
+for i in b:
+    print(i, end=" ")
 print()
-

DSA/Arrays/array.py

@@ -0,0 +1,124 @@
+# Array
+# Arrays are not native data structures in Python.
+# Instead, we use list, which are similar but more flexible.
+
+# However, there are models available in Python
+# for creating more efficient arrays with a specific data
+# type, mainly for numeric data type.
+
+# We can use numpy module and array module to create an array data structure in Python.
+
+# They store elements as contiguous block of memory without pointers,
+# reducing memory overhead.
+
+# array objects can only store elements of same data type.
+
+# The simple examples of array data structures:
+# collections of books,
+# clothes in wardrobe or
+# pens in your pen stand.
+
+# Real world Examples of Array
+# box of macarons.
+
+# So this is very similar to the array data structure.
+
+# If you look at this box very carefully,
+# we can easily see what are the properties of this box.
+
+# First is it's a box of macarons which holds macarons in it.
+
+# This means that this box is produced for macarons.
+
+# You cannot store,
+# for example,
+
+# 1. this cream puff into this box because it's not going to fit in.
+
+# 2. The next property is that all macarons in this box are next to each other.
+
+# 3. There is no gap between them, which means that they are contiguous.
+
+# 4.And the next property is that each macaroon here can be identified
+# uniquely based on their location.
+
+# So this is the first macaroon.This is the second.This is the third.
+# And it continues like this.
+
+# So based on their location, we can identify them.
+
+# So these are the common properties of this box and can be seen very easily.
+
+# If you compare this box of macarons with the array data structure,
+# we can see that they are very similar.
+
+# So a typical array structure looks like this.
+
+# You can easily see that the appearance of the macarons box and
+# array data structure somehow looks each other.
+
+## properties of this array
+
+# The first property is an array can store data of specified type.
+
+# This means that when we create an array of integers,
+# we cannot store string values in the array.
+
+# As you see, in case of macaron box,
+# we cannot store any other suite which will not fit in this box.
+
+# So here the data type is macaroon. We cannot store this creampuff in this array.
+
+# The data type is integer, so we cannot store the string.
+
+# Now the next property is elements of array are located in a contiguous location in memory.
+
+# This means that the elements are located next to each other.
+
+# There is no gap between them, so they have to be located contiguously in the memory.
+
+# Now the next property is each element of array has a unique index.
+
+# For example, the index of ten over here is going to be two and the index of four is going to be zero.
+
+# And keep in mind that the first element's index starts from zero and increase sequentially.
+
+# So these are the main properties of the array data structure and we have compared it with the real life
+
+# example to understand it very well.
+
+# why do we need array data structure?
+
+# So consider a situation where we need to create three integer variables.
+# So if we create them, we can name them like this.
+
+# Number one, Number two, Number three.
+
+# Now, this is very simple because we have to store just three integer numbers.
+
+# Now let's assume we have to store 500 integer numbers.
+
+# Are we going to use 500 variables? Of course not.
+
+# To handle such situations, all programming languages provide a concept called array.
+
+# An array is a data structure which can store collection of elements of the same type.
+
+# So array is used to store a collection of data, but it is more often useful to think of array as a
+
+# collection of variables of the same type.
+
+# So instead of declaring individual 500 variables, we are just going to create an array and we are going
+
+# to access the elements of array as we need them.
+
+
+# What are arrays?
+# An array is a container which can hold a fix number of items
+# and these items should be of the same type.
+# Each item stored in an array is called an element
+# and they can be of any type including integers, floats, strings, etc.
+
+# These elements are stored at contiguous memory location.
+# Each location of an element in an array has a numerical index starting from 0.
+# These indices are used to identify and access the elements.

DSA/Sorting Algorithm/Linear_search.py renamed to DSA/Searching Algorithm/Linear_search.py

@@ -1,11 +1,11 @@
 # Insertion Sort:
-# Insertion sort is a very simple method to sort numbers in an ascending or descending order. 
-# This method follows the incremental method. 
+# Insertion sort is a very simple method to sort numbers in an ascending or descending order.
+# This method follows the incremental method.
 # It can be compared with the technique how cards are sorted at the time of playing a game.
-# This is an in-place comparison-based sorting algorithm. 
-# Here, a sub-list is maintained which is always sorted. 
-# For example, the lower part of an array is maintained to be sorted. 
-# An element which is to be 'inserted' in this sorted sub-list, has to find its appropriate place 
+# This is an in-place comparison-based sorting algorithm.
+# Here, a sub-list is maintained which is always sorted.
+# For example, the lower part of an array is maintained to be sorted.
+# An element which is to be 'inserted' in this sorted sub-list, has to find its appropriate place
 # and then it has to be inserted there. Hence the name, insertion sort.
 
 
@@ -22,23 +22,28 @@
 
 # code:
 def insertionSort(arr):
-	n = len(arr) # Get the length of the array
-	
-	if n <= 1:
-		return # If the array has 0 or 1 element, it is already sorted, so return
-
-	for i in range(1, n): # Iterate over the array starting from the second element
-		key = arr[i] # Store the current element as the key to be inserted in the right position
-		j = i-1
-		while j >= 0 and key < arr[j]: # Move elements greater than key one position ahead
-			arr[j+1] = arr[j] # Shift elements to the right
-			j -= 1
-		arr[j+1] = key # Insert the key in the correct position
+    n = len(arr)  # Get the length of the array
+
+    if n <= 1:
+        return  # If the array has 0 or 1 element, it is already sorted, so return
+
+    for i in range(1, n):  # Iterate over the array starting from the second element
+        key = arr[
+            i
+        ]  # Store the current element as the key to be inserted in the right position
+        j = i - 1
+        while (
+            j >= 0 and key < arr[j]
+        ):  # Move elements greater than key one position ahead
+            arr[j + 1] = arr[j]  # Shift elements to the right
+            j -= 1
+        arr[j + 1] = key  # Insert the key in the correct position
+
 
 # Sorting the array [12, 11, 13, 5, 6] using insertionSort
 arr = [12, 11, 13, 5, 6]
 insertionSort(arr)
 print(arr)
 
-# If the given numbers are sorted, this algorithm runs in O(n) time. 
-# If the given numbers are in reverse order, the algorithm runs in O(n2) time.
+# If the given numbers are sorted, this algorithm runs in O(n) time.
+# If the given numbers are in reverse order, the algorithm runs in O(n2) time.

DSA/Sorting Algorithm/insertion_sort.py

@@ -43,6 +43,29 @@
 # print(sorted_arr)
 
 
+def quick_sort(arr, low, high):
+    if low < high:
+        p = partition(arr, low, high)
+        quick_sort(arr, low, p)
+        quick_sort(arr, p + 1, high)
+
+
+def partition(arr, low, high):
+    pivot = arr[(low + high) // 2]
+    i = low - 1
+    j = high + 1
+    while True:
+        i += 1
+        while arr[i] < pivot:
+            i += 1
+        j -= 1
+        while arr[j] > pivot:
+            j -= 1
+        if i >= j:
+            return j
+        arr[i], arr[j] = arr[j], arr[i]
+
+
 def quick_sort(arr):
     if len(arr) <= 1:
         return arr

DSA/Sorting Algorithm/quick sort.py

@@ -0,0 +1 @@
+# Higher Order Function

Notes/3.Advance/2.Higher_Order_Function.py

@@ -1,6 +1,7 @@
 # Decorators in Python
-# Decorators are a very powerful and useful tool in Python 
-# since it allows programmers to modify the behaviour of a function or class. 
-# Decorators allow us to wrap another function in order to extend the behaviour of the wrapped function, 
+# Decorators are a very powerful and useful tool in Python
+# since it allows programmers to modify the behaviour of a function or class.
+# Decorators allow us to wrap another function in order
+# to extend the behaviour of the wrapped function,
 # without permanently modifying it.
 

Notes/3.Advance/4.Decorators.py

@@ -14,13 +14,14 @@
 
 # Allows Duplicate Members: A list can have two or more elements that are identical.
 
-# Heterogeneous: Lists can contain elements of different types, 
+# Heterogeneous: Lists can contain elements of different types,
 # although this is generally not recommended for most applications.
 print("-----------------------------------------------------------")
 
 
 # Creation of Lists object
-# You can create a list by enclosing its elements in square brackets [], separated by commas:
+# You can create a list by enclosing its elements in square brackets [],
+# separated by commas:
 
 # 1.
 my_list = []