New Strings questions

Author: rahulcode22

Arrays/BubbleSort.py

@@ -0,0 +1,12 @@
+'''
+Bubble sort is a example of sorting algorithm . In this method we at first compare the data element in the first position with the second position and arrange them in desired order.Then we compare the data element with with third data element and arrange them in desired order. The same process continuous until the data element at second last and last position
+'''
+def bubbleSort(arr,n):
+    for i in range(0,n):
+        for j in range(0,n):
+            if arr[j]>arr[i]:
+                arr[i], arr[j] = arr[j], arr[i]
+    return arr
+
+arr = [3,2,6,4,1]
+print bubbleSort(arr,5)

Binary-Search/Matrix-median.py

@@ -0,0 +1,15 @@
+'''
+Given a N cross M matrix in which each row is sorted, find the overall median of the matrix. Assume N*M is odd.
+'''
+class Solution:
+    # @param A : list of list of integers
+    # @return an integer
+    def findMedian(self, matrix):
+
+        lis = []
+        for i in range(len(matrix)):
+            for j in range(len(matrix[0])):
+                lis.append(matrix[i][j])
+
+        lis.sort()
+        return lis[len(lis)/2]

Binary-Search/Median-of-array.py

@@ -0,0 +1,53 @@
+'''
+There are two sorted arrays A and B of size m and n respectively.
+
+Find the median of the two sorted arrays ( The median of the array formed by merging both the arrays ).
+
+The overall run time complexity should be O(log (m+n)).
+'''
+
+class Solution:
+    # @param A : tuple of integers
+    # @param B : tuple of integers
+    # @return a double
+    def findMedianSortedArrays(self, A, B):
+        m = len(A)
+        n = len(B)
+        if m > n:
+            n,m = m,n
+            A,B = B,A
+        if m == 0:
+            if n == 0:
+                return 0
+            if n%2:
+                return B[n/2]
+            else:
+                return (B[n/2]+B[n/2-1])/2.0
+        low = 0
+        high = m
+        while low <= high:
+            i = (low+high)/2
+            j = (m+n+1)/2-i
+            if (j == 0 or i == m or B[j - 1] <= A[i]) and (i == 0 or j == n or A[i-1] <= B[j]):
+                if (m+n)%2:
+                    if i == 0:
+                        return B[j-1]
+                    elif j == 0:
+                        return A[i-1]
+                    return max(A[i-1],B[j-1])
+                else:
+                    if i == 0:
+                        return (B[j-1] + min(A[i],B[j]))/2.0
+                    if j == 0:
+                    	return (A[i-1] + min(A[i],B[j]))/2.0
+                    if i == m:
+                    	return (max(A[i-1],B[j-1]) + B[j])/2.0
+                    if j == n:
+                    	return (max(A[i-1],B[j-1]) + A[i])/2.0
+                    return (max(A[i-1],B[j-1]) + min(A[i],B[j]))/2.0
+            elif (j == 0 or i == m or B[j - 1] > A[i]):
+                low = i+1
+            elif (i == 0 or j == n or A[i-1] > B[j]):
+                high = i-1
+        return -1
+        

Binary-Search/Painter's-partition-problem.py

@@ -0,0 +1,35 @@
+'''
+You have to paint N boards of length {A0, A1, A2, A3 … AN-1}. There are K painters available and you are also given how much time a painter takes to paint 1 unit of board. You have to get this job done as soon as possible under the constraints that any painter will only paint contiguous sections of board.
+'''
+def ppp(n,time,arr):
+    def isPossible(t,c,a):
+        summ = 0
+        while a > 0 and len(c) > 0:
+            if summ + c[-1] > t:
+                summ = 0
+                a -=1
+            else:
+                summ += c.pop()
+        if len(c) == 0:
+            return True
+        else:
+            return False
+
+    x = max(arr)
+    y = sum(arr)
+    if len(arr) == 0:
+        return 0
+    if len(arr) == 1:
+        return time*arr[0]
+    prev = y
+    while x < y:
+        m = (x + y)/2
+        if isPossible(m,arr[:],n):
+            prev = m
+            y = m - 1
+        else:
+            x = m + 1
+    m = prev
+    while isPossible(m-1,arr[:],n):
+        m = m - 1
+    return m*B % 1000003

Binary-Search/Square-root-of-integer.py

@@ -0,0 +1,20 @@
+from math import floor
+def sqrtsearch(x):
+    start = 1
+    end  = x
+    ans = 0
+    if x == 0 or x == 1:
+        return x
+    while start <= end:
+        mid = (start+end)/2
+        if x == mid*mid:
+            return mid
+        elif x > (mid*mid):
+            start = mid + 1
+            ans = mid
+        else:
+            end = mid - 1
+    return floor(ans)
+
+x = 11
+print sqrtsearch(x)

Binary-Search/sorted-insert-position.py

@@ -0,0 +1,32 @@
+'''
+Given a sorted array and a target value, return the index if the target is found. If not, return the index where it would be if it were inserted in order.
+
+You may assume no duplicates in the array.
+'''
+class Solution:
+    # @param A : list of integers
+    # @param B : integer
+    # @return an integer
+    def searchInsert(self, arr, target):
+
+        floor_index = 0
+        ceiling_index = len(arr) - 1
+        if len(arr) == 1 and arr[0] == target:
+            return 0
+        if arr[ceiling_index-1] < target:
+            return ceiling_index + 1
+
+        while floor_index < ceiling_index:
+            mid = (floor_index + ceiling_index)/2
+            if arr[mid] == target:
+                return mid
+            elif arr[mid] > target:
+                ceiling_index = mid-1
+                ans = mid -1
+            else:
+                floor_index = mid + 1
+                ans = mid + 1
+        if arr[ans] < target:
+            return ans + 1
+        else:
+            return ans

Math/Sorted-Permutation-Rank.py

@@ -0,0 +1,54 @@
+'''
+Given a string, find the rank of the string amongst its permutations sorted lexicographically.
+Assume that no characters are repeated.
+
+EXAMPLE:
+Input : 'acb'
+Output : 2
+
+The order permutations with letters 'a', 'c', and 'b' :
+abc
+acb
+bac
+bca
+cab
+cba
+The answer might not fit in an integer, so return your answer % 1000003
+'''
+from itertools import permutations
+class Solution:
+    # @param A : string
+    # @return an integer
+    def findRank(self, st):
+
+        def fact(n):
+
+            f = 1
+            while n >= 1:
+                f = f*n
+                n = n-1
+            return f
+
+        def findSmallerInRight(st,low,high):
+            countRight = 0
+            i = low + 1
+            while i <= high:
+                if st[i] < st[low]:
+                    countRight += 1
+                i = i + 1
+            return countRight
+
+        mul = fact(len(st))
+        rank = 1
+        i = 0
+        while i < len(st):
+            mul = mul/(len(st)-i)
+            #count no of chars smaller than str[i] from str[i+1] to str[len-1]
+            countRight = findSmallerInRight(st,i,len(st)-1)
+            rank = rank + countRight*mul
+            i = i+1
+        for i in set(st):
+            if st.count(i) > 1:
+                rank =rank/fact(st.count(i))
+                
+        return rank%1000003

Math/largest-coprime-divisor.py

@@ -0,0 +1,21 @@
+'''
+You are given two positive numbers A and B. You need to find the maximum valued integer X such that:
+
+X divides A i.e. A % X = 0
+X and B are co-prime i.e. gcd(X, B) = 1
+'''
+def gcd(a, b):
+    while b:
+        a, b = b, a%b
+    return a
+
+class Solution:
+    # @param A : integer
+    # @param B : integer
+    # @return an integer
+    def cpFact(self, A, B):
+        p=gcd(A,B)
+        while p!=1:
+            A/=p
+            p=gcd(A,B)
+        return A

Math/sorted-permutations-rank-with-repeats.py

@@ -0,0 +1,80 @@
+from itertools import permutations
+class Solution:
+
+    def fact (self, n ) :
+        if n <= 1 :
+            return 1
+        else :
+            return n * self.fact(n-1)
+
+    def findRank(self, A):
+
+        res = 1
+        char_occur = {}
+        for char in A:
+            char_occur[char] = char_occur.get(char, 0) + 1
+        for i in range(0, len(A)-1) :
+            rank = 0
+            for j in range(i+1, len(A)) :
+                if A[i] > A[j] :
+                    rank += 1
+            temp = self.fact(len(A) - i - 1)%1000003
+            temp1= 1
+            for key in char_occur.keys() :
+                temp1 *= self.fact(char_occur[key])
+            temp1 = pow(temp1, 1000001, 1000003)
+            res = (res + rank * temp1 * temp)%1000003
+            char_occur[A[i]] -= 1
+        return res
+
+'''
+Another Solution
+'''
+def fact(n) :
+    f = 1
+    while n >= 1 :
+        f = f * n
+        n = n - 1
+    return f
+
+# A utility function to count smaller
+# characters on right of arr[low]
+def findSmallerInRight(st, low, high) :
+
+    countRight = 0
+    i = low + 1
+    while i <= high :
+        if st[i] < st[low] :
+            countRight = countRight + 1
+        i = i + 1
+
+    return countRight
+
+# A function to find rank of a string
+# in all permutations of characters
+def findRank (st) :
+    ln = len(st)
+    mul = fact(ln)
+    rank = 1
+    i = 0
+
+    while i < ln :
+
+        mul = mul / (ln - i)
+
+        # count number of chars smaller
+        # than str[i] fron str[i+1] to
+        # str[len-1]
+        countRight = findSmallerInRight(st, i, ln-1)
+
+        rank = rank + countRight * mul
+        i = i + 1
+    for j in set(st):
+        if st.count(j) > 1:
+            rank = rank/fact(st.count(j))
+    return rank + 1
+
+
+# Driver program to test above function
+st = "aba"
+print (findRank(st))

String/KMP-Algo.py

@@ -0,0 +1,44 @@
+def KMPSearch(pat,txt):
+    m = len(pat)
+    n = len(txt)
+    #Now create a lps array that will hold the longest prefix suffix value
+    lps = [0]*m
+    j = 0 #index for pat
+    computeLPSArray(pat,m,lps)
+
+    i = 0 #index For txt[]
+
+    while i < n:
+        if pat[j] == txt[i]:
+            i += 1
+            j += 1
+        if j == m:
+            print "Pattern found at index" + str(i-j)
+            j = lps[j-1]
+        elif i < n and pat[j] != txt[i]:
+            if j != 0:
+                j = lps[j-1]
+            else:
+                i += 1
+
+def computeLPSArray(pat,m,lps):
+    j = 0 #length of previous lps
+    lps[0] = 0
+    i = 1
+    while i < m:
+        if pat[i] == pat[j]:
+            j += 1
+            lps[i] = j
+            i += 1
+        else:
+            if j != 0:
+                j = lps[j-1]
+
+            else:
+                lps[i] = 0
+                i += 1
+
+#Now time to test
+txt = "ABABDABACDABABCABAB"
+pat  = "ABABCABAB"
+KMPSearch(pat,txt)