adding all resources

Author: shushrutsharma

1. Resources/BigO-cheat-sheet.pdf

@@ -0,0 +1,24 @@
+#O(1) - Constant Time
+#The no. of operations do not depend on the size of the input and are always constant.
+import time
+
+array_small = ['nemo' for i in range(10)]
+array_medium = ['nemo' for i in range(100)]
+array_large = ['nemo' for i in range(10000)]
+
+def finding_nemo(array):
+    t0 = time.time()
+    for i in array:
+        pass
+    t1 = time.time()
+    print(f'Time taken = {t1-t0}')
+
+finding_nemo(array_small)
+finding_nemo(array_medium)
+finding_nemo(array_large)
+
+#Time taken in all 3 cases would be 0.0 seconds because we are only extracting the first and second elements of the arays.
+#We are not looping over the entire array.
+#We are performing two O(1) operations, which equal to O(2)
+#Any constant number can be considered as 1. There we can say this function is of O(1) - Constant Time Complexity.
+

1. Resources/Books/Data Structures - Reema Thareja.pdf

@@ -0,0 +1,33 @@
+import time
+
+large1 = ['nemo' for i in range(100000)]
+large2 = ['nemo' for i in range(100000)]
+
+def find_nemo(array1, array2):
+
+    #Here there are two different variables array1 and array2.
+    #They have to be represented by 2 different variables in the Big-O representation as well.
+    #Let array1 correspond to m and array2 correspond to n
+
+    t0 = time.time() #O(1)
+    for i in range(0,len(array1)): #O(m)
+        if array1[i] == 'nemo': #m*O(1)
+            print("Found Nemo!!") #k1*O(1) where k1 <= m because this statement will be executed only if the if statement returns True, which can be k1(<=m) times
+    t1 = time.time() #O(1)
+    print(f'The search took {t1-t0} seconds.') #O(1)
+
+    t0 = time.time() #O(1)
+    for i in range(0, len(array2)): #O(n)
+        if array2[i] == 'nemo': #n*O(1)
+            print("Found Nemo!!") #k2*O(1) where k2 <= m because this statement will be executed only if the if statement returns True, which can be k2(<=m) times
+    t1 = time.time() #O(1)
+    print(f'The search took {t1 - t0} seconds.') #O(1)
+
+find_nemo(large1, large2)
+
+#Total time complexity of the find_nemo function =
+#O(1 + m + m*1 + k1*1 + 1 + 1 + 1 + n + n*1 + k2*1 + 1 + 1) = O(6 + 2m + 2n + k1 + k2)
+#Now k1<=m and k2<=n. In the worst case, k1 can be m and k2 can be n. We'll consider the worst case and calculate the Big-O
+#O(6 + 2m + 2n + m + n) = O(3m + 3n + 6) = O(3(m + n + 2))
+#The constants can be safely ignored.
+#Therefore, O(m + n + 2) = O(m + n)

1. Resources/Books/Operating_System_Concepts,_8th_Edition[A4].pdf

@@ -0,0 +1,22 @@
+import time
+
+array1 = ['a','b','c','d','e']
+array2 = [1,2,3,4,5]
+
+def pairs(array1, array2):
+
+    # Here there are two different variables array1 and array2.
+    # They have to be represented by 2 different variables in the Big-O representation as well.
+    # Let array1 correspond to m and array2 correspond to n
+
+    for i in range(len(array1)): #n*O(m)
+        for j in range(len(array2)): #m*O(n)
+            print(array1[i],array2[j]) #m*n*O(1)
+
+pairs(array1,array2)
+
+#Total time complexity of the pairs function =
+#O(n*m + m*n + m*n*1) = O(3*m*n)
+#The constants can be safely ignored.
+#Therefore, O(m * n * 3) = O(m * n)
+

1. Resources/Books/competitiveCoding.pdf

@@ -0,0 +1,36 @@
+import time
+
+nemo = ['nemo']
+everyone = ['dory', 'bruce', 'marlin', 'nemo', 'gill', 'bloat', 'nigel', 'squirt', 'darla']
+large = ['nemo' for i in range(100000)]
+def find_nemo(array):
+    t0 = time.time()
+    for i in range(0,len(array)):
+        if array[i] == 'nemo':
+            print("Found Nemo!!")
+    t1 = time.time()
+    print(f'The search took {t1-t0} seconds.')
+find_nemo(nemo)
+find_nemo(everyone)
+find_nemo(large)
+
+
+def funchallenge(input):
+    temp = 10 #O(1)
+    temp = temp +50 #O(1)
+    for i in range(len(input)): #O(n)
+        var = True #n*O(1)
+        temp += 1 #n*O(1)
+    return temp #O(1)
+
+funchallenge(nemo)
+funchallenge(everyone)
+funchallenge(large)
+
+#Total running time of the funchallenge function =
+#O(1 + 1 + n + n*1 + n*1 + n*1 + 1) = O(3n +3) = O(3(n+1))
+#Any constant in the Big-O representation can be replaced by 1, as it doesn't really matter what constant it is.
+#Therefore, O(3(n+1)) becomes O(n+1)
+#Similarly, any constant number added or subtracted to n or multiplied or divided by n can also be safely written as just n
+#This is because the constant that operates upon n, doesn't depend on n, i.e., the input size
+#Therefore, the funchallenge function can be said to be of O(n) or Linear Time Complexity.

1. Resources/DAA Syllabus.pdf

@@ -0,0 +1,43 @@
+import time
+
+array = ['a','b','c','d','e']
+
+def log_all_pairs(array):
+
+    #There are nested for loops in this function but there is only one variable array. So we don't need two variables for the Big-O
+
+    for i in range(len(array)): #n*O(n)
+        for j in range(len(array)): #n*O(n)
+            print(array[i], array[j]) #n*n*O(1)
+
+log_all_pairs(array)
+
+#Total time complexity of the log_all_pairs function =
+#O(n*n + n*n + n*n*1) = O(3n^2)
+#The constants can be safely ignored.
+#Therefore, O(3n^2) = O(n^2)
+
+new_array = [1,2,3,4,5]
+def print_numbers_then_pairs(array):
+
+    #There are a total of three loops here but only one variable. So we need only variable for our Big-O notation
+
+    print("The numbers are : ") #O(1)
+    for i in range(len(array)): #O(n)
+        print(array[i]) #n*O(1)
+
+    print("The pairs are :") #O(1)
+    for i in range(len(array)): #n*O(n)
+        for j in range(len(array)): #n*O(n)
+            print(array[i],array[j]) #n*n*O(1)
+
+print_numbers_then_pairs(new_array)
+
+#Total time complexity of the print_numbers_then_pairs function =
+#O(1 + n + n*1 + 1 + n*n + n*n + n*n*1) = O(3n^2 + 2n + 2)
+#Now, Big-O presents scalability of the cod, i.e., how the code will behave as the inputs grow larger and larger
+#Therefore if the expression contains terms of different degrees and the size of inputs is huge, the terms of the smaller degrees become negligible in comparison to those of the higher degrees
+#Therefore, we can ignore the terms of the smaller degrees and only keep the highest degree term
+#O(3n^2 + 2n + 2) = O(3n2)
+#The constants can be safely ignored.
+#Therefore, O(3n^2) = O(n^2)

1. Resources/Interview cheatsheet.pdf

@@ -0,0 +1,58 @@
+#Given an array of integers, find if the array contains any duplicates.
+#Your function should return true if any value appears at least twice in the array, and it should return false if every element is distinct.
+#Example 1:
+#Input: [1,2,3,1]
+#Output: true
+#Example 2:
+#Input: [1,2,3,4]
+#Output: false
+
+#As usual we'll get the naive approach out of the way first.
+
+def brute_force_duplicate_search(array):
+    for i in range(len(array)-1):
+        for j in range(i+1,len(array)):
+            if array[i] == array[j]:
+                return True
+    return False
+
+array = [1,2,46,32,98,61,34,46]
+print(brute_force_duplicate_search(array))
+
+#This is pretty simple, as we go through every possible pair of elements to check if they are the same.
+#If we find a pair having the same elements we return True, else we return False
+#Time Complexity - O(n^2)
+
+#A slightly better solution can be :
+#First we sort the array using O(nlog n) built-in sort of Python.
+#Then we loop through the array once to check if any consecutive elements are same, which will be O(n).
+#So overall complexity will be O(nlog n)
+
+def better_duplicate_search(array):
+    array.sort()
+    for i in range(len(array)-1):
+        if array[i] == array[i+1]:
+            return True
+    return False
+
+print(better_duplicate_search(array))
+
+#An even better solution can be using a dictionary.
+#As we loop through the array, we'll check first if the current element is present in the dictionary
+#If yes, we return True
+#If no, we add the element to the dictionary.
+#Since looking up in a dictionary is O(1) time, overall complexity would be O(n)
+
+def smart_duplicate_search(array):
+    dictionary = dict()
+    if len(array)<2:
+        return False
+    else:
+        for i in range(len(array)):
+            if array[i] in dictionary:
+                return True
+            else:
+                dictionary[array[i]] = True
+    return False
+
+print(smart_duplicate_search(array))

1. Resources/Master Plan.pdf

@@ -0,0 +1,77 @@
+#Although arrays are pre-defined in Python in the form of lists, we can implement our own arrays.
+#Here, we will implement our own array with some common methods such as access, push, pop, insert, delete
+
+class my_array():
+    def __init__(self):
+        self.length = 0 #We initialize the array's length to be zero
+        self.data = {} #We initialize the data of the array using an empty dictionary. The keys will correspond to the index and the values to the data
+
+    #The attributes of the array class are stored in a dictionary by default.
+    #When the __dict__ method is called on an instance of the class it returns the attributes of the class along with their values in a dictionary format
+    #Now, when the instance of the class is printed, it returns a class object with its location in memory.
+    #But we know when we print the array we get the elements of the array as output
+    #When we print the instance of the class, the built-in __str__ method is called. So we can modify the __str__ method inside the class
+    #To suit our needs.
+    def __str__(self):
+        print(self.data.values())
+        return str(self.__dict__) #This will print the attributes of the array class(length and data) in string format when print(array_instance) is executed
+
+    def get(self, index):
+        return self.data[index] #This method takes in the index of the element as a parameter and returns the corresponding element in O(1) time.
+
+    def push(self, item):
+        self.length += 1
+        self.data[self.length - 1] = item #Adds the item provided to the end of the array
+
+    def pop(self):
+        last_item = self.data[self.length-1] #Collects the last element
+        del self.data[self.length - 1] #Deletes the last element from the array
+        self.length -= 1 #Decrements the length attribute of the array by 1
+        return last_item #Returns the popped element. O(1) time
+
+    def insert(self, index, item):
+        self.length += 1
+        for i in range(self.length-1, index, -1):
+            self.data[i] = self.data[i-1] #Shifts every element from the index to the end by one place towards right. Thus making space at the specified index
+        self.data[index] = item #Adds the element at the given index. O(n) operation
+
+
+    def delete(self,index):
+        for i in range(index, self.length-1):
+            self.data[i] = self.data[i+1] #Shifts elements from the given index to the end by one place towards left
+        del self.data[self.length - 1] #The last element which remains two times in the array is deleted
+        self.length -= 1 #The lenght is decremented by 1. O(n) operation
+
+
+
+arr = my_array()
+print(arr)
+print("-"*100)
+arr.push(6)
+#{'length': 1, 'data': {0: 6}}
+
+arr.push(2)
+#{'length': 2, 'data': {0: 6, 1: 2}}
+
+arr.push(9)
+#{'length': 3, 'data': {0: 6, 1: 2, 2: 9}}
+
+arr.pop()
+#{'length': 2, 'data': {0: 6, 1: 2}}
+
+arr.push(45)
+arr.push(12)
+arr.push(67)
+#{'length': 5, 'data': {0: 6, 1: 2, 2: 45, 3: 12, 4: 67}}
+
+arr.insert(3,10)
+#{'length': 6, 'data': {0: 6, 1: 2, 2: 45, 3: 10, 4: 12, 5: 67}}
+
+arr.delete(4)
+#{'length': 5, 'data': {0: 6, 1: 2, 2: 45, 3: 10, 4: 67}}
+
+print(arr.get(1))
+#2
+
+print(arr)
+#The outputs given after each function call are the outputs obtained by calling print(arr) and not by the function calls themselves

1. Resources/Master_the_Interview.pdf

@@ -0,0 +1,76 @@
+#Arrays are one of the most commonly-used data structures
+#The elements of an array are stored in contiguous memory locations
+#Arrays are of two types : Static and Dynamic
+#Static arrays have fixed, pre-defined amount of memory that they can use, whereas in dynamic arrays this is flexible
+#In Python we only have dynamic arrays
+#Some basic operations and their complexities are given below :
+
+#Look-up/Accses - O(1)
+#Push/Pop - O(1)*
+#Insert - O(n)
+#Delete - O(n)
+
+array = [5,8,2,9,17,43,25,10]
+
+#Look-up/Acces
+#Any element of an array can be accessed by its index.
+#We just need to ask for the particular index of the element we are interested in and we will get the element in constant time
+first_element = array[0]  #This will return the first element of the array, in this case, 5, in O(1) time
+sixth_element = array[5]  #sixth-element = 43 Again, in O(1) time
+
+
+#Push/Pop
+#Push corresponds to pushing or adding an element at the end of the array.
+#Similarly, pop corresponds to removing the element at the end of the array.
+#Since the index of the end of the array is known, finding it and pushing or popping an element will only require O(1) time
+array.append(87) #Adds 87 at the end of the array in O(1) time
+
+#In some special cases, the append(push) operation may take greater time. This is because as mentioned earlier, Python has dynamic arrays
+#So when an element is to appended and the array is filled, the entire array has to be copied to a new location
+#With more space allocated(generally double the space) this time so that more items can be appended.
+#Therefore, some individual operations may reuire O(n) time or greater, but when averaged over a large number of operations,
+#The complexity can be safely considered to be O(1)
+
+array.pop() #Pops/removes the element at the end of the array in O(1) time.
+
+print(array)
+
+
+#Insert
+#Insert operation inserts an element at the beginning of the array, or at any location specified.
+#This is O(n) operation since after inserting the element at the desired location,
+#The elements to the right of the array have to be updated with the correct index as they all have shifted by one place.
+#This requires looping through the array. Hence, O(n) time.
+array.insert(0,50) #Inserts 50 at the beginning of the array and shifts all other elements one place towards right. O(n)
+array.insert(4,0) #inserts '0' at index '4', thus shifting all elements starting from index 4 one place towards right. O(n)
+
+print(array)
+
+
+#Delete
+#Similar to insert, it deletes an element from the specified location in O(n) time
+#The elements to the right of the deleted element have to shifted one space left, which requires looping over the entire array
+#Hence, O(n) time complexity
+array.pop(0) #This pops the first element of the array, shifting the remaining elements of the array one place left. O(n)
+print(array)
+array.remove(17) #This command removes the first occurence of the element 17 in the array, for which it needs to traverse the entire array, which requires O(n) time
+print(array)
+del array[2:4] #This command deletes elements from position 2 to position 4, again, in O(n) time
+print(array)
+
+array.insert(11, 'shushrut')
+print(array)
+print("-"*100)
+
+l = [5,8,2,9,17,43,25,10]
+print(len)
+l.insert(9, "shushrut")
+len = len(l)
+print(len)
+
+
+a = 15
+b = 15
+c = 300
+d = 300
+print(a is b, c is d)