18/06/21

Author: OliverIgnetik

Arrays/Anagrams.py

@@ -1,18 +1,10 @@
 from nose.tools import assert_equal
 
 ################ Problem Definition #####################################
-
-# Given an integer array, output all the **unique** pairs that sum up to a specific value **k**.
-
-# So the input:
-
-#     pair_sum([1,3,2,2],4)
-
-# would return **2** pairs:
-
-#      (1,3)
-#      (2,2)
-
+"""
+Given two strings find if they are anagrams, that is contain the same letters 
+but in different order.
+"""
 ################ Solution #####################################
 
 
@@ -74,6 +66,6 @@ def test(self, sol):
 print(anagram('clint eastwood', 'old west action'))
 
 # Run Tests
-# t = AnagramTest()
-# t.test(anagram)
-# t.test(anagram2)
+t = AnagramTest()
+t.test(anagram)
+t.test(anagram2)

Arrays/Reversing a string.py

@@ -1,6 +1,6 @@
 def reverse(stri):
     mylist = []
-    for i in range(len(stri)-1, -1, -1):
+    for i in range(len(stri) - 1, -1, -1):
         mylist.append(stri[i])
     return ''.join(mylist)
 

Arrays/Sentence_reversal.py

@@ -1,25 +1,25 @@
 from nose.tools import assert_equal
 
 ################ Problem Definition #####################################
+"""
+Given a string of words, reverse all the words. For example:
 
-# Given a string of words, reverse all the words. For example:
+Given:
 
-# Given:
+    'This is the best'
 
-#     'This is the best'
+Return:
 
-# Return:
+    'best the is This'
 
-#     'best the is This'
+As part of this exercise you should remove all leading and trailing whitespace. So that inputs such as:
 
-# As part of this exercise you should remove all leading and trailing whitespace. So that inputs such as:
+    '  space here'  and 'space here      '
 
-#     '  space here'  and 'space here      '
-
-# both become:
-
-#     'here space'
+both become:
 
+    'here space'
+"""
 ################################# Solution ##############################
 
 

Arrays/String_compression.py

@@ -1,8 +1,12 @@
 ##################### Problem ######################
 
-# 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.
+"""
+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'.
+The function should also be case sensitive, so that a string 'AAAaaa' returns 'A3a3'.
+"""
 
 ##################### Solution #####################
 

Arrays/first_unique_char.py

@@ -0,0 +1,17 @@
+def first_unique_chars(myStr):
+    chars = {}
+    for i, x in enumerate(myStr):
+        if x not in chars:
+            chars[x] = i
+        else:
+            chars[x] = -1
+
+    for x in chars:
+        if x != -1:
+            return chars[x]
+
+    return -1
+
+
+myStr = 'helleo'
+print(first_unique_chars(myStr))

Arrays/kth_largest_element.py

@@ -0,0 +1,116 @@
+from queue import PriorityQueue
+
+# O(NlogN)
+
+
+def simple_method(arr, k):
+    arr.sort()
+    return arr[len(arr) - k]
+
+
+"""
+O(N*logK) Approach with heap
+
+We throw away items that items smaller then
+the kth largest item. So that we grab the smallest item
+left in the heap is the second largest item.
+"""
+
+
+def heap_approach(arr, k):
+    q = PriorityQueue()
+    for num in arr:
+        q.put(num)
+        if q.qsize() > k:
+            q.get()
+
+    return q.get()
+
+
+"""
+O(N) Approach using partitions 
+Think of BUD (Bottlenecks, Unnecessary work, Duplicate work)
+
+We can do a partition and eliminate half of the search space (on average)self.
+It works on the fact that in a sorted array:
+
+- The kth largest item must be at index n-k
+- Generally speaking if we do a partition then if we know the
+kth largest item should be at an index greater then the index of pivot
+then we should focus our search on the items with greater indices (or to the right)
+"""
+
+
+import math
+import random
+
+
+def kthLargest(arr, k):
+    '''
+    :type arr: list of int
+    :type k: int
+    :rtype: int
+    '''
+    n = len(arr)
+    left = 0
+    right = n - 1
+
+    while left <= right:
+        # Random pivot index will ensure on average we avoid
+        # O(N^2) runtime
+        choosen_pivot_index = random.randint(left, right)
+
+        final_index_of_choosen_pivot = partition(
+            arr, left, right, choosen_pivot_index)
+
+        # What does the 'finalIndexOfChoosenPivot' tell us?
+        if (final_index_of_choosen_pivot == n - k):
+
+            # If the pivot index in the (n-k)th index then we are done and can stop here
+            return arr[final_index_of_choosen_pivot]
+        elif (final_index_of_choosen_pivot > n - k):
+            # k'th largest must be in the left partition.
+            right = final_index_of_choosen_pivot - 1
+        else:
+            # finalIndexOfChoosenPivot < n - k
+
+            # k'th largest must be in the right partition.
+
+            left = final_index_of_choosen_pivot + 1
+
+    return -1
+
+
+def partition(self, arr, left, right, pivot_index):
+    pivot_value = arr[pivot_index]
+    lesser_items_tail_index = left
+
+    # Move the item at the 'pivotIndex' OUT OF THE WAY. We are about to bulldoze
+    # through the partitioning space and we don't want it in the way
+    swap(arr, pivot_index, right)
+
+    for i in range(left, right):
+        if arr[i] < pivot_value:
+            swap(arr, i, lesser_items_tail_index)
+            lesser_items_tail_index += 1
+
+    # Ok...partitioning is done. Swap the pivot item BACK into the space we just
+    # partitioned at the 'lesserItemsTailIndex'...that's where the pivot item
+    # belongs
+
+    # In the middle of the "sandwich".
+
+    swap(arr, right, lesser_items_tail_index)
+
+    return lesser_items_tail_index
+
+
+def swap(self, arr, first, second):
+    temp = arr[first]
+    arr[first] = arr[second]
+    arr[second] = temp
+
+
+arr = [8, 1, 3, 2, 6, 7]
+
+print(heap_approach(arr, 2))

Arrays/largest_continuous_sum.py

@@ -1,7 +1,9 @@
 from nose.tools import assert_equal
 
 ################ Problem Definition ###########################
-# Given an array of integers (positive and negative) find the largest continuous sum.
+"""
+Given an array of integers (positive and negative) find the largest continuous sum.
+"""
 
 ################ Solution #####################################
 

Arrays/largest_subarray.py

@@ -0,0 +1,43 @@
+# O(N^2)
+def quadratic_approach(arr):
+    maxSum = -float('inf')
+    maxSub = []
+    for left in range(len(arr)):
+        runningWindowSum = 0
+        runningSubArray = []
+
+        for right in range(left, len(arr)):
+            runningWindowSum += arr[right]
+            runningSubArray.append(arr[right])
+            if (runningWindowSum > maxSum):
+                maxSum = runningWindowSum
+                maxSub = runningSubArray[:]
+
+    return [maxSum, maxSub]
+
+
+# O(N)
+def kadane_algorithm(arr):
+    runningSum = arr[0]
+    maxSum = arr[0]
+    maxSub = []
+    runningSub = []
+
+    for i in range(1, len(arr)):
+        if (runningSum < arr[i]):
+            runningSum = arr[i]
+            runningSub = [arr[i]]
+        else:
+            runningSum += arr[i]
+            runningSub.append(arr[i])
+
+        if runningSum > maxSum:
+            maxSum = runningSum
+            maxSub = runningSub[:]
+
+    return [maxSum, maxSub]
+
+
+arr = [-2, 1, -3, 4, -1, 2, 1, -5, 4]
+
+print(kadane_algorithm(arr))

Arrays/missing_item.py

@@ -3,19 +3,23 @@
 import collections
 
 ################ Problem Definition ###########################
+"""
+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.
 
-# 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.
 
-# Here is an example input, the first array is shuffled and the number 5 is removed to construct the second array.
+Input:
 
-# Input:
+    finder([1,2,3,4,5,6,7],[3,7,2,1,4,6])
 
-#     finder([1,2,3,4,5,6,7],[3,7,2,1,4,6])
+Output:
 
-# Output:
-
-#     5 is the missing number
+    5 is the missing number
 
+"""
 ################ Solution #####################################
 
 # naive solution
@@ -68,7 +72,7 @@ def finder3(arr1, arr2):
 
     # Perform an XOR between the numbers in the arrays
     # XOR is good for pairs
-    for num in arr1+arr2:  # O(N) time complexity
+    for num in arr1 + arr2:  # O(N) time complexity
         result ^= num
 
     return result

Dynamic Programming/knapsack.py

@@ -0,0 +1,45 @@
+"""
+A naive recursive implementation
+of 0-1 Knapsack Problem
+
+Returns the maximum value that
+can be put in a knapsack of
+capacity W
+
+References
+- https://www.geeksforgeeks.org/0-1-knapsack-problem-dp-10/
+- https://www.youtube.com/watch?v=qOUsP4eoYls&list=PLyEvk8ZeQDMVbsg7CEfT0NV3s3GkMx1vN&index=10
+"""
+
+
+def knapSack(W, wt, val, n):
+
+    # Base Case
+    if n == 0 or W == 0:
+        return 0
+
+    # If weight of the nth item is
+    # more than Knapsack of capacity W,
+    # then this item cannot be included
+    # in the optimal solution
+    if (wt[n - 1] > W):
+        return knapSack(W, wt, val, n - 1)
+
+    # return the maximum of two cases:
+    # (1) nth item included
+    # (2) not included
+    else:
+        return max(
+            val[n - 1] + knapSack(
+                W - wt[n - 1], wt, val, n - 1),
+            knapSack(W, wt, val, n - 1))
+
+# end of function knapSack
+
+
+# Driver Code
+val = [60, 100, 120]
+wt = [10, 20, 30]
+W = 50
+n = len(val)
+print(knapSack(W, wt, val, n))

Hashtables/First Recurring Character.py

@@ -2,14 +2,13 @@
 def func(mylist):
 
     for i in range(0, len(mylist)):
-        for j in range(i+1, len(mylist)):
+        for j in range(i + 1, len(mylist)):
             if mylist[i] == mylist[j]:
                 return mylist[i]
     return 0
 
-# O(N) time complexity
-
 
+# O(N) time complexity
 def hashtable(mylist):
     mydict = {}
     for i in range(0, len(mylist)):