Initial commit

Author: raghunandepu

.DS_Store

@@ -0,0 +1,37 @@
+"""
+Problem:
+This problem was recently asked by Google.
+
+Given a list of numbers and a number k, return whether any two numbers from the list add up to k.
+For example, given [10, 15, 3, 7] and k of 17, return true since 10 + 7 is 17.
+Bonus: Can you do this in one pass?
+
+"""
+
+# Solution 1
+"""
+def findPairs(arr, sum):
+  # Traverses through list twice to compare one element with the rest and find the sum
+  for i in range(0, len(arr)):
+    for j in range(0, len(arr)):
+      if sum == arr[i] + arr[j]:
+        return True
+  return False
+"""
+
+# Solution 2
+
+def findPairs(arr, sum):
+  
+  #Traverse through the list
+  for i in range(0, len(arr)):
+    if sum-i in arr:
+      return True
+  return False
+
+
+# Test
+A = [10, 15, 3, 7]
+print (findPairs(A, 17))
+
+

001_find_pairs.py

@@ -0,0 +1,63 @@
+"""
+This problem was asked by Uber.
+ 
+Given an array of integers, return a new array such that each element at index i of the new array is the product of
+all the numbers in the original array except the one at i.
+For example, if our input was [1, 2, 3, 4, 5], the expected output would be [120, 60, 40, 30, 24]. 
+If our input was [3, 2, 1], the expected output would be [2, 3, 6].
+Follow-up: what if you can't use division?
+"""
+
+# Solution
+# Reference: https://www.interviewcake.com/question/python3/product-of-other-numbers 
+"""
+The product of all the integers except the integer at each index can be broken down into two pieces:
+
+the product of all the integers before each index and
+the product of all the integers after each index.
+"""
+
+def get_array_product_except_index(arr):
+  if len(arr) < 2:
+     raise IndexError('To get the product, we need atlest 2 elements in the list')
+   
+   # We make a list with length of input to hold the products
+  products_expect_index = [None] * len(arr)
+   
+  # For each integer, we find the product of all the integers
+  # before it (left half) and store the total product so far 
+  # setting it 1 as there are no elements before first element to multiply
+  
+  product_so_far = 1
+  for i in range(len(arr)):
+    products_expect_index [i] = product_so_far
+    product_so_far *= arr[i]
+
+
+  # For each integer, we find the product of all the integers
+  # after it. Since each index in product already has the 
+  # product of all the integers before it, now we'are storing the total product of all other integers
+
+  # We traverse through the list backwards and calcuate the product using the already calucated product above.
+  product_so_far = 1
+  for i in range(len(arr) -1, -1, -1):
+    products_expect_index[i] *= product_so_far
+    product_so_far *= arr[i]
+    
+  return products_expect_index
+   
+  
+   
+arr = [1, 2, 3, 4, 5]
+print ("Input :  ", arr)
+print ("Output: ", get_array_product_except_index(arr))
+
+"""
+Complexity: 
+
+O(n) time and
+O(n) space. 
+
+We make two passes through our input a list, and the list we build always has the same length as the input list.
+
+"""

002_array_product_except_index.py

@@ -0,0 +1,49 @@
+"""This problem was asked by amazon.
+ 
+Given an array of integers, find the first missing positive integer in linear time and constant space. In other words, find the lowest positive integer that does not exist in the array. The array can contain duplicates and negative numbers as well.
+ 
+For example, the input [3, 4, -1, 1] should give 2. The input [1, 2, 0] should give 3.
+ 
+You can modify the input array in-place."""
+
+# Solution:
+
+# Approach 1: 
+"""we would just sort the array, while filtering out negative numbers, and iterate over the sorted array and return the first number that doesn't match the index. However, sorting takes O(n log n), so we can't use that here."""
+ 
+# Approach 2:
+"""Clearly we have to use some sort of trick here to get it running in linear time. Since the first missing positive number must be between 1 and len(array) + 1 (why?), we can ignore any negative numbers and numbers bigger than len(array). The basic idea is to use the indices of the array itself to reorder the elements to where they should be. We traverse the array and swap elements between 0 and the length of the array to their value's index. We stay at each index until we find that index's value and keep on swapping.
+ 
+By the end of this process, all the first positive numbers should be grouped in order at the beginning of the array. We don't care about the others. This only takes O(N) time, since we swap each element at most once.
+ 
+Then we can iterate through the array and return the index of the first number that doesn't match, just like before."""
+
+
+def first_missing_positive(nums):
+    if not nums:
+        return 1
+    for i, num in enumerate(nums):
+        while i + 1 != nums[i] and 0 < nums[i] <= len(nums):
+            v = nums[i]
+            nums[i], nums[v - 1] = nums[v - 1], nums[i]
+            if nums[i] == nums[v - 1]:
+                break
+    for i, num in enumerate(nums, 1):
+        if num != i:
+            return i
+    return len(nums) + 1
+  
+nums = [3, 4, -1, 1]
+print (first_missing_positive(nums))
+
+# Approach 3:
+"""Another way we can do this is by adding all the numbers to a set, and then use a counter initialized to 1. Then continuously increment the counter and check whether the value is in the set."""
+
+"""def first_missing_positive(nums):
+    s = set(nums)
+    i = 1
+    while i in s:
+        i += 1
+    return i
+    
+This is much simpler, but runs in O(N) time and space, whereas the previous algorithm uses no extra space."""

003_missing_positive_integer.py

@@ -0,0 +1,33 @@
+# Problem: https://leetcode.com/problems/last-stone-weight/
+"""
+We have a collection of rocks, each rock has a positive integer weight.
+
+Each turn, we choose the two heaviest rocks and smash them together.  Suppose the stones have weights x and y with x <= y.  The result of this smash is:
+
+If x == y, both stones are totally destroyed;
+If x != y, the stone of weight x is totally destroyed, and the stone of weight y has new weight y-x.
+At the end, there is at most 1 stone left.  Return the weight of this stone (or 0 if there are no stones left.)
+
+ 
+
+Example 1:
+
+Input: [2,7,4,1,8,1]
+Output: 1
+Explanation: 
+We combine 7 and 8 to get 1 so the array converts to [2,4,1,1,1] then,
+we combine 2 and 4 to get 2 so the array converts to [2,1,1,1] then,
+we combine 2 and 1 to get 1 so the array converts to [1,1,1] then,
+we combine 1 and 1 to get 0 so the array converts to [1] then that's the value of last stone."""
+
+import heapq
+class Solution:
+    def lastStoneWeight(self, stones):
+        # we will use heappop which pops smallest elmenent
+        # Since we need largest, we are adding minus(-) and pick it using heappop
+        pq = [-x for x in stones]
+        heapq.heapify(pq)
+        for i in range(len(stones)-1):
+            x, y = -heapq.heappop(pq), -heapq.heappop(pq)
+            heapq.heappush(pq, -abs(x-y))
+        return -pq[0]

004_Last_Stone_Weight.py

@@ -0,0 +1,29 @@
+# https://www.geeksforgeeks.org/maximum-sum-such-that-no-two-elements-are-adjacent/
+# Function to return max sum such that  
+# no two elements are adjacent 
+
+"""
+Given an array of positive numbers, find the maximum sum of a subsequence with the constraint that no 2 numbers in the sequence should be adjacent in the array. So 3 2 7 10 should return 13 (sum of 3 and 10) or 3 2 5 10 7 should return 15 (sum of 3, 5 and 7).Answer the question in most efficient way."""
+
+def find_max_sum(arr): 
+    incl = 0
+    excl = 0
+     
+    for i in arr: 
+          
+        # Current max excluding i (No ternary in  
+        # Python) 
+        new_excl = excl if excl>incl else incl 
+         
+        # Current max including i 
+        incl = excl + i 
+        excl = new_excl 
+      
+    # return max of incl and excl 
+    return (excl if excl>incl else incl) 
+  
+# Driver program to test above function 
+arr = [5, 5, 10, 100, 10, 5] 
+print (find_max_sum(arr))
+
+# Time Complexity: O(n)

005_max_sum_nonadjacent.py

@@ -0,0 +1,86 @@
+"""
+This problem was asked by Amazon. [Hard]
+
+There exists a staircase with N steps, and you can climb up either 1 or 2 steps at a time. Given N, write a function that returns the number of unique ways you can climb the staircase. The order of the steps matters.
+
+For example, if N is 4, then there are 5 unique ways:
+
+1, 1, 1, 1
+2, 1, 1
+1, 2, 1
+1, 1, 2
+2, 2
+
+What if, instead of being able to climb 1 or 2 steps at a time, you could climb any number from a set of positive integers X? For example, if X = {1, 3, 5}, you could climb 1, 3, or 5 steps at a time."""
+
+# Solution:
+""" Let's start with small test cases and see if we can find some sort of patterns
+
+Number of stairs -> N
+N = 1 -> [1]
+N = 2 -> [1, 1], [2]
+N = 3 -> [1, 1, ,1] , [1,2] [2,1]
+N = 4 -> [1, 1, 1, 1], [1,2,1], [1,1,2], [2,2], [2,1,1]
+
+The only ways to get to N = 3, is to first get to N=1 and then go up by 2 steps, or get to N=2 and go by up by 1 step. So f(3) = f(2) + f(1)
+
+Does this hold for N = 4? Yes, it does. Since we can only get to the 4th step by getting to the 3rd step and going up by one, or by getting to the 2nd step and going up by two. So f(4) = f(3) + f(2).
+
+
+To generalize, f(n) = f(n - 1) + f(n - 2). That's just the Fibonacci sequence!
+------------------------------------------
+def staircase(n):
+  if n < =1:
+    return 1
+  return staircase(n-1) + staircase(n-2)
+------------------------------------------
+
+  
+Of course, this is really slow (O(2^N)) — we are doing a lot of repeated computations! We can do it a lot faster by just computing iteratively.
+-------------------------------
+def staircase(n):
+  a = 1
+  b = 2 
+  for _ in range(n-1):
+    a, b = b, a+b
+  return a
+
+print (staircase(3))
+-------------------------------
+
+Now, let's try to generalize what we've learned so that it works if you can take a number of steps from the set X. Similar reasoning tells us that if X = {1, 3, 5}, then our algorithm should be f(n) = f(n - 1) + f(n - 3) + f(n - 5). If n < 0, then we should return 0 since we can't start from a negative number of steps.
+
+Let X = {1, 3, 5}
+# Recursive approach O(X^N)
+------------------------------
+def staircase(n, X):
+  if n <0:
+    return 0
+  elif n == 1:
+    return 1
+  else:
+    return sum(staircase(n - e) for e in X)
+  
+  This is again, very slow (O(|X|^N)) since we are repeating computations again. We can use dynamic programming to speed it up.
+  
+  Each entry cache[i] will contain the number of ways we can get to step i with the X."""
+  
+def staircase(n, X):
+  cache = [0 for _ in range(n+1)]
+  cache[0] = 1
+  for i in range(1, n+1):
+    cache[i] += sum(cache[i-x] for x in X if i-x >=0)
+  return cache[n]
+
+X = {1, 3, 5}
+print (staircase(4, X))
+    
+  #This now takes O(N * |X|) time and O(N) space.
+      
+  
+
+
+
+
+
+

006_climbing_stairs.py

@@ -0,0 +1,53 @@
+"""This problem was asked by Amazon. [Hard]
+
+Given an integer k and a string s, find the length of the longest substring that contains at most k distinct characters.
+
+For example, given s = "abcba" and k = 2, the longest substring with k distinct characters is "bcb".
+"""
+# =====================================================================================================
+# Solution 1:
+"""The most obvious brute force solution here is to simply try every possible substring of the string to check whether it containts at most k distinct characters. If it does and it is greater than the current longest valid substring, then update the current one. """
+
+"""def longest_substring_with_k_distinct_chars(s, k):
+  current_longest_substring = ''
+  for i in range(len(s)):
+    for j in range(i+1, len(s)+1):
+      substring = s[i:j]
+      if len(set(substring)) <= k and len(substring) > len(current_longest_substring):
+        current_longest_substring = substring
+  return len(current_longest_substring)
+        
+print (longest_substring_with_k_distinct_chars("abcba",2))"""
+
+"""This takes O(n^2 * k) time, since we use n2 to generate each possible substring, and then take k to check each character."""
+# =====================================================================================================
+
+# Solution 2:
+
+"""
+We can improve this by instead of keeping a running window of our longest substring. We keep a dictionary that maps characters to the index of their last occurence. Then, as we iterate over the string, we will check the size of the dictionary. If it's larger than k, then it means our window is too big, so we have to pop the smallest item in the dictionary and recompute the outbounds. If, when we add a character to the dictionary and it doesn't go over k, then we are safe - the dictionary hasn't been filled up yet or it's a character we have seen before.
+"""
+def longest_substring_with_k_distinct_chars(s,k):
+  if k ==0:
+    return 0
+  
+  # keep a running window
+  bounds = (0,0)
+  h = {}
+  max_length = 0
+  for i, char in enumerate(s):
+    h[char] = i
+    if len(h) <=k:
+      new_lower_bound = bounds[0] # lower bound remain same
+    else:
+      #otherwise, pop last occuring char
+      key_to_pop = min(h, key=h.get)
+      new_lower_bound = h.pop(key_to_pop) + 1
+      
+    bounds = (new_lower_bound, bounds[1]+1)
+    max_length = max(max_length, bounds[1] - bounds[0])
+  return max_length
+  
+print (longest_substring_with_k_distinct_chars("abcba",2))
+
+# This takes O(n * k) time and O(k) space.

007_longest_substring_count.py

@@ -0,0 +1,31 @@
+"""
+The problem is that we want to reverse a T[] array in O(N) linear time complexity and we want the algorithm to be in-place as well!
+
+For example: input is [1,2,3,4,5] then the output is [5,4,3,2,1]"""
+
+# Solution:
+# In place algorithms that reverses array in O(N) with no extra space
+
+def array_reversal(arr):
+  
+  # pointer to the first item
+  start_index = 0
+  # pointer to the last time
+  end_index = len(arr) - 1
+  
+  # while the end index is greater than the start index
+  while end_index > start_index:
+    #swap two items
+    arr[start_index], arr[end_index] = arr[end_index], arr[start_index]
+    
+    #increment the start index
+    start_index += 1
+    
+    # decrement the end index
+    end_index -= 1
+    
+  return arr
+
+if __name__ == "__main__":
+  arr = [1, 2, 3, 4, 5]
+  print (array_reversal(arr))