udemy course questions

Author: harishpuvvada

Graphs/Dijkstra.py

@@ -0,0 +1,37 @@
+'''
+
+Consider an array of non-negative integers. A second array is formed by shuffling the elements of the first array and deleting a random element. Given these two arrays, find which element is missing in the second array.
+
+Here is an example input, the first array is shuffled and the number 5 is removed to construct the second array.
+
+Input:
+
+finder([1,2,3,4,5,6,7],[3,7,2,1,4,6])
+Output:
+
+5 is the missing number
+
+'''
+
+
+def missingElement(arr1,arr2):
+
+    if len(arr1)==len(arr2):
+        return "Nothing is Missing"
+
+    arr1.sort()
+    arr2.sort()
+
+    for num1,num2 in zip(arr1,arr2):
+        if num1!=num2:
+            return num1
+
+
+    return arr1[-1]     #because zip wont form a tuple of last element which wont have a pair in arr2
+
+
+arr1 = [1,2,3,4,5,6,7]
+arr2 = [3,5,2,1,4,6]
+
+
+print(missingElement(arr1,arr2))

Lists/MissingElementFinder.py

@@ -0,0 +1,27 @@
+
+'''
+
+Given an array of integers (positive and negative) find the largest continuous sum.
+
+'''
+
+
+def large_cont_sum(arr):
+
+    if len(arr)==0:
+        return 0
+
+    max_sum = current_sum = arr[0]
+
+    for num in arr[1:]:
+
+        current_sum = max(current_sum + num, num)
+
+        max_sum = max(max_sum, current_sum)
+
+    return max_sum
+
+arr1 = [1,2,-1,3,4,10,10,-10,-1]
+
+
+print(large_cont_sum(arr1)) #29

Lists/largestContinuousSum.py

@@ -16,5 +16,5 @@ def isValid(self, s):
             elif char in dict.keys():
                 if (stack == [] or dict[char] != stack.pop()): #.pop spits out last element
                     return False
-            
+
         return stack == []

Misc/Valid Paranthesis - Leet Code.py

@@ -0,0 +1,50 @@
+def rev_word1(s):
+    return " ".join(reversed(s.split()))
+
+#Or
+
+def rev_word2(s):
+    return " ".join(s.split()[::-1])
+
+#or
+
+def rev_word3(s):
+    """
+    Manually doing the splits on the spaces.
+    """
+
+    words = []
+    length = len(s)
+    spaces = [' ']
+
+    # Index Tracker
+    i = 0
+
+    # While index is less than length of string
+    while i < length:
+
+        # If element isn't a space
+        if s[i] not in spaces:
+
+            # The word starts at this index
+            word_start = i
+
+            while i < length and s[i] not in spaces:
+
+                # Get index where word ends
+                i += 1
+            # Append that word to the list
+            words.append(s[word_start:i])
+        # Add to index
+        i += 1
+
+    # Join the reversed words
+    return " ".join(reversed(words))
+
+
+rev_word1('   Hello John    how are you   ')
+rev_word2('   Hello John    how are you   ')
+rev_word3('   Hello John    how are you   ')
+
+
+#ANS: 'you are how John Hello'

Strings/ReverseSentence.py

@@ -0,0 +1,34 @@
+'''
+Given a string in the form 'AAAABBBBCCCCCDDEEEE' compress it to become 'A4B4C5D2E4'. For this problem, you can falsely "compress" strings of single or double letters. For instance, it is okay for 'AAB' to return 'A2B1' even though this technically takes more space.
+
+The function should also be case sensitive, so that a string 'AAAaaa' returns 'A3a3'.
+'''
+
+def string_Comp(s):
+
+    l = len(s)
+
+    if l == 0:
+        return ""
+
+    if l == 1:
+        return s+"1"
+
+    dic = {}
+
+    for char in s:
+
+        if char in dic:
+            dic[char] +=1
+        else:
+            dic[char] = 1
+
+    final = ''
+
+    for key,value in dic.items():
+        final +=key+str(value)
+
+    return final
+
+
+print(string_Comp('AAAABaa'))

Strings/StringCompression.py

@@ -9,7 +9,7 @@
     1. Create a temp string and store concatenation of str1 to
        str1 in temp.
                           temp = str1.str1
-    2. If str2 is a substring of temp then str1 and str2 are 
+    2. If str2 is a substring of temp then str1 and str2 are
        rotations of each other.
 
     Example: