├── .gitignore ├── README.md ├── Strings ├── Revword.py ├── LengthLast.py ├── Palindrome.py ├── LCP.py ├── Multiply.py ├── ZigZag.py ├── Roman2Int.py ├── LongestPalin.py ├── Version.py ├── Count_Say.py ├── AtoI.py ├── PrettyJSON.py ├── Power.py ├── StrStr.py ├── AddBinary.py ├── IPAddress.py ├── Int2Roman.py ├── ValidNumber.py └── TextJust.py ├── Bit Manipulation ├── Single.py ├── Num1Bits.py ├── Revbits.py ├── Single2.py ├── CntBits.py └── Divide.py ├── Math ├── gcd.py ├── Factorial.py ├── Excel1.py ├── Excel2.py ├── Revint.py ├── Arrange.py ├── Palindrome.py ├── Power2.py ├── Paths.py ├── PrimeSum.py ├── Rank.py └── Rank2.py ├── Backtracking ├── PalinPart.py ├── Subset.py ├── Permutations.py ├── LetterPhone.py ├── Subset2.py ├── Combinations.py ├── Comb2.py ├── PermSeq.py ├── Comb.py ├── Parenthesis.py ├── Sudoku.py └── NQueens.py ├── Binary Search ├── Sqrt.py ├── Pow.py ├── Search2D.py ├── Books.py ├── InsertPos.py ├── Paint.py ├── SearchRotated.py ├── SearchRange.py └── MedianArray.py ├── Dynamic Programming ├── Stairs.py ├── Adjacent.py ├── UniqueTrees.py ├── LIS.py ├── CoinChange2.py ├── Triangle.py ├── Stocks2.py ├── MaxProd.py ├── DistinctSubseq.py ├── MinPath.py ├── AnyTwo.py ├── Jump1.py ├── EditDistance.py ├── Jump2.py ├── Palin2.py ├── Regex2.py ├── MaxPathTree.py ├── LongestParen.py ├── Stocks1.py ├── Regex.py ├── Dungeon.py ├── WordBreak.py ├── WordBreak2.py ├── DecodeWays.py ├── Paths2.py ├── Scramble.py ├── MaxRectangle.py ├── Maxcoin.py ├── Stocks3.py ├── RodCut.py ├── Arrange2.py ├── AvgSet.py ├── CNTTrue.py └── IsInterleave.py ├── Arrays ├── Maxsum.py ├── Diagnol.py ├── Wave.py ├── Rotate2D.py ├── Largestnum.py ├── Pascal1.py ├── RepeatArr.py ├── Pascal2.py ├── Narray.py ├── reach.py ├── Positive.py ├── Setzero.py ├── Interval2.py ├── Hotel.py ├── Nextperm.py ├── Maxdist.py ├── Plus1.py ├── Maxset.py ├── Repeat3.py ├── Flip.py ├── Spiral.py ├── Maxgap.py └── Interval.py ├── Two pointers ├── RemDup.py ├── SortColor.py ├── RemElem.py ├── Merge.py ├── Diffk.py ├── IntersectArr.py ├── MaxOne.py ├── Container.py ├── Array3Ptr.py ├── 3Sum.py ├── 3SumZero.py └── RemDup2.py ├── Greedy ├── MaxP3.py ├── Mice.py ├── Majority.py ├── Bulbs.py ├── Gas.py ├── Candy.py └── Seats.py ├── Hashing ├── Colorful.py ├── LSZero.py ├── 2Sum.py ├── RepeatStr.py ├── Equal.py ├── WindowStr.py ├── CopyList.py ├── Anagrams.py ├── ValidSudoku.py ├── Fraction.py ├── Substring.py ├── Points.py └── 4Sum.py ├── Stacks and Queues ├── Nearest.py ├── Braces.py ├── SimplifyPath.py ├── SlidingMax.py ├── EvalExp.py ├── Rain.py ├── MinStack.py └── Histogram.py ├── Graphs ├── Fibsum.py ├── Surrounding.py ├── Black.py ├── CloneGraph.py ├── LevelOrder.py ├── StepNum.py ├── Knight.py ├── List2Tree.py ├── WordLadder1.py ├── Multiple.py ├── WordSearch.py ├── Multiple.cpp └── WordLadder2.py ├── Trees ├── SameTree.py ├── ArrayBST.py ├── Preorder.py ├── Invert.py ├── Symmetry.py ├── MaxDepth.py ├── Cartesian.py ├── KthSmallest2.py ├── BinTree.py ├── MinDepth.py ├── Path2.py ├── SumRootLeaf.py ├── NextPointer2.cpp ├── Postorder.py ├── BinTree2.py ├── Inorder.py ├── TreeIterator.py ├── Balanced.py ├── Flatten.py ├── LCA.py ├── Path.py ├── Recover.py ├── NextPointer2.py ├── ZigZagTree.py ├── Prefix.py ├── T2Sum.py └── Order.py ├── Linked Lists ├── RemDupLink.py ├── Merge.py ├── ListCycle.py ├── NthEnd.py ├── SwapL.py ├── PartitionList.py ├── InsertionSort.py ├── LPalin.py ├── AddNum.py ├── RemDupLink2.py ├── SortList.py ├── ReverseList.py └── ReorderList.py └── Heaps and Maps ├── LRU.py ├── DNums.py └── MergeKList.py /.gitignore: -------------------------------------------------------------------------------- 1 | *~ 2 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # interviewbit-solutions-python -------------------------------------------------------------------------------- /Strings/Revword.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : string 3 | # @return string 4 | def reverseWords(self, A): 5 | return " ".join(A.split()[::-1]) 6 | 7 | -------------------------------------------------------------------------------- /Bit Manipulation/Single.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : tuple of integers 3 | # @return an integer 4 | def singleNumber(self, A): 5 | return reduce(lambda x,y : x^y, A) 6 | 7 | -------------------------------------------------------------------------------- /Bit Manipulation/Num1Bits.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : integer 3 | # @return an integer 4 | def numSetBits(self, A): 5 | s = 0 6 | while A != 0: 7 | s += A % 2 8 | A /= 2 9 | return s 10 | 11 | -------------------------------------------------------------------------------- /Math/gcd.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : integer 3 | # @param B : integer 4 | # @return an integer 5 | def gcd(self, A, B): 6 | if B > A: 7 | A, B = B, A 8 | while B: 9 | A , B = B, A%B 10 | return A 11 | -------------------------------------------------------------------------------- /Backtracking/PalinPart.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : string 3 | # @return a list of list of strings 4 | def partition(self, s): 5 | return [[s[:i]] + rest for i in range(1,len(s)+1) if s[:i] == s[:i][::-1] for rest in self.partition(s[i:]) or [[]]] 6 | 7 | -------------------------------------------------------------------------------- /Binary Search/Sqrt.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : integer 3 | # @return an integer 4 | def sqrt(self, A): 5 | if A < 2: return A 6 | root = A 7 | 8 | while root * root > A: 9 | root = (root + A/root)/2 10 | return root 11 | -------------------------------------------------------------------------------- /Dynamic Programming/Stairs.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : integer 3 | # @return an integer 4 | def climbStairs(self, A): 5 | stairs = [1]*(A+1) 6 | for i in range(2,len(stairs)): 7 | stairs[i] = stairs[i-1] + stairs[i-2] 8 | return stairs[-1] 9 | -------------------------------------------------------------------------------- /Math/Factorial.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : integer 3 | # @return an integer 4 | def trailingZeroes(self, A): 5 | val = 5 6 | res = 0 7 | i = 1 8 | while A >= val**i: 9 | res += A/(val**i) 10 | i += 1 11 | 12 | return res 13 | 14 | -------------------------------------------------------------------------------- /Bit Manipulation/Revbits.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : unsigned integer 3 | # @return an unsigned integer 4 | def reverse(self, A): 5 | a = 0 6 | for i in range(32): 7 | a <<= 1 8 | a |= A & 1 9 | A >>= 1 10 | 11 | return a 12 | 13 | -------------------------------------------------------------------------------- /Bit Manipulation/Single2.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : tuple of integers 3 | # @return an integer 4 | def singleNumber(self, A): 5 | ones = 0 6 | twos = 0 7 | for n in A: 8 | ones = (ones ^ n) & ~twos 9 | twos = (twos ^ n) & ~ones 10 | 11 | return ones 12 | -------------------------------------------------------------------------------- /Arrays/Maxsum.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : tuple of integers 3 | # @return an integer 4 | def maxSubArray(self, A): 5 | max_here = A[0] 6 | res = A[0] 7 | for x in A[1:]: 8 | max_here = max(x, max_here + x) 9 | res = max(max_here, res) 10 | 11 | return res 12 | -------------------------------------------------------------------------------- /Arrays/Diagnol.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param a : list of list of integers 3 | # @return a list of list of integers 4 | def diagonal(self, a): 5 | B = [[] for i in range(len(a)*2)] 6 | for i in range(len(a)): 7 | for j in range(len(a)): 8 | B[i+j].append(a[i][j]) 9 | 10 | return B[:-1] 11 | 12 | 13 | -------------------------------------------------------------------------------- /Backtracking/Subset.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : list of integers 3 | # @return a list of list of integers 4 | def subsets(self, A): 5 | all_subsets = [[]] 6 | for item in sorted(A): 7 | all_subsets += [prev_subset + [item] for prev_subset in all_subsets] 8 | return sorted(all_subsets) 9 | 10 | -------------------------------------------------------------------------------- /Dynamic Programming/Adjacent.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : list of list of integers 3 | # @return an integer 4 | def adjacent(self, A): 5 | L = [0 for i in range(len(A[0]) + 3)] 6 | for i in range(len(A[0])): 7 | L[i+3] = max(L[i+1], L[i]) + max(A[0][i], A[1][i]) 8 | return L[-1] if L[-1] > L[-2] else L[-2] 9 | -------------------------------------------------------------------------------- /Math/Excel1.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : string 3 | # @return an integer 4 | def titleToNumber(self, A): 5 | #A = A[::] 6 | num = 0 7 | count = 0 8 | for i in range(len(A)-1,-1,-1): 9 | num += (ord(A[i]) - ord('A') + 1) * pow(26, count) 10 | count += 1 11 | return num 12 | -------------------------------------------------------------------------------- /Math/Excel2.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : integer 3 | # @return a strings 4 | def convertToTitle(self, A): 5 | res = "" 6 | while A > 0: 7 | A -= 1 8 | temp = A%26 9 | A /= 26 10 | res += chr(ord('A')+temp) 11 | 12 | return res[::-1] 13 | 14 | -------------------------------------------------------------------------------- /Arrays/Wave.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : list of integers 3 | # @return a list of integers 4 | def wave(self, A): 5 | A.sort() 6 | n = len(A) 7 | for i in range(0,n,2): 8 | if i + 1 < n: 9 | A[i], A[i+1] = A[i+1], A[i] 10 | 11 | return A 12 | 13 | 14 | -------------------------------------------------------------------------------- /Math/Revint.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : integer 3 | # @return an integer 4 | def reverse(self, A): 5 | 6 | if A < 0: 7 | return -int(str(-A)[::-1]) if -int(str(-A)[::-1]) > -2147483647 else 0 8 | 9 | else: 10 | return int(str(A)[::-1]) if int(str(A)[::-1]) < 2147483647 else 0 11 | 12 | -------------------------------------------------------------------------------- /Arrays/Rotate2D.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : list of list of integers 3 | # @return the same list modified 4 | def rotate(self, A): 5 | for i in range(len(A)): 6 | for j in range(i,len(A)): 7 | A[i][j] , A[j][i] = A[j][i] , A[i][j] 8 | 9 | for i in A: 10 | i.reverse() 11 | 12 | return A 13 | 14 | -------------------------------------------------------------------------------- /Dynamic Programming/UniqueTrees.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : integer 3 | # @return an integer 4 | def numTrees(self, A): 5 | fact_2n = 1 6 | fact_n = 1 7 | import sys 8 | for i in range(A+2, 2*A + 1): 9 | fact_2n *= i 10 | fact_n *= (i-A) 11 | return fact_2n / fact_n if fact_2n / fact_n < sys.maxint else -sys.maxint -1 12 | 13 | -------------------------------------------------------------------------------- /Dynamic Programming/LIS.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : tuple of integers 3 | # @return an integer 4 | def lis(self, A): 5 | if not A: return 0 6 | n = len(A) 7 | l = [1] * n 8 | for i in range(1, n): 9 | for j in range(0,i): 10 | if A[i] > A[j] and l[i] < l[j] + 1: 11 | l[i] = l[j] + 1 12 | return max(l) 13 | 14 | -------------------------------------------------------------------------------- /Two pointers/RemDup.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : list of integers 3 | # @return an integer 4 | def removeDuplicates(self, A): 5 | count = 0 6 | i = 0 7 | while i < len(A): 8 | if i == 0 or A[i] != A[i-1]: 9 | A[count] = A[i] 10 | count += 1 11 | 12 | i += 1 13 | 14 | return count 15 | 16 | -------------------------------------------------------------------------------- /Greedy/MaxP3.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : list of integers 3 | # @return an integer 4 | def maxp3(self, A): 5 | A = sorted(A) 6 | 7 | if A[-1] < 0: 8 | return A[-1] * A[-2] * A[-3] 9 | else: 10 | third_number = A[-1] 11 | other_two_mult = max((A[0]* A[1]), (A[-2]* A[-3])) 12 | return third_number * other_two_mult 13 | 14 | -------------------------------------------------------------------------------- /Math/Arrange.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : list of integers 3 | # Modify the array A which is passed by reference. 4 | # You do not need to return anything in this case. 5 | def arrange(self, A): 6 | N = len(A) 7 | for i in range(len(A)): 8 | A[i] = A[i] + A[A[i]%N]%N * N 9 | 10 | for i in range(len(A)): 11 | A[i] /= N 12 | 13 | 14 | -------------------------------------------------------------------------------- /Backtracking/Permutations.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : list of integers 3 | # @return a list of list of integers 4 | def permute(self, A): 5 | if len(A) == 1: return [A] 6 | permus = [] 7 | for i in range(len(A)): 8 | for l in self.permute(A[:i] + A[i+1:]): 9 | permus.append([A[i]] + l) 10 | 11 | 12 | return permus 13 | 14 | 15 | -------------------------------------------------------------------------------- /Arrays/Largestnum.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : tuple of integers 3 | # @return a strings 4 | def largestNumber(self, A): 5 | a = map(str, A) 6 | a.sort(cmp_items, reverse = True) 7 | return ''.join(a).lstrip('0') or '0' 8 | 9 | 10 | def cmp_items(a, b): 11 | if int(a+b) > int(b+a): 12 | return 1 13 | elif int(a+b) == int(b+a): 14 | return 0 15 | else: 16 | return -1 17 | 18 | 19 | -------------------------------------------------------------------------------- /Dynamic Programming/CoinChange2.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : list of integers 3 | # @param B : integer 4 | # @return an integer 5 | def coinchange2(self, A, B): 6 | if not A: return 0 7 | change = [0] * (B+1) 8 | change[0] = 1 9 | for i in range(len(A)): 10 | for j in range(A[i], B+1): 11 | change[j] += change[j - A[i]] 12 | change[j] %= 1000007 13 | return change[-1] 14 | 15 | -------------------------------------------------------------------------------- /Math/Palindrome.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : integer 3 | # @return a boolean value ( True / False ) 4 | def isPalindrome(self, A): 5 | def reverse(n): 6 | res = 0 7 | while n: 8 | temp = n % 10 9 | res = res*10 + temp 10 | n /= 10 11 | 12 | return res 13 | 14 | if A < 0: 15 | return False 16 | 17 | return A == reverse(A) 18 | 19 | -------------------------------------------------------------------------------- /Strings/LengthLast.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : string 3 | # @return an integer 4 | def lengthOfLastWord(self, A): 5 | if not A: return 0 6 | j = 0 7 | while j < len(A) and A[~j] == ' ': 8 | j += 1 9 | 10 | i = j 11 | length = 0 12 | while i < len(A): 13 | if A[~i] == " ": 14 | return length 15 | length += 1 16 | i += 1 17 | 18 | return length 19 | -------------------------------------------------------------------------------- /Dynamic Programming/Triangle.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : list of list of integers 3 | # @return an integer 4 | def minimumTotal(self, A): 5 | m = len(A) 6 | n = len(A[-1]) 7 | import sys 8 | cost = [[sys.maxint] * (n+1) for i in range(m+1)] 9 | cost[0][0] = 0 10 | for i in range(m): 11 | for j in range(len(A[i])): 12 | cost[i+1][j+1] = A[i][j] + min(cost[i][j], cost[i][j+1]) 13 | 14 | return min(cost[-1]) 15 | 16 | -------------------------------------------------------------------------------- /Math/Power2.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : integer 3 | # @return a boolean 4 | def isPower(self, A): 5 | if A < 2: 6 | return True 7 | 8 | import math 9 | for x in range(2, int(math.sqrt(A))+ 1): 10 | y = 2 11 | p = pow(x, y) 12 | while p <= A: 13 | if p == A: 14 | return True 15 | y += 1 16 | p = pow(x,y) 17 | 18 | return False 19 | -------------------------------------------------------------------------------- /Strings/Palindrome.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : string 3 | # @return an integer 4 | def isPalindrome(self, A): 5 | s = [] 6 | 7 | for c in A: 8 | if 'A' <= c <= 'Z' or 'a' <= c <= 'z' or '0' <= c <= '9': 9 | s.append(c) 10 | 11 | s = ''.join(s) 12 | 13 | #print s.lower(), s[::-1].lower() 14 | if s.lower() == s[::-1].lower(): 15 | return True 16 | else: 17 | return False 18 | 19 | -------------------------------------------------------------------------------- /Two pointers/SortColor.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : list of integers 3 | # @return A after the sort 4 | def sortColors(self, A): 5 | l = len(A) 6 | zero_count = 0 7 | one_count = 0 8 | 9 | for i in range(l): 10 | if A[i] == 0: 11 | zero_count += 1 12 | elif A[i] == 1: 13 | one_count += 1 14 | 15 | 16 | return [0]*zero_count + [1] * one_count + [2]*(l-zero_count - one_count) 17 | 18 | -------------------------------------------------------------------------------- /Dynamic Programming/Stocks2.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : tuple of integers 3 | # @return an integer 4 | def maxProfit(self, A): 5 | if len(A) < 1: return 0 6 | mProfit = 0 7 | totalProfit = 0 8 | for i in range(1,len(A)): 9 | if A[i] > A[i-1]: 10 | mProfit += A[i] - A[i-1] 11 | else: 12 | totalProfit += mProfit 13 | mProfit = 0 14 | totalProfit += mProfit 15 | return totalProfit 16 | 17 | -------------------------------------------------------------------------------- /Greedy/Mice.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : list of integers 3 | # @param B : list of integers 4 | # @return an integer 5 | def mice(self, A, B): 6 | A = sorted(A) 7 | #print A 8 | B = sorted(B) 9 | #print B 10 | import sys 11 | 12 | maxdiff = -sys.maxint - 1 13 | 14 | for i in range(len(A)): 15 | maxdiff = max( maxdiff, abs(A[i] -B[i]) ) 16 | 17 | return maxdiff 18 | 19 | 20 | -------------------------------------------------------------------------------- /Binary Search/Pow.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param x : integer 3 | # @param n : integer 4 | # @param d : integer 5 | # @return an integer 6 | def pow(self, x, n, d): 7 | 8 | result = 1 9 | base = x % d 10 | while n > 0: 11 | if n % 2 == 1: 12 | result = (result*base) % d 13 | n = n >> 1 14 | base = (base*base)%d 15 | return result%d 16 | 17 | 18 | 19 | 20 | 21 | 22 | -------------------------------------------------------------------------------- /Hashing/Colorful.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : integer 3 | # @return an integer 4 | def colorful(self, A): 5 | s = str(A) 6 | d = set() 7 | for i in range(len(s)): 8 | for j in range(i+1, len(s)+1): 9 | x = reduce(lambda x,y : x*y, map(int, s[i:j])) 10 | if x in d: 11 | return False 12 | else: 13 | d.add(x) 14 | 15 | return True 16 | 17 | 18 | -------------------------------------------------------------------------------- /Math/Paths.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : integer 3 | # @param B : integer 4 | # @return an integer 5 | def uniquePaths(self, A, B): 6 | if A== 1 or B== 1: return 1 7 | 8 | fact_A = 1 9 | fact_B = 1 10 | fact_A_B = 1 11 | for i in range(1,A+B-1): 12 | fact_A_B *= i 13 | if i < B: 14 | fact_B *= i 15 | if i < A: 16 | fact_A *= i 17 | 18 | return fact_A_B/(fact_B*fact_A) 19 | 20 | -------------------------------------------------------------------------------- /Math/PrimeSum.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : integer 3 | # @return a list of integers 4 | def primesum(self, A): 5 | prime = set(range(1,A+1)) 6 | for i in range(2,len(prime)): 7 | if prime[i] == True: 8 | j = 2 9 | while j*i <= A: 10 | prime[j*i] = False 11 | j += 1 12 | 13 | for i in range(2,A): 14 | if prime[i] and prime[A-i]: 15 | return (i, A-i) 16 | 17 | 18 | -------------------------------------------------------------------------------- /Stacks and Queues/Nearest.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param arr : list of integers 3 | # @return a list of integers 4 | def prevSmaller(self, arr): 5 | if not arr : return None 6 | st = [] 7 | res = [] 8 | for a in arr: 9 | while st and st[-1] >= a: 10 | st.pop() 11 | if not st: 12 | res.append(-1) 13 | else: 14 | res.append(st[-1]) 15 | st.append(a) 16 | 17 | return res 18 | 19 | -------------------------------------------------------------------------------- /Two pointers/RemElem.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : list of integers 3 | # @param B : integer 4 | # @return an integer 5 | def removeElement(self, A, B): 6 | n = len(A) 7 | 8 | count = 0 9 | 10 | for i in range(n): 11 | if A[i] == B: 12 | continue 13 | else: 14 | A[count] = A[i] 15 | count += 1 16 | 17 | #A[:] = filter(lambda x: x != B, A) 18 | 19 | return count 20 | 21 | 22 | -------------------------------------------------------------------------------- /Dynamic Programming/MaxProd.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : tuple of integers 3 | # @return an integer 4 | def maxProduct(self, A): 5 | if not A: 6 | return 0 7 | premax, premin = A[0], A[0] 8 | res = A[0] 9 | for n in A[1:]: 10 | minhere = min(premax*n, premin*n, n) 11 | maxhere = max(premin*n, premax*n, n) 12 | res = max(minhere, maxhere,res) 13 | premin = minhere 14 | premax = maxhere 15 | 16 | return res 17 | 18 | -------------------------------------------------------------------------------- /Math/Rank.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : string 3 | # @return an integer 4 | def findRank(self, A): 5 | s = sorted(list(A)) 6 | f = 1 7 | rank = 1 8 | length = len(A) 9 | 10 | for i in range(len(A)): 11 | length -= 1 12 | n = s.index(A[i]) 13 | s.remove(A[i]) 14 | f = 1 15 | for j in range(length): 16 | f *= (j + 1) 17 | rank += (n * (f)) % 1000003 18 | 19 | return rank % 1000003 20 | 21 | -------------------------------------------------------------------------------- /Greedy/Majority.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : tuple of integers 3 | # @return an integer 4 | def majorityElement(self, A): 5 | if len(A) == 1: return A[0] 6 | count = 1 7 | majority_index = 0 8 | for i in range(1,len(A)): 9 | if A[majority_index] != A[i]: 10 | count -= 1 11 | if count < 1: 12 | majority_index = i 13 | count = 1 14 | else: 15 | count += 1 16 | return A[majority_index] 17 | 18 | -------------------------------------------------------------------------------- /Strings/LCP.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : list of strings 3 | # @return a strings 4 | def longestCommonPrefix(self, A): 5 | res = "" 6 | min_length = min(map(len,A)) 7 | #print min_length 8 | 9 | for i in range(min_length): 10 | curr = "" 11 | for s in A: 12 | if curr and curr != s[i]: 13 | return res 14 | else: 15 | curr = s[i] 16 | res += curr 17 | 18 | return res 19 | 20 | -------------------------------------------------------------------------------- /Greedy/Bulbs.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : list of integers 3 | # @return an integer 4 | def bulbs(self, A): 5 | count = 0 6 | 7 | for i in range(len(A)): 8 | if count % 2== 0 and A[i] == 0: 9 | count += 1 10 | elif count % 2 == 0 and A[i] == 1: 11 | pass 12 | elif count % 2 == 1 and A[i] == 0: 13 | pass 14 | elif count % 2 == 1 and A[i] == 1: 15 | count += 1 16 | 17 | return count 18 | 19 | -------------------------------------------------------------------------------- /Arrays/Pascal1.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : integer 3 | # @return a list of list of integers 4 | def generate(self, A): 5 | if A == 0: return [] 6 | 7 | pascal = [[1] for i in range(A)] 8 | 9 | for i in range(1,A): 10 | prev_row = pascal[i-1] 11 | for j in range(1,len(prev_row)+1): 12 | ele = pascal[i-1][j] + pascal[i-1][j-1] if j > 0 and j >= 1 16 | s += 2*abs((m - n) * n) 17 | s %= (pow(10,9) + 7) 18 | k += 1 19 | 20 | return s 21 | 22 | -------------------------------------------------------------------------------- /Two pointers/Merge.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : list of integers 3 | # @param B : list of integers 4 | # @return A modified after the merge 5 | def merge(self, A, B): 6 | i = 0 7 | j = 0 8 | 9 | while i < len(A) and j < len(B): 10 | if A[i] < B[j]: 11 | i += 1 12 | else: 13 | A.insert(i, B[j]) 14 | j += 1 15 | i += 1 16 | 17 | 18 | if j < len(B): 19 | A += B[j:] 20 | 21 | return A 22 | 23 | -------------------------------------------------------------------------------- /Arrays/RepeatArr.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : tuple of integers 3 | # @return an integer 4 | def repeatedNumber(self, A): 5 | from collections import defaultdict 6 | from math import sqrt 7 | d = defaultdict(int) 8 | c = set() 9 | 10 | for i in A: 11 | d[int(sqrt(i))] += 1 12 | 13 | for i in A: 14 | if d[int(sqrt(i))] > 1: 15 | if i not in c: 16 | c.add(i) 17 | else: 18 | return i 19 | 20 | -------------------------------------------------------------------------------- /Dynamic Programming/MinPath.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : list of list of integers 3 | # @return an integer 4 | def minPathSum(self, A): 5 | if not A: return 0 6 | m = len(A) 7 | n = len(A[0]) 8 | import sys 9 | cost = [ [sys.maxint]* (n+1) for i in range(m+1) ] 10 | cost[0][1] = 0 11 | cost[1][0] = 0 12 | for i in range(m): 13 | for j in range(n): 14 | cost[i+1][j+1] = A[i][j] + min(cost[i][j+1], cost[i+1][j]) 15 | 16 | return cost[-1][-1] 17 | 18 | -------------------------------------------------------------------------------- /Graphs/Fibsum.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : integer 3 | # @return an integer 4 | def fibsum(self, A): 5 | fibs = [1, 1] 6 | while True: 7 | res = fibs[-1] + fibs[-2] 8 | if res > A: 9 | break 10 | else: 11 | fibs.append(res) 12 | count = 0 13 | i = 0 14 | while A > 0: 15 | num = fibs[~i] 16 | if A >= num: 17 | count += A/num 18 | A %= num 19 | i += 1 20 | 21 | return count 22 | 23 | -------------------------------------------------------------------------------- /Trees/SameTree.py: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node 2 | # class TreeNode: 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.left = None 6 | # self.right = None 7 | 8 | class Solution: 9 | # @param A : root node of tree 10 | # @param B : root node of tree 11 | # @return an integer 12 | def isSameTree(self, A, B): 13 | if A == None and B == None: return True 14 | elif A == None or B == None: return False 15 | return A.val == B.val and self.isSameTree(A.left, B.left) and self.isSameTree(A.right, B.right) 16 | 17 | -------------------------------------------------------------------------------- /Arrays/Pascal2.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : integer 3 | # @return a list of integers 4 | def getRow(self, A): 5 | if A == 0: return [1] 6 | pascal = [[0] * (A+1) for i in range(2)] 7 | pascal[0][0] = 1 8 | 9 | for i in range(1,A+1): 10 | for j in range(i+1): 11 | if j == 0: 12 | pascal[1][j] = 1 13 | else: 14 | pascal[1][j] = pascal[0][j-1] + pascal[0][j] 15 | 16 | pascal[0] = pascal[1][:] 17 | 18 | return pascal[1] 19 | 20 | -------------------------------------------------------------------------------- /Hashing/LSZero.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : list of integers 3 | # @return a list of integers 4 | def lszero(self, A): 5 | d= {0:-1} 6 | s = 0 7 | l = -1 8 | r = -1 9 | for i,n in enumerate(A): 10 | s += n 11 | if s in d: 12 | if i - d[s] > r - l - 1: 13 | l = d[s] 14 | r = i+1 15 | else: 16 | d[s] = i 17 | 18 | if r == -1: 19 | return [] 20 | 21 | return A[l+1:r] 22 | 23 | 24 | 25 | -------------------------------------------------------------------------------- /Strings/Multiply.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : string 3 | # @param B : string 4 | # @return a strings 5 | def multiply(self, A, B): 6 | num1 = A 7 | num2 = B 8 | 9 | res = [0]* (len(num1) + len(num2)) 10 | for i, e1 in enumerate(reversed(num1)): 11 | for j, e2 in enumerate(reversed(num2)): 12 | res[i+j] += int(e1) * int(e2) 13 | res[i+j+1] += res[i+j]/10 14 | res[i+j] %= 10 15 | 16 | while len(res) > 1 and res[-1] == 0: res.pop() 17 | 18 | return ''.join( map(str,res[::-1]) ) 19 | 20 | -------------------------------------------------------------------------------- /Graphs/Surrounding.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : list of list of chars 3 | def solve(self, board): 4 | if not board: return 5 | m = len(board) 6 | n = len(board[0]) 7 | 8 | stack = [ij for k in range(m+n) for ij in ((0,k),(m-1,k),(k,0),(k,n-1))] 9 | while stack: 10 | x, y = stack.pop() 11 | if 0 <= x < m and 0 <= y < n and board[x][y] == 'O': 12 | stack += [(x,y-1),(x,y+1),(x-1,y),(x+1,y)] 13 | board[x][y] = "S" 14 | 15 | board[:] = [["XO"[c=="S"] for c in row] for row in board ] 16 | 17 | 18 | -------------------------------------------------------------------------------- /Strings/ZigZag.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : string 3 | # @param B : integer 4 | # @return a strings 5 | def convert(self, A, B): 6 | s = "" 7 | if B == 1: return A 8 | for i in range(B): 9 | step_size = 2*(B-1) 10 | j = i 11 | nex = 2 * i 12 | while j < len(A): 13 | s += A[j] 14 | nex = abs(step_size - nex) 15 | if nex !=0 : 16 | j += nex 17 | else: 18 | nex = abs(step_size - nex) 19 | j += nex 20 | return s 21 | -------------------------------------------------------------------------------- /Hashing/2Sum.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : tuple of integers 3 | # @param B : integer 4 | # @return a list of integers 5 | def twoSum(self, nums, target): 6 | d = {} 7 | 8 | for i in range(len(nums)): 9 | if nums[i] not in d: 10 | if target - nums[i] not in d: 11 | d[nums[i]] = i + 1 12 | else: 13 | return [d[target - nums[i]] , i + 1] 14 | else: 15 | if target - nums[i] in d: 16 | return [d[target - nums[i]] , i + 1] 17 | 18 | return [] 19 | -------------------------------------------------------------------------------- /Graphs/Black.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : list of strings 3 | # @return an integer 4 | def black(self, grid): 5 | if not grid: 6 | return 0 7 | visited = [[False]*len(grid[0]) for _ in xrange(len(grid))] 8 | def sink(i,j): 9 | if 0 <= i < len(grid) and 0 <= j < len(grid[0]) and grid[i][j] == 'X' and not visited[i][j]: 10 | visited[i][j] = True 11 | map(sink, (i-1, i+1, i, i), (j, j, j - 1, j+1)) 12 | return 1 13 | return 0 14 | 15 | return sum(sink(i,j) for i in range(len(grid)) for j in range(len(grid[i]))) 16 | 17 | -------------------------------------------------------------------------------- /Greedy/Gas.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param gas : tuple of integers 3 | # @param cost : tuple of integers 4 | # @return an integer 5 | def canCompleteCircuit(self, gas, cost): 6 | if sum(gas) < sum(cost): 7 | return -1 8 | 9 | cost_sum = 0 10 | gas_sum = 0 11 | min_index = -1 12 | for i in range(len(gas)-1, -1, -1): 13 | cost_sum += cost[i] 14 | gas_sum += gas[i] 15 | if cost_sum <= gas_sum: 16 | min_index = i 17 | cost_sum = 0 18 | gas_sum = 0 19 | 20 | return min_index 21 | 22 | -------------------------------------------------------------------------------- /Two pointers/Diffk.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : list of integers 3 | # @param B : integer 4 | # @return an integer 5 | def diffPossible(self, A, B): 6 | if len(A) < 2: 7 | return False 8 | 9 | i = 0 10 | j = 1 11 | 12 | while i < len(A) and j < len(A): 13 | if A[j] - A[i] < B: 14 | j += 1 15 | elif A[j] - A[i] > B: 16 | i += 1 17 | else: 18 | if j!= i: 19 | return True 20 | else: 21 | j += 1 22 | 23 | return False 24 | 25 | -------------------------------------------------------------------------------- /Two pointers/IntersectArr.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : tuple of integers 3 | # @param B : tuple of integers 4 | # @return a list of integers 5 | def intersect(self, A, B): 6 | inter = [] 7 | j = 0 8 | i= 0 9 | while i < len(A) and j < len(B): 10 | if A[i] == B[j]: 11 | inter.append(A[i]) 12 | i += 1 13 | j += 1 14 | 15 | elif A[i] < B[j]: 16 | i += 1 17 | 18 | elif A[i] > B[j]: 19 | j += 1 20 | 21 | 22 | return inter 23 | 24 | 25 | -------------------------------------------------------------------------------- /Trees/ArrayBST.py: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node 2 | # class TreeNode: 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.left = None 6 | # self.right = None 7 | 8 | class Solution: 9 | # @param A : tuple of integers 10 | # @return the root node in the tree 11 | def sortedArrayToBST(self, A): 12 | if len(A) == 0: return None 13 | if len(A) == 1: return TreeNode(A[0]) 14 | mid = len(A)/2 15 | root = TreeNode(A[mid]) 16 | root.left = self.sortedArrayToBST(A[:mid]) 17 | root.right = self.sortedArrayToBST(A[mid+1:]) 18 | return root 19 | 20 | 21 | -------------------------------------------------------------------------------- /Trees/Preorder.py: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node 2 | # class TreeNode: 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.left = None 6 | # self.right = None 7 | 8 | class Solution: 9 | # @param A : root node of tree 10 | # @return a list of integers 11 | def preorderTraversal(self, A): 12 | l = [] 13 | st = [] 14 | st.append(A) 15 | while st: 16 | u = st[-1] 17 | l.append(u.val) 18 | st = st[:-1] 19 | if u.right: st.append(u.right) 20 | if u.left: st.append(u.left) 21 | 22 | 23 | return l 24 | 25 | -------------------------------------------------------------------------------- /Arrays/Narray.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : tuple of integers 3 | # @return a list of integers 4 | def repeatedNumber(self, A): 5 | length = len(A) 6 | SigmaN = length*(length+1)/2 7 | SigmaNsquare = length * (length+1) * (2*length +1)/6 8 | AminusB = sum(A) - SigmaN 9 | square_sum = 0 10 | 11 | for i in range(len(A)): 12 | square_sum += A[i]*A[i] 13 | 14 | SquareMinus = square_sum - SigmaNsquare 15 | 16 | AplusB = SquareMinus/AminusB 17 | 18 | return [(AplusB+AminusB)/2, (AplusB-AminusB)/2] 19 | 20 | 21 | 22 | 23 | -------------------------------------------------------------------------------- /Hashing/RepeatStr.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : string 3 | # @return an integer 4 | def lengthOfLongestSubstring(self, s): 5 | if len(s) < 2: 6 | return len(s) 7 | else: 8 | n, d = len(s), {} 9 | d[s[0]] = 0 10 | p1 = 0 11 | p2 = 1 12 | max_length = 1 13 | while p2 < n: 14 | if s[p2] in d and p1 <= d[s[p2]]: 15 | p1 = d[s[p2]] + 1 16 | else: 17 | max_length = max(p2 - p1+1, max_length) 18 | d[s[p2]] = p2 19 | p2 += 1 20 | return max_length 21 | 22 | -------------------------------------------------------------------------------- /Trees/Invert.py: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node 2 | # class TreeNode: 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.left = None 6 | # self.right = None 7 | 8 | class Solution: 9 | # @param root : root node of tree 10 | # @return the root node in the tree 11 | def invertTree(self, root): 12 | if root == None: return None 13 | elif root.left == None and root.right == None: return root 14 | else: 15 | root.left , root.right = root.right, root.left 16 | self.invertTree(root.left) 17 | self.invertTree(root.right) 18 | 19 | return root 20 | 21 | -------------------------------------------------------------------------------- /Arrays/reach.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param X : list of integers 3 | # @param Y : list of integers 4 | # Points are represented by (X[i], Y[i]) 5 | # @return an integer 6 | def coverPoints(self, X, Y): 7 | minDist = 0 8 | if not X and not Y: return 0 9 | 10 | if len(X) == 1: return 0 11 | 12 | for i in range(1,len(X)): 13 | nearest_diagnol_end = min(abs(X[i] - X[i-1]), abs(Y[i] - Y[i-1])) 14 | minDist += nearest_diagnol_end + abs(abs(X[i] - X[i-1]) - nearest_diagnol_end) + abs(abs(Y[i] - Y[i-1]) - nearest_diagnol_end) 15 | 16 | 17 | return minDist 18 | 19 | -------------------------------------------------------------------------------- /Dynamic Programming/AnyTwo.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : string 3 | # @return an integer 4 | def anytwo(self, A): 5 | dp = [[0] * (len(A)+1) for _ in range(len(A)+1) ] 6 | for i in range(len(A)): 7 | for j in range(len(A)): 8 | if i == j: 9 | dp[i][j] = max(dp[i-1][j] ,dp[i][j-1]) 10 | else: 11 | if A[i] == A[j]: 12 | dp[i][j] = dp[i-1][j-1] + 1 13 | else: 14 | dp[i][j] = max(dp[i-1][j] ,dp[i][j-1]) 15 | if dp[i][j] >= 2: 16 | return 1 17 | return 0 18 | 19 | -------------------------------------------------------------------------------- /Trees/Symmetry.py: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node 2 | # class TreeNode: 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.left = None 6 | # self.right = None 7 | 8 | class Solution: 9 | # @param A : root node of tree 10 | # @return an integer 11 | def isSymmetric(self, A): 12 | if A == None: return True 13 | return self.isSame(A.left, A.right) 14 | 15 | def isSame(self, A, B): 16 | if A == None and B == None: return True 17 | elif A == None or B == None: return False 18 | return A.val == B.val and self.isSame(A.left, B.right) and self.isSame(A.right, B.left) 19 | 20 | 21 | -------------------------------------------------------------------------------- /Dynamic Programming/Jump1.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : list of integers 3 | # @return an integer 4 | def canJump(self, A): 5 | if len(A) == 1: return 1 6 | i = len(A) - 1 7 | while i >= 0: 8 | reachable = False 9 | dist = 1 10 | j = i - 1 11 | while j >= 0 and not reachable: 12 | if A[j] >= dist: 13 | reachable = True 14 | else: 15 | j -= 1 16 | dist += 1 17 | if i == 0: return 1 18 | if not reachable: return 0 19 | else: 20 | i = j 21 | return 0 22 | -------------------------------------------------------------------------------- /Linked Lists/RemDupLink.py: -------------------------------------------------------------------------------- 1 | # Definition for singly-linked list. 2 | # class ListNode: 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.next = None 6 | 7 | class Solution: 8 | # @param A : head node of linked list 9 | # @return the head node in the linked list 10 | def deleteDuplicates(self, A): 11 | curr = A 12 | while curr: 13 | if curr.next: 14 | if curr.val == curr.next.val: 15 | curr.next = curr.next.next 16 | else: 17 | curr = curr.next 18 | else: 19 | curr = curr.next 20 | 21 | return A 22 | 23 | -------------------------------------------------------------------------------- /Arrays/Positive.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : list of integers 3 | # @return an integer 4 | def firstMissingPositive(self, A): 5 | curr = 0 6 | p = 0 7 | 8 | while curr < len(A): 9 | if 0 < A[curr] <= len(A): 10 | pos = A[curr] - 1 11 | while 0 <= pos < len(A) and A[pos] != pos + 1: 12 | k = pos 13 | pos = A[pos] - 1 14 | A[k] = k + 1 15 | curr += 1 16 | 17 | for i in range(len(A)): 18 | if A[i] != i + 1: 19 | return i + 1 20 | 21 | return len(A) + 1 22 | 23 | -------------------------------------------------------------------------------- /Backtracking/LetterPhone.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : string 3 | # @return a list of strings 4 | def letterCombinations(self, digits): 5 | if not digits: 6 | return [] 7 | 8 | #print digits 9 | 10 | phone = {1: ["1"], 2: ["a", "b", "c"], 3: ["d","e","f"], 4: ["g","h","i"], 5:["j","k","l"], 6: ["m","n","o"], 7: ["p","q","r","s"], 8: ["t","u","v"], 9: ["w","x","y","z"], 0: ["0"]} 11 | 12 | all_combs = [] 13 | for letter in phone[int(digits[0])]: 14 | for comb in self.letterCombinations(digits[1:]) or [""]: 15 | all_combs.append(letter+comb) 16 | return all_combs 17 | 18 | -------------------------------------------------------------------------------- /Trees/MaxDepth.py: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node 2 | # class TreeNode: 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.left = None 6 | # self.right = None 7 | 8 | class Solution: 9 | # @param A : root node of tree 10 | # @return an integer 11 | def maxDepth(self, A): 12 | count = 0 13 | return self.maxDepthHelper(A, count) 14 | 15 | def maxDepthHelper(self, A, count): 16 | count += 1 17 | l = count 18 | r = count 19 | if A.left: l = self.maxDepthHelper(A.left, count) 20 | if A.right: r = self.maxDepthHelper(A.right, count) 21 | 22 | return max(l,r) 23 | 24 | 25 | -------------------------------------------------------------------------------- /Dynamic Programming/EditDistance.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : string 3 | # @param B : string 4 | # @return an integer 5 | def minDistance(self, A, B): 6 | edit = [[0]* (len(B) + 1) for i in range(len(A) + 1)] 7 | for i in range(len(A)+1): 8 | for j in range(len(B)+1): 9 | if i == 0: 10 | edit[i][j] = j 11 | elif j == 0: 12 | edit[i][j] = i 13 | elif A[i-1] == B[j-1]: 14 | edit[i][j] = edit[i-1][j-1] 15 | else: 16 | edit[i][j] = 1 + min(edit[i-1][j-1], edit[i-1][j] , edit[i][j-1]) 17 | return edit[-1][-1] 18 | 19 | -------------------------------------------------------------------------------- /Trees/Cartesian.py: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node 2 | # class TreeNode: 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.left = None 6 | # self.right = None 7 | 8 | class Solution: 9 | # @param A : list of integers 10 | # @return the root node in the tree 11 | def buildTree(self, A): 12 | if not A: 13 | return None 14 | 15 | else: 16 | max_val= max(A) 17 | max_idx = A.index(max_val) 18 | root = TreeNode(max_val) 19 | root.left = self.buildTree(A[:max_idx]) 20 | root.right = self.buildTree(A[max_idx+1:]) 21 | 22 | return root 23 | 24 | -------------------------------------------------------------------------------- /Arrays/Setzero.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : list of list of integers 3 | # @return the same list modified 4 | def setZeroes(self, A): 5 | m = len(A) 6 | n = len(A[0]) 7 | row= [1]*m 8 | col= [1]*n 9 | for i in range(m): 10 | for j in range(n): 11 | if(A[i][j]==0): 12 | row[i]=0 13 | col[j]=0 14 | 15 | 16 | for i in range(m): 17 | if(row[i]==0): 18 | A[i]= [0]*n 19 | for j in range(n): 20 | if(col[j]==0): 21 | for i in range(m): 22 | A[i][j]=0 23 | return A 24 | 25 | -------------------------------------------------------------------------------- /Hashing/Equal.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : list of integers 3 | # @return a list of integers 4 | def equal(self, A): 5 | n = len(A) 6 | d = {} 7 | res = [] 8 | for i in range(n-1): 9 | for j in range(i+1, n): 10 | s = A[i] + A[j] 11 | if s not in d: 12 | d[s] = (i,j) 13 | else: 14 | if d[s][0] == i or d[s][1] == j or d[s][1] == i or d[s][0] == j: 15 | continue 16 | else: 17 | res.append(list(d[s]) + [i,j]) 18 | 19 | return sorted(res)[0] if res else res 20 | 21 | 22 | -------------------------------------------------------------------------------- /Dynamic Programming/Jump2.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : list of integers 3 | # @return an integer 4 | def jump(self, A): 5 | nums = A 6 | i = 0 7 | jumps = 0 8 | last_max_reachable_index = 0 9 | current_max_reachable_index = 0 10 | while last_max_reachable_index < len(nums)-1: 11 | while i <= last_max_reachable_index: 12 | current_max_reachable_index = max(i + nums[i], current_max_reachable_index) 13 | i += 1 14 | if last_max_reachable_index == current_max_reachable_index: return -1 15 | last_max_reachable_index = current_max_reachable_index 16 | jumps += 1 17 | return jumps 18 | -------------------------------------------------------------------------------- /Hashing/WindowStr.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param S : string 3 | # @param T : string 4 | # @return a string 5 | def minWindow(self, S, T): 6 | import collections 7 | need, missing = collections.Counter(T), len(T) 8 | 9 | I = J = i = 0 10 | 11 | for j, c in enumerate(S,1): 12 | missing -= need[c] > 0 13 | need[c] -= 1 14 | 15 | if not missing: 16 | while i < j and need[S[i]] < 0: 17 | need[S[i]] += 1 18 | i += 1 19 | if not J or j -i < J - I: 20 | J, I = j, i 21 | 22 | 23 | return S[I:J] 24 | 25 | 26 | -------------------------------------------------------------------------------- /Arrays/Interval2.py: -------------------------------------------------------------------------------- 1 | # Definition for an interval. 2 | # class Interval: 3 | # def __init__(self, s=0, e=0): 4 | # self.start = s 5 | # self.end = e 6 | 7 | class Solution: 8 | # @param intervals, a list of Intervals 9 | # @return a list of Interval 10 | def merge(self, intervals): 11 | merged_interval = [] 12 | 13 | for interval in sorted(intervals, key = lambda i: i.start): 14 | if merged_interval != [] and merged_interval[-1].end >= interval.start: 15 | merged_interval[-1].end = max(merged_interval[-1].end, interval.end) 16 | else: 17 | merged_interval += interval, 18 | 19 | 20 | return merged_interval 21 | 22 | -------------------------------------------------------------------------------- /Backtracking/Subset2.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : list of integers 3 | # @return a list of list of integers 4 | def subsetsWithDup(self, nums): 5 | if not nums: 6 | return [[]] 7 | return sorted(self.subsetHelper(sorted(nums))) 8 | 9 | def subsetHelper(self, nums): 10 | if not nums: 11 | return [] 12 | 13 | res = [] 14 | i = 0 15 | while i < len(nums) and nums[i] == nums[0]: 16 | i += 1 17 | 18 | for subset in self.subsetHelper(nums[i:]) or [[]]: 19 | for j in range(i+1): 20 | res += [[nums[0]]*(j) + subset] 21 | #res += self.subsetHelper(nums[i:]) 22 | return res 23 | 24 | -------------------------------------------------------------------------------- /Hashing/CopyList.py: -------------------------------------------------------------------------------- 1 | # Definition for singly-linked list with a random pointer. 2 | # class RandomListNode: 3 | # def __init__(self, x): 4 | # self.label = x 5 | # self.next = None 6 | # self.random = None 7 | 8 | class Solution: 9 | # @param head, a RandomListNode 10 | # @return a RandomListNode 11 | def copyRandomList(self, head): 12 | from collections import defaultdict 13 | d = defaultdict(lambda: RandomListNode(0)) 14 | d[None] = None 15 | m = head 16 | 17 | while m: 18 | d[m].label = m.label 19 | d[m].next = d[m.next] 20 | d[m].random = d[m.random] 21 | m = m.next 22 | 23 | return d[head] 24 | 25 | -------------------------------------------------------------------------------- /Binary Search/Search2D.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : list of list of integers 3 | # @param B : integer 4 | # @return an integer 5 | def searchMatrix(self, A, B): 6 | 7 | start = 0 8 | end = (len(A) * len(A[0])) -1 9 | 10 | m = len(A) 11 | n = len(A[0]) 12 | 13 | while start < end: 14 | mid = (start + end) / 2 15 | mid_i = mid / n 16 | mid_j = mid % n 17 | if A[mid_i][mid_j] < B: 18 | start = mid + 1 19 | elif A[mid_i][mid_j] > B: 20 | end = mid 21 | else: 22 | return 1 23 | 24 | return 1 if A[-1][-1] == B else 0 25 | 26 | 27 | -------------------------------------------------------------------------------- /Binary Search/Books.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : list of integers 3 | # @param B : integer 4 | # @return an integer 5 | def books(self, A, B): 6 | lo = max(A) 7 | hi = sum(A) 8 | 9 | if B > len(A): return -1 10 | 11 | while lo < hi: 12 | mid = (lo + hi) / 2 13 | requiredStudents = getRequiredStudents(mid, A) 14 | if requiredStudents <= B: 15 | hi = mid 16 | else: 17 | lo = mid + 1 18 | return lo 19 | 20 | def getRequiredStudents(mid, C): 21 | num = 1 22 | s = 0 23 | for i in C: 24 | s += i 25 | if s > mid: 26 | num += 1 27 | s = i 28 | return num 29 | 30 | -------------------------------------------------------------------------------- /Stacks and Queues/Braces.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : string 3 | # @return an integer 4 | def braces(self, A): 5 | st = [] 6 | if not A: 7 | return 0 8 | for a in A: 9 | if not st or a != ")": 10 | st.append(a) 11 | else: 12 | encountered_operator = False 13 | while st and st[-1] != "(": 14 | if st[-1] in "+-*/": 15 | encountered_operator = True 16 | st.pop() 17 | 18 | if not encountered_operator: 19 | return 1 20 | if st: 21 | st.pop() 22 | 23 | return 0 24 | 25 | -------------------------------------------------------------------------------- /Two pointers/MaxOne.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : list of integers 3 | # @param B : integer 4 | # @return a list of integers 5 | def maxone(self, A, B): 6 | nZero = 0 7 | l, r = 0, 0 8 | maxLen = -1 9 | while r < len(A): 10 | if nZero <= B: 11 | if A[r] == 0: 12 | nZero += 1 13 | r += 1 14 | if nZero > B: 15 | if A[l] == 0: 16 | nZero -= 1 17 | l += 1 18 | 19 | if maxLen < r - l + 1: 20 | start = l 21 | end = r 22 | maxLen = r - l + 1 23 | 24 | 25 | return range(start, end) 26 | 27 | 28 | -------------------------------------------------------------------------------- /Two pointers/Container.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : list of integers 3 | # @return an integer 4 | def maxArea(self, A): 5 | if len(A) < 2: return 0 6 | i = 0 7 | area = 0 8 | maxContainer = 0 9 | while i < len(A) - 1: 10 | j = len(A) - 1 11 | area = 0 12 | while i < j: 13 | if A[j] < A[i]: 14 | area = max(area, (j-i)*A[j]) 15 | j -= 1 16 | else: 17 | area = max(area, (j-i) * A[i]) 18 | break 19 | 20 | maxContainer = max(maxContainer, area) 21 | i += 1 22 | 23 | 24 | return maxContainer 25 | 26 | -------------------------------------------------------------------------------- /Trees/KthSmallest2.py: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node 2 | # class TreeNode: 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.left = None 6 | # self.right = None 7 | 8 | class Solution: 9 | # @param root : root node of tree 10 | # @param k : integer 11 | # @return an integer 12 | def kthsmallest(self, root, k): 13 | for val in self.inorder(root): 14 | if k == 1: 15 | return val 16 | else: 17 | k -= 1 18 | def inorder(self, root): 19 | if root: 20 | for val in self.inorder(root.left): 21 | yield val 22 | yield root.val 23 | for val in self.inorder(root.right): 24 | yield val 25 | 26 | -------------------------------------------------------------------------------- /Binary Search/InsertPos.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : list of integers 3 | # @param B : integer 4 | # @return an integer 5 | def searchInsert(self, A, B): 6 | 7 | if len(A) == 1: 8 | return 1 if A[0] < B else 0 9 | 10 | if not A: 11 | return 0 12 | 13 | start = 0 14 | end = len(A) - 1 15 | 16 | while start < end: 17 | mid = (start + end) /2 18 | 19 | if A[mid] < B: 20 | start = mid + 1 21 | #print start 22 | elif A[mid] > B: 23 | end = mid 24 | else: 25 | return mid 26 | 27 | return start + 1 if start == len(A) - 1 else start 28 | 29 | -------------------------------------------------------------------------------- /Hashing/Anagrams.py: -------------------------------------------------------------------------------- 1 | # Code is correct but Interviewbit Judge has some problem 2 | # in case of this problem 3 | 4 | class Solution: 5 | # @param A : tuple of strings 6 | # @return a list of list of integers 7 | def anagrams(self, A): 8 | if A == None: return A 9 | d = {} 10 | list_of_groups = [] 11 | group_number = 0 12 | for i in xrange(len(A)): 13 | sorted_A_i = ''.join(sorted(A[i])) 14 | if sorted_A_i not in d: 15 | list_of_groups.append([i+1]) 16 | d[sorted_A_i] = group_number 17 | group_number += 1 18 | else: 19 | list_of_groups[d[sorted_A_i]].append(i+1) 20 | 21 | return list_of_groups 22 | 23 | 24 | 25 | -------------------------------------------------------------------------------- /Dynamic Programming/Palin2.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : string 3 | # @return an integer 4 | def minCut(self, A): 5 | breaks = [i for i in range(-1,len(A))] 6 | 7 | for i in range(len(A)): 8 | r1 , r2 = 0, 0 9 | 10 | #odd length 11 | while i -r1 >= 0 and i + r1 < len(A) and A[i-r1] == A[i + r1]: 12 | breaks[i + r1 + 1] = min(breaks[i + r1 + 1], breaks[i-r1] + 1) 13 | r1 += 1 14 | 15 | #even length 16 | while i - r2 > 0 and i + r2 < len(A) and A[i -r2 -1] == A[i + r2]: 17 | breaks[i + r2 + 1] = min(breaks[i + r2 + 1], breaks[i-r2-1] + 1) 18 | r2 += 1 19 | 20 | return breaks[-1] 21 | 22 | -------------------------------------------------------------------------------- /Strings/Roman2Int.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : string 3 | # @return an integer 4 | def romanToInt(self, A): 5 | s = [] 6 | num = 0 7 | d = {'I': 1, 'V': 5, 'X': 10, 'L': 50, 'C': 100, 'D': 500, 'M': 1000} 8 | 9 | i = 1 10 | 11 | while i < len(A)+1: 12 | #print i 13 | num += d[A[-i]] 14 | if i < len(A) and ((A[-i-1] == 'I' and (A[-i] == 'V' or A[-i] == 'X')) 15 | or (A[-i-1] == 'X' and (A[-i] == 'L' or A[-i] == 'C')) 16 | or (A[-i-1] == 'C' and (A[-i] == 'D' or A[-i] == 'M'))): 17 | i += 1 18 | num -= d[A[-i]] 19 | #print num 20 | i += 1 21 | 22 | return num 23 | -------------------------------------------------------------------------------- /Backtracking/Combinations.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param n : integer 3 | # @param k : integer 4 | # @return a list of list of integers 5 | def combine(self, n, k): 6 | return self.comb_helper(1,n+1,k) 7 | 8 | def comb_helper(self,start, end, k): 9 | #print start, end , k 10 | if end - start == k: 11 | #print start, end , k 12 | return [range(start, start + k)] 13 | elif k == 0: 14 | return [[]] 15 | #return [range(start, end+1)] 16 | 17 | all_combs = [] 18 | 19 | for i in range(start, end+1 - k): 20 | for comb in self.comb_helper(i + 1, end, k - 1): 21 | all_combs.append([i]+comb) 22 | 23 | return all_combs 24 | 25 | -------------------------------------------------------------------------------- /Arrays/Hotel.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param arrive : list of integers 3 | # @param depart : list of integers 4 | # @param K : integer 5 | # @return a boolean 6 | def hotel(self, arrive, depart, K): 7 | if not K: return False 8 | arrive = zip(arrive, [1]*len(arrive)) 9 | depart = zip(depart, [-1]*len(arrive)) 10 | s = sorted(arrive + depart) 11 | 12 | if len(arrive) < 2: 13 | if K >= 1: 14 | return True 15 | else: 16 | return False 17 | 18 | i = 0 19 | overlaps = 0 20 | while i < len(s): 21 | overlaps += s[i][1] 22 | if overlaps > K: 23 | return False 24 | i += 1 25 | return True 26 | 27 | -------------------------------------------------------------------------------- /Arrays/Nextperm.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : list of integers 3 | # @return the same list of integer after modification 4 | def nextPermutation(self, A): 5 | is_sorted = True 6 | if len(A) <= 1: return A 7 | smallest = -1 8 | for i in range(len(A)-1, 0, -1): 9 | if A[i] > A[i-1]: 10 | j = i 11 | while j < len(A) and A[i-1] < A[j]: 12 | j += 1 13 | 14 | A[i-1], A[j-1] = A[j-1], A[i-1] 15 | 16 | A[i:] = sorted(A[i:]) 17 | is_sorted = False 18 | break 19 | else: 20 | smallest = i 21 | 22 | 23 | return sorted(A) if is_sorted == True else A 24 | 25 | -------------------------------------------------------------------------------- /Stacks and Queues/SimplifyPath.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : string 3 | # @return a strings 4 | def simplifyPath(self, A): 5 | st = [] 6 | new_A = A.split('/') 7 | 8 | new_A = filter(lambda x: x != '', new_A) 9 | 10 | 11 | i = 0 12 | while i < len(new_A): 13 | 14 | if new_A[i] == '.': 15 | pass 16 | 17 | elif new_A[i] == '..': 18 | st = st[:-1] 19 | else: 20 | st.append(new_A[i]) 21 | 22 | i += 1 23 | 24 | #print new_A 25 | 26 | #if len(new_A) == 1: 27 | # return '/'+st[0] 28 | #else: 29 | s = '/'.join(st) 30 | return '/' + s 31 | -------------------------------------------------------------------------------- /Arrays/Maxdist.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : tuple of integers 3 | # @return an integer 4 | def maximumGap(self, A): 5 | n = len(A) 6 | if len(A) == 1: return 0 7 | Lmin = [0]*n 8 | Rmax = [0]*n 9 | Lmin[0] = A[0] 10 | for i in range(1,n): 11 | Lmin[i] = min(Lmin[i-1],A[i]) 12 | Rmax[n-1] = A[n-1] 13 | for i in range(n-2,-1,-1): 14 | Rmax[i] = max(Rmax[i+1],A[i]) 15 | 16 | i = 0 17 | j = 0 18 | ret = -1 19 | if n == 1: 20 | return ret 21 | while i < n and j < n: 22 | if Lmin[i] <= Rmax[j]: 23 | ret = max(ret, j-i) 24 | j += 1 25 | else: 26 | i += 1 27 | return ret 28 | 29 | -------------------------------------------------------------------------------- /Binary Search/Paint.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : integer 3 | # @param B : integer 4 | # @param C : list of integers 5 | # @return an integer 6 | def paint(self, A, B, C): 7 | lo = max(C) 8 | hi = sum(C) 9 | 10 | while lo < hi: 11 | mid = (lo + hi) / 2 12 | requiredPainters = getRequiredPainters(mid, C) 13 | if requiredPainters <= A: 14 | hi = mid 15 | else: 16 | lo = mid + 1 17 | #print mid , requiredPainters 18 | return lo*B % 10000003 19 | 20 | def getRequiredPainters(mid, C): 21 | num = 1 22 | s = 0 23 | for i in C: 24 | s += i 25 | if s > mid: 26 | num += 1 27 | s = i 28 | return num 29 | 30 | 31 | -------------------------------------------------------------------------------- /Arrays/Plus1.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : list of integers 3 | # @return a list of integers 4 | def plusOne(self, A): 5 | res = [] 6 | added = False 7 | 8 | while A and not A[0]: 9 | A = A[1:] 10 | 11 | if not A: return [1] 12 | 13 | for i in range(1,len(A)+1): 14 | if A[-i] == 9 and not added: 15 | res.append(0) 16 | if i == len(A): 17 | res.append(1) 18 | added = True 19 | elif A[-i] != 9 and not added: 20 | res.append(A[-i]+ 1) 21 | added = True 22 | else: 23 | res.append(A[-i]) 24 | 25 | 26 | return res[::-1] 27 | 28 | 29 | -------------------------------------------------------------------------------- /Trees/BinTree.py: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node 2 | # class TreeNode: 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.left = None 6 | # self.right = None 7 | 8 | class Solution: 9 | # @param inorder : list of integers denoting inorder traversal 10 | # @param postorder : list of integers denoting postorder traversal 11 | # @return the root node in the tree 12 | def buildTree(self, inorder, postorder): 13 | root = None 14 | if inorder: 15 | ind = inorder.index(postorder.pop()) 16 | root = TreeNode(inorder[ind]) 17 | root.right = self.buildTree(inorder[ind+1:], postorder) 18 | root.left = self.buildTree(inorder[:ind], postorder) 19 | 20 | 21 | return root if root else None 22 | 23 | -------------------------------------------------------------------------------- /Stacks and Queues/SlidingMax.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : tuple of integers 3 | # @param B : integer 4 | # @return a list of integers 5 | def slidingMaximum(self, A, B): 6 | nums = A 7 | k = B 8 | if not nums: 9 | return nums 10 | st = [] 11 | for i in range(k): 12 | while st and nums[st[-1]] <= nums[i]: 13 | st.pop() 14 | st.append(i) 15 | 16 | l = [nums[st[0]]] 17 | 18 | n = len(nums) 19 | for i in range(k,n): 20 | while st and nums[st[-1]] <= nums[i]: 21 | st.pop() 22 | while st and i - st[0] >= k: 23 | st.pop(0) 24 | st.append(i) 25 | l.append(nums[st[0]]) 26 | 27 | return l 28 | 29 | -------------------------------------------------------------------------------- /Dynamic Programming/Regex2.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param s : string 3 | # @param p : string 4 | # @return an integer 5 | def isMatch(self, s, p): 6 | m = len(s) 7 | n = len(p) 8 | dp = [[0]*(m+1) for i in range(n+1)] 9 | dp[0][0] = 1 10 | for i in xrange(1,n+1): 11 | x = p[i-1] 12 | if x == "*" and i > 1: 13 | dp[i][0] = dp[i-2][0] 14 | for j in xrange(1, m + 1): 15 | if x == "*": 16 | dp[i][j] = dp[i-2][j] or dp[i-1][j] 17 | if p[i-2] == '.' or p[i-2] == s[j-1]: 18 | dp[i][j] = dp[i][j] or dp[i][j-1] 19 | elif x == s[j-1] or x == '.': 20 | dp[i][j] = dp[i-1][j-1] 21 | return dp[-1][-1] 22 | 23 | 24 | -------------------------------------------------------------------------------- /Arrays/Maxset.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : list of integers 3 | # @return a list of integers 4 | def maxset(self, A): 5 | if len(A) == 0: return [] 6 | max_sub = [] 7 | curr_sub = [] 8 | curr_sum = 0 9 | max_sum = -1 10 | 11 | for i in range(len(A)): 12 | if A[i] >=0 : 13 | curr_sub.append(A[i]) 14 | curr_sum += A[i] 15 | else: 16 | curr_sum = 0 17 | curr_sub = [] 18 | if curr_sum > max_sum: 19 | max_sub = curr_sub 20 | max_sum = curr_sum 21 | elif curr_sum == max_sum and len(max_sub) <= len(curr_sub): 22 | max_sub = curr_sub 23 | max_sum = curr_sum 24 | 25 | return max_sub 26 | 27 | -------------------------------------------------------------------------------- /Dynamic Programming/MaxPathTree.py: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node 2 | # class TreeNode: 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.left = None 6 | # self.right = None 7 | 8 | class Solution: 9 | # @param A : root node of tree 10 | # @return an integer 11 | def maxPathSum(self, A): 12 | import sys 13 | res = [-sys.maxint-1] 14 | self.maxPathSumHelper(A, res) 15 | return res[0] 16 | 17 | def maxPathSumHelper(self, A, res): 18 | if not A: return 0 19 | l_p = self.maxPathSumHelper(A.left, res) 20 | r_p = self.maxPathSumHelper(A.right, res) 21 | single = max(max(l_p, r_p) + A.val, A.val) 22 | both = max(l_p + r_p + A.val, single) 23 | res[0] = max(res[0], both) 24 | 25 | return single 26 | 27 | -------------------------------------------------------------------------------- /Strings/LongestPalin.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : string 3 | # @return a strings 4 | def longestPalindrome(self, A): 5 | if len(A) == 0: return None 6 | max_pal = "" 7 | for i in xrange(len(A)): 8 | p1 = self.expandAroundCenter(i,i, A) 9 | if len(p1) > len(max_pal): 10 | max_pal = p1 11 | p2 = self.expandAroundCenter(i, i+1, A) 12 | if len(p2) > len(max_pal): 13 | max_pal = p2 14 | 15 | return max_pal 16 | 17 | def expandAroundCenter(self, left,right, A): 18 | while(left >=0 and right < len(A) and A[left] == A[right]): 19 | left -= 1 20 | right +=1 21 | return A[left+1: right] 22 | 23 | 24 | 25 | 26 | -------------------------------------------------------------------------------- /Trees/MinDepth.py: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node 2 | # class TreeNode: 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.left = None 6 | # self.right = None 7 | 8 | class Solution: 9 | # @param A : root node of tree 10 | # @return an integer 11 | def minDepth(self, A): 12 | q = [] 13 | q.append(A) 14 | q.append("sentinel") 15 | count = 0 16 | while q != ["sentinel"]: 17 | u = q[0] 18 | q = q[1:] 19 | if u == "sentinel": 20 | count += 1 21 | q.append("sentinel") 22 | continue 23 | if u.left: q.append(u.left) 24 | if u.right: q.append(u.right) 25 | if u.left == None and u.right == None : return count + 1 26 | 27 | return count + 1 28 | -------------------------------------------------------------------------------- /Trees/Path2.py: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node 2 | # class TreeNode: 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.left = None 6 | # self.right = None 7 | 8 | class Solution: 9 | # @param root : root node of tree 10 | # @param sum1 : integer 11 | # @return a list of list of integers 12 | def pathSum(self, root, s): 13 | if not root: 14 | return [] 15 | elif not root.left and not root.right: 16 | return [[root.val]] if root.val == s else [] 17 | 18 | l = [] 19 | 20 | for path in self.pathSum(root.left, s - root.val): 21 | l.append([root.val]+ path) 22 | 23 | for path in self.pathSum(root.right, s - root.val): 24 | l.append([root.val]+ path) 25 | 26 | return l 27 | 28 | -------------------------------------------------------------------------------- /Two pointers/Array3Ptr.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : tuple of integers 3 | # @param B : tuple of integers 4 | # @param C : tuple of integers 5 | # @return an integer 6 | def minimize(self, A, B, C): 7 | p = len(A) 8 | q = len(B) 9 | r = len(C) 10 | import sys 11 | res = sys.maxint 12 | i, j, k = 0,0 ,0 13 | while i < p and j < q and k < r: 14 | min_e, max_e = min(A[i],B[j],C[k]), max(A[i],B[j],C[k]) 15 | if res > max_e - min_e: 16 | res = max_e - min_e 17 | if res == 0: 18 | return 0 19 | if A[i] == min_e: 20 | i += 1 21 | elif B[j] == min_e: 22 | j += 1 23 | else: 24 | k += 1 25 | 26 | return res 27 | 28 | -------------------------------------------------------------------------------- /Trees/SumRootLeaf.py: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node 2 | # class TreeNode: 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.left = None 6 | # self.right = None 7 | 8 | class Solution: 9 | # @param A : root node of tree 10 | # @return an integer 11 | def sumNumbers(self, root): 12 | 13 | def helper(root,val): 14 | if root: 15 | if not (root.left or root.right): 16 | res[0] += (val*10 + root.val) 17 | if root.left: 18 | helper(root.left, val*10 + root.val) 19 | if root.right: 20 | helper(root.right, val*10 + root.val) 21 | 22 | if not root: 23 | return 0 24 | res = [0] 25 | helper(root, 0) 26 | return res[0]%1003 27 | 28 | -------------------------------------------------------------------------------- /Dynamic Programming/LongestParen.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : string 3 | # @return an integer 4 | def longestValidParentheses(self, A): 5 | s = A 6 | n = len(s) 7 | longest = [0]*n 8 | max_length = 0 9 | 10 | for i in range(n): 11 | if s[i]== ")": 12 | if i - 1 >= 0 and s[i-1] == "(": 13 | longest[i] = 2 if i == 1 else longest[i-2] + 2 14 | max_length = max(max_length, longest[i]) 15 | else: 16 | if i- longest[i-1] -1 >=0 and s[i- longest[i-1] -1] == "(": 17 | longest[i] = longest[i-1] + 2 + (longest[i-longest[i-1] - 2] if i-longest[i-1] - 2 >= 0 else 0) 18 | max_length = max(max_length, longest[i]) 19 | 20 | 21 | return max_length 22 | 23 | -------------------------------------------------------------------------------- /Dynamic Programming/Stocks1.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : tuple of integers 3 | # @return an integer 4 | def maxProfit(self, A): 5 | mProfit = 0 6 | if len(A) < 2: return 0 7 | 8 | 9 | smallest = A[0] 10 | largest = A[1] 11 | 12 | mProfit = largest - smallest 13 | currProfit = mProfit 14 | 15 | for i in range(1,len(A)): 16 | if A[i] > largest: 17 | currProfit = currProfit + A[i] - largest 18 | largest = A[i] 19 | elif A[i] < smallest: 20 | smallest = A[i] 21 | largest = A[i] 22 | currProfit = 0 23 | 24 | mProfit = max(mProfit, currProfit) 25 | 26 | 27 | return mProfit 28 | 29 | 30 | 31 | -------------------------------------------------------------------------------- /Dynamic Programming/Regex.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param s : string 3 | # @param p : string 4 | # @return an integer 5 | def isMatch(self, s, p): 6 | match = 0 7 | asterisk = -1 8 | i, j = 0,0 9 | m = len(s) 10 | n = len(p) 11 | 12 | while i < m: 13 | if j < n and p[j] == "*": 14 | match = i 15 | asterisk = j 16 | j += 1 17 | elif j < n and (s[i] == p[j] or p[j] == '?'): 18 | i += 1 19 | j += 1 20 | elif asterisk >= 0: 21 | i = match 22 | match += 1 23 | j = asterisk + 1 24 | else: 25 | return False 26 | while j < n and p[j] == "*": 27 | j += 1 28 | 29 | return True if j == n else False 30 | 31 | -------------------------------------------------------------------------------- /Graphs/CloneGraph.py: -------------------------------------------------------------------------------- 1 | # Definition for a undirected graph node 2 | # class UndirectedGraphNode: 3 | # def __init__(self, x): 4 | # self.label = x 5 | # self.neighbors = [] 6 | 7 | class Solution: 8 | # @param node, a undirected graph node 9 | # @return a undirected graph node 10 | def cloneGraph(self, node): 11 | d = {} 12 | if not node: 13 | return node 14 | node2 = UndirectedGraphNode(node.label) 15 | d[node] = node2 16 | d[None] = None 17 | q = [node] 18 | 19 | while q: 20 | u = q.pop(0) 21 | for n in u.neighbors: 22 | if n not in d: 23 | d[n] = UndirectedGraphNode(n.label) 24 | q.append(n) 25 | d[u].neighbors.append(d[n]) 26 | 27 | return node2 28 | 29 | -------------------------------------------------------------------------------- /Dynamic Programming/Dungeon.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : list of list of integers 3 | # @return an integer 4 | def calculateMinimumHP(self, A): 5 | dungeon = A 6 | m = len(dungeon) 7 | n = len(dungeon[0]) 8 | #dp = [[0]*(n) for i in range(m)] 9 | dungeon[-1][-1] = 1 if dungeon[-1][-1] >= 0 else -dungeon[-1][-1] + 1 10 | 11 | 12 | for j in range(1,n): 13 | dungeon[-1][-j-1] = max(dungeon[-1][-j] - dungeon[-1][-j-1], 1) 14 | 15 | for i in range(1,m): 16 | dungeon[-i-1][-1] = max(dungeon[-i][-1] - dungeon[-i-1][-1], 1) 17 | 18 | for i in range(1,m): 19 | for j in range(1,n): 20 | dungeon[-i-1][-j-1] = max(1, min(dungeon[-i-1][-j], dungeon[-i][-j-1]) - dungeon[-i-1][-j-1]) 21 | 22 | return dungeon[0][0] 23 | 24 | -------------------------------------------------------------------------------- /Linked Lists/Merge.py: -------------------------------------------------------------------------------- 1 | # Definition for singly-linked list. 2 | # class ListNode: 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.next = None 6 | 7 | class Solution: 8 | # @param A : head node of linked list 9 | # @param B : head node of linked list 10 | # @return the head node in the linked list 11 | def mergeTwoLists(self, A, B): 12 | head1 = A 13 | head2 = B 14 | 15 | p1 = head1 16 | p2 = head2 17 | 18 | p1_prev = None 19 | while p1 and p2: 20 | if p1.val <= p2.val: 21 | p1_prev = p1 22 | p1 = p1.next 23 | else: 24 | if p1_prev != None : p1_prev.next = p2 25 | p1, p2 = p2, p1 26 | p1_prev.next = p2 27 | 28 | return head1 if head1.val <= head2.val else head2 29 | 30 | -------------------------------------------------------------------------------- /Trees/NextPointer2.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree with next pointer. 3 | * struct TreeLinkNode { 4 | * int val; 5 | * TreeLinkNode *left, *right, *next; 6 | * TreeLinkNode(int x) : val(x), left(NULL), right(NULL), next(NULL) {} 7 | * }; 8 | */ 9 | void Solution::connect(TreeLinkNode* root) { 10 | TreeLinkNode *tail = new TreeLinkNode(0); 11 | TreeLinkNode *dummy = tail; 12 | TreeLinkNode *node = root; 13 | 14 | 15 | while(node != NULL) 16 | { 17 | tail->next = node->left; 18 | if(tail->next != NULL) 19 | tail = tail->next; 20 | tail->next = node->right; 21 | if(tail->next != NULL) 22 | tail = tail->next; 23 | node = node->next; 24 | if(node == NULL) 25 | { 26 | tail = dummy; 27 | node = dummy->next; 28 | } 29 | } 30 | 31 | } 32 | 33 | -------------------------------------------------------------------------------- /Trees/Postorder.py: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node 2 | # class TreeNode: 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.left = None 6 | # self.right = None 7 | 8 | class Solution: 9 | # @param A : root node of tree 10 | # @return a list of integers 11 | def postorderTraversal(self, A): 12 | l = [] 13 | st = [] 14 | st.append(A) 15 | while st: 16 | u = st[-1] 17 | if u.left == None and u.right == None: 18 | l.append(u.val) 19 | st = st[:-1] 20 | if u.right: 21 | st.append(u.right) 22 | u.right = None 23 | if u.left: 24 | st.append(u.left) 25 | u.left = None 26 | 27 | 28 | return l 29 | 30 | 31 | 32 | -------------------------------------------------------------------------------- /Dynamic Programming/WordBreak.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : string 3 | # @param B : list of strings 4 | # @return an integer 5 | def wordBreak(self, A, B): 6 | wordLenList = set(map(len, B)) 7 | sentences = [False for i in range(len(A))] 8 | for startIndex in range(len(A), -1, -1): 9 | for wordLen in wordLenList: 10 | if startIndex + wordLen > len(A) or A[startIndex: startIndex + wordLen] not in B: 11 | continue 12 | if startIndex + wordLen == len(A): 13 | sentences[startIndex] = True 14 | break 15 | else: 16 | if sentences[startIndex + wordLen]: 17 | sentences[startIndex] = True 18 | break 19 | if sentences[0]: return 1 20 | else: return 0 21 | 22 | -------------------------------------------------------------------------------- /Dynamic Programming/WordBreak2.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : string 3 | # @param B : list of strings 4 | # @return a list of strings 5 | def wordBreak(self, s, wordDict): 6 | return findWords(0, len(s), s, wordDict, {}) 7 | 8 | 9 | def findWords(start, end, s, wordDict, cache): 10 | if start in cache: 11 | return cache[start] 12 | 13 | cache[start] = [] 14 | current = start 15 | candidate = '' 16 | 17 | while current < end: 18 | candidate += s[current] 19 | current += 1 20 | if candidate in wordDict: 21 | if current == end: 22 | cache[start].append(candidate) 23 | else: 24 | for x in findWords(current, end, s, wordDict, cache): 25 | cache[start].append(candidate + ' ' + x) 26 | 27 | return cache[start] 28 | 29 | 30 | -------------------------------------------------------------------------------- /Graphs/LevelOrder.py: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node 2 | # class TreeNode: 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.left = None 6 | # self.right = None 7 | 8 | class Solution: 9 | # @param A : root node of tree 10 | # @return a list of list of integers 11 | def levelOrder(self, root): 12 | level = [] 13 | queue = [] 14 | if root: 15 | queue.append(root) 16 | res = [] 17 | while queue: 18 | new_queue = [] 19 | res.append([]) 20 | for node in queue: 21 | res[-1].append(node.val) 22 | if node.left: 23 | new_queue.append(node.left) 24 | if node.right: 25 | new_queue.append(node.right) 26 | queue = new_queue 27 | 28 | return res 29 | 30 | -------------------------------------------------------------------------------- /Heaps and Maps/LRU.py: -------------------------------------------------------------------------------- 1 | import collections 2 | 3 | class LRUCache: 4 | 5 | # @param capacity, an integer 6 | def __init__(self, capacity): 7 | 8 | 9 | self.d = collections.OrderedDict() 10 | self.capacity = capacity 11 | 12 | 13 | # @return an integer 14 | def get(self, key): 15 | try: 16 | v = self.d.pop(key) 17 | self.d[key] = v 18 | return v 19 | except KeyError: 20 | return -1 21 | 22 | 23 | # @param key, an integer 24 | # @param value, an integer 25 | # @return nothing 26 | def set(self, key, value): 27 | try: 28 | self.d.pop(key) 29 | except KeyError: 30 | if self.capacity == len(self.d): 31 | self.d.popitem(last = False) 32 | 33 | self.d[key] = value 34 | 35 | 36 | -------------------------------------------------------------------------------- /Trees/BinTree2.py: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node 2 | # class TreeNode: 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.left = None 6 | # self.right = None 7 | 8 | class Solution: 9 | # @param preorder : list of integers denoting preorder traversal of tree 10 | # @param inorder : list of integers denoting inorder traversal of tree 11 | # @return the root node in the tree 12 | def buildTree(self, preorder, inorder): 13 | def helper(l,r): 14 | root = None 15 | if l < r: 16 | i = d[preorder.pop(0)] 17 | root = TreeNode(inorder[i]) 18 | root.left = helper(l,i) 19 | root.right = helper(i+1, r) 20 | 21 | return root 22 | 23 | d = {val:i for i, val in enumerate(inorder)} 24 | return helper(0, len(inorder)) 25 | 26 | -------------------------------------------------------------------------------- /Heaps and Maps/DNums.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : list of integers 3 | # @param B : integer 4 | # @return a list of integers 5 | def dNums(self, A, B): 6 | from collections import Counter 7 | k = [] 8 | if B > len(A): return [] 9 | else: 10 | m = Counter(A[:B]) 11 | k.append(len(m)) 12 | #print k 13 | for i in range(1, len(A) - B+1): 14 | if m[A[i-1]] == 1: 15 | m.pop(A[i-1]) 16 | k.append(k[-1]-1) 17 | else: 18 | m[A[i-1]] -= 1 19 | k.append(k[-1]) 20 | 21 | if A[i+B-1] not in m: 22 | m[A[i+B-1]] = 1 23 | k[-1] += 1 24 | else: 25 | m[A[i+B-1]] += 1 26 | 27 | return k 28 | 29 | 30 | -------------------------------------------------------------------------------- /Linked Lists/ListCycle.py: -------------------------------------------------------------------------------- 1 | # Definition for singly-linked list. 2 | # class ListNode: 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.next = None 6 | 7 | class Solution: 8 | # @param A : head node of linked list 9 | # @return the first node in the cycle in the linked list 10 | def detectCycle(self, A): 11 | p1 = A 12 | p2 = A 13 | 14 | first_time = 1 15 | while first_time == 1 or p1 != p2: 16 | p1 = p1.next 17 | if p2 == None or p2.next == None: 18 | return None 19 | else: 20 | p2 = p2.next.next 21 | 22 | first_time = 0 23 | 24 | #print "yaha a gya bc" 25 | p1 = A 26 | while p1 != p2: 27 | p1 = p1.next 28 | p2 = p2.next 29 | 30 | 31 | return p2 32 | 33 | 34 | -------------------------------------------------------------------------------- /Graphs/StepNum.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : integer 3 | # @param B : integer 4 | # @return a list of integers 5 | def stepnum(self, A, B): 6 | def nextNums(val): 7 | n = [] 8 | if val - 1 >= 0: 9 | n.append(val-1) 10 | if val + 1 <= 9: 11 | n.append(val+1) 12 | return n 13 | graph = [i for i in range(10)] 14 | level = set(graph) 15 | res = set() 16 | while level: 17 | new_level = set() 18 | for num in level: 19 | if A <= num <= B: 20 | res.add(num) 21 | val = num % 10 22 | for n in nextNums(val): 23 | new_num = num*10 + n 24 | if new_num <= B: 25 | new_level.add(new_num) 26 | level = new_level 27 | 28 | return sorted(list(res)) 29 | 30 | -------------------------------------------------------------------------------- /Stacks and Queues/EvalExp.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : list of strings 3 | # @return an integer 4 | def evalRPN(self, A): 5 | def calc(a, b, oper): 6 | if oper == "+": 7 | return a + b 8 | elif oper == "-": 9 | return a - b 10 | elif oper == "*": 11 | return a * b 12 | else: 13 | if a * b < 0 and a % b != 0: 14 | return a / b + 1 15 | else: 16 | return a/b 17 | 18 | st = [] 19 | i = 0 20 | while i < len(A): 21 | if A[i] in '+-*/': 22 | b = st.pop() 23 | a = st.pop() 24 | st.append(calc(a,b,A[i])) 25 | else: 26 | st.append(int(A[i])) 27 | i += 1 28 | 29 | 30 | 31 | return int(st[0]) 32 | 33 | -------------------------------------------------------------------------------- /Stacks and Queues/Rain.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : tuple of integers 3 | # @return an integer 4 | def trap(self, height): 5 | i = 0 6 | j = len(height) - 1 7 | 8 | maxleft, maxright = 0, 0 9 | water = 0 10 | left = 0 11 | right = len(height) - 1 12 | 13 | while left <= right: 14 | if height[left] <= height[right]: 15 | if maxleft < height[left]: 16 | maxleft = height[left] 17 | else: 18 | water += maxleft - height[left] 19 | left += 1 20 | else: 21 | if maxright < height[right]: 22 | maxright = height[right] 23 | else: 24 | water += maxright - height[right] 25 | right -= 1 26 | 27 | 28 | return water 29 | 30 | -------------------------------------------------------------------------------- /Arrays/Repeat3.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : tuple of integers 3 | # @return an integer 4 | def repeatedNumber(self, A): 5 | count1, count2 ,poss1, poss2 = 0, 0 , 0, 1 6 | for n in A: 7 | if poss1 == n: 8 | count1 += 1 9 | elif poss2 == n: 10 | count2 += 1 11 | elif count1 == 0: 12 | count1, poss1 = 1, n 13 | elif count2 == 0: 14 | count2, poss2 = 1, n 15 | else: 16 | count1 -= 1 17 | count2 -= 1 18 | 19 | count1, count2 = 0, 0 20 | 21 | for n in A: 22 | if n == poss1: 23 | count1 += 1 24 | elif n == poss2: 25 | count2 += 1 26 | #res = [] 27 | 28 | if count1 > len(A)//3: return poss1 29 | if count2 > len(A)//3: return poss2 30 | return -1 31 | 32 | -------------------------------------------------------------------------------- /Dynamic Programming/DecodeWays.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : string 3 | # @return an integer 4 | def numDecodings(self, A): 5 | if not A: return 0 6 | n = len(A) 7 | 8 | ways = [0] * n 9 | ways[0] = 1 10 | 11 | if A[0] == '0': return 0 12 | for i in range(1,n): 13 | if int(A[i]) == 0: 14 | if int(A[i-1]) == 1 or int(A[i-1]) == 2: 15 | ways[i] = max(ways[i-2],1) 16 | else: 17 | return 0 18 | else: 19 | if 1 <= int(A[i-1]) <= 2: 20 | if int(A[i-1]) == 2 and int(A[i]) < 7: 21 | ways[i] = max(ways[i-2],1) 22 | elif int(A[i-1]) == 1: 23 | ways[i] = max(ways[i-2],1) 24 | ways[i] += ways[i-1] 25 | 26 | return ways[-1] 27 | 28 | 29 | 30 | 31 | -------------------------------------------------------------------------------- /Two pointers/3Sum.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : list of integers 3 | # @param B : integer 4 | # @return an integer 5 | def threeSumClosest(self, A, B): 6 | #if len(A) < 3: return None 7 | A = sorted(A) 8 | n = len(A) 9 | import sys 10 | 11 | mindiff = sys.maxint 12 | 13 | for i in range(len(A)-2): 14 | j = i + 1 15 | k = n - 1 16 | while j < k: 17 | s = A[i] + A[k] + A[j] 18 | diff = abs(B - s) 19 | 20 | if diff == 0: 21 | return s 22 | 23 | if diff < mindiff: 24 | mindiff = diff 25 | result = s 26 | 27 | if s <= B: 28 | j += 1 29 | else: 30 | k -= 1 31 | 32 | 33 | return result 34 | 35 | -------------------------------------------------------------------------------- /Backtracking/Comb2.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : list of integers 3 | # @param B : integer 4 | # @return a list of list of integers 5 | def combinationSum(self, candidates, target): 6 | sorted_list = sorted(candidates) 7 | all_combinations = self.combinationHelper(sorted_list, 0, target) 8 | return all_combinations 9 | 10 | 11 | def combinationHelper(self, candidates, start, target): 12 | if target == 0: 13 | return [[]] 14 | result = [] 15 | 16 | for i in range(start, len(candidates)): 17 | if i != start and candidates[i] == candidates[i-1]: 18 | continue 19 | elif candidates[i] > target: 20 | break 21 | else: 22 | for r in self.combinationHelper(candidates, i+1, target - candidates[i]): 23 | result.append([candidates[i]]+ r) 24 | 25 | return result 26 | 27 | -------------------------------------------------------------------------------- /Graphs/Knight.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param N : integer 3 | # @param M : integer 4 | # @param x1 : integer 5 | # @param y1 : integer 6 | # @param x2 : integer 7 | # @param y2 : integer 8 | # @return an integer 9 | def knight(self, N, M, x1, y1, x2, y2): 10 | visited = [[False]*M for i in range(N)] 11 | queue = [((x1,y1),0)] 12 | visited[x1-1][y1-1] = True 13 | def append_paths(i,j, depth): 14 | for x, y in ((1,2),(-1,2),(1,-2),(-1,-2),(2,1),(-2,1),(2,-1),(-2,-1)): 15 | if 1 <= i + x <= N and 1 <= j + y <= M and not visited[x+i-1][y+j-1]: 16 | queue.append(((x+i,y+j),depth+1)) 17 | visited[x+i-1][y+j-1] = True 18 | 19 | while queue: 20 | (i,j), d = queue.pop(0) 21 | if i == x2 and j == y2: 22 | return d 23 | else: 24 | append_paths(i,j,d) 25 | 26 | return -1 27 | 28 | -------------------------------------------------------------------------------- /Linked Lists/NthEnd.py: -------------------------------------------------------------------------------- 1 | # Definition for singly-linked list. 2 | # class ListNode: 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.next = None 6 | 7 | class Solution: 8 | # @param A : head node of linked list 9 | # @param B : integer 10 | # @return the head node in the linked list 11 | def removeNthFromEnd(self, A, B): 12 | head, n = A, B 13 | prev1 = None 14 | prev2 = None 15 | count = 0 16 | curr1, curr2 = head, head 17 | while curr2: 18 | count += 1 19 | if count > n: 20 | prev1 = curr1 21 | curr1 = curr1.next 22 | prev2 = curr2 23 | curr2 = curr2.next 24 | 25 | if prev1: 26 | if curr1: 27 | prev1.next = curr1.next 28 | else: 29 | prev1.next = None 30 | else: 31 | head = head.next 32 | 33 | return head 34 | 35 | -------------------------------------------------------------------------------- /Two pointers/3SumZero.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : list of integers 3 | # @return a list of list of integers 4 | def threeSum(self, A): 5 | A = sorted(A) 6 | n = len(A) 7 | 8 | res = [] 9 | 10 | for i in range(len(A)-2): 11 | if i > 0 and A[i] == A[i-1]: 12 | continue 13 | 14 | j = i + 1 15 | k = n - 1 16 | while j < k: 17 | s = A[i] + A[j] + A[k] 18 | 19 | if s == 0: 20 | res.append([A[i], A[j], A[k]]) 21 | 22 | if s <= 0: 23 | j += 1 24 | while j < k and A[j] == A[j-1]: 25 | j += 1 26 | else: 27 | k -= 1 28 | while k > j and A[k] == A[k+1]: 29 | k -= 1 30 | 31 | return res 32 | 33 | -------------------------------------------------------------------------------- /Trees/Inorder.py: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node 2 | # class TreeNode: 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.left = None 6 | # self.right = None 7 | 8 | class Solution: 9 | # @param A : root node of tree 10 | # @return a list of integers 11 | def inorderTraversal(self, A): 12 | import sys 13 | 14 | l = [] 15 | st = [] 16 | st.append((A, A.val)) 17 | while st: 18 | u, val = st[-1] 19 | #st = st[:-1] 20 | if u.right: 21 | st = st[:-1] + [(u.right, u.right.val)] + [st[-1]] 22 | u.right = None 23 | #st.append(u) 24 | if u.left: 25 | st.append((u.left, u.left.val)) 26 | u.left = None 27 | else: 28 | #print u 29 | st = st[:-1] 30 | l.append(val) 31 | #print l 32 | 33 | return l 34 | -------------------------------------------------------------------------------- /Stacks and Queues/MinStack.py: -------------------------------------------------------------------------------- 1 | class MinStack: 2 | # @param x, an integer 3 | 4 | def __init__(self): 5 | self.st = [] 6 | 7 | 8 | def push(self, x): 9 | if not self.st: 10 | self.st.append((x, 0)) 11 | 12 | else: 13 | if x < self.st[self.st[-1][1]][0]: 14 | self.st.append((x, len(self.st))) 15 | 16 | else: 17 | self.st.append((x, self.st[-1][1])) 18 | 19 | 20 | # @return nothing 21 | def pop(self): 22 | if self.st != []: self.st.pop() 23 | 24 | 25 | 26 | # @return an integer 27 | def top(self): 28 | if not self.st: return -1 29 | else: 30 | return self.st[-1][0] 31 | 32 | 33 | 34 | # @return an integer 35 | def getMin(self): 36 | if not self.st : return -1 37 | else: 38 | return self.st[self.st[-1][1]][0] 39 | 40 | 41 | 42 | 43 | -------------------------------------------------------------------------------- /Strings/Version.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : string 3 | # @param B : string 4 | # @return an integer 5 | def compareVersion(self, A, B): 6 | v1 = A.split('.') 7 | v2 = B.split('.') 8 | 9 | i = 0 10 | 11 | while i < len(v1) and i < len(v2): 12 | if int(v1[i]) > int(v2[i]): 13 | return 1 14 | elif int(v1[i]) < int(v2[i]): 15 | return -1 16 | i += 1 17 | 18 | if len(v1) == len(v2): 19 | return 0 20 | elif len(v1) > len(v2): 21 | while i < len(v1) and int(v1[i]) == 0: 22 | i += 1 23 | if i == len(v1): 24 | return 0 25 | else: 26 | return 1 27 | else: 28 | while i < len(v2) and int(v2[i]) == 0: 29 | i += 1 30 | if i == len(v2): 31 | return 0 32 | else: 33 | return -1 34 | 35 | -------------------------------------------------------------------------------- /Backtracking/PermSeq.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param n : integer 3 | # @param k : integer 4 | # @return a strings 5 | def getPermutation(self, n, k): 6 | d = {0: 1} 7 | 8 | for i in range(1,n+1): 9 | d[i] = d[i-1]*i 10 | #print d 11 | l = range(1,n+1) 12 | s = "" 13 | while k: 14 | i = k/d[len(l)-1] 15 | #print k/d[len(l)-1], i 16 | if i == len(l): 17 | s += str(l[-1]) 18 | k -= (i)*d[len(l)-1] 19 | l.pop(-1) 20 | else: 21 | 22 | k -= (i)*d[len(l)-1] 23 | if not k: 24 | s += str(l[i-1]) 25 | l.pop(i-1) 26 | else: 27 | s += str(l[i]) 28 | l.pop(i) 29 | 30 | #print s 31 | 32 | if l: 33 | s += ''.join(map(str,l[::-1])) 34 | return s 35 | 36 | -------------------------------------------------------------------------------- /Strings/Count_Say.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : integer 3 | # @return a strings 4 | def countAndSay(self, A): 5 | array_one = "1" 6 | A = A-1 7 | 8 | 9 | for i in xrange(A): 10 | j = 0 11 | array_two = "" 12 | while j < len(array_one) - 1: 13 | count = 1 14 | while j+1 < len(array_one) and array_one[j] == array_one[j+1]: 15 | j += 1 16 | count += 1 17 | array_two = array_two + str(count) 18 | array_two = array_two + str(array_one[j]) 19 | j += 1 20 | 21 | if len(array_one) == 1: 22 | array_one = "11" 23 | elif array_one[-1] != array_one[-2]: 24 | array_two= array_two + str(11) 25 | array_one = array_two[:] 26 | elif array_one[-1] == array_one[-2]: 27 | array_one = array_two 28 | 29 | 30 | return array_one 31 | 32 | 33 | -------------------------------------------------------------------------------- /Hashing/ValidSudoku.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : tuple of strings 3 | # @return an integer 4 | def isValidSudoku(self, A): 5 | rowD = [{} for i in range(9)] 6 | colD = [{} for i in range(9)] 7 | boxD = [{} for i in range(9)] 8 | 9 | for i in range(9): 10 | for j in range(9): 11 | ele = A[i][j] 12 | if ele != '.': 13 | if A[i][j] not in rowD[i]: 14 | rowD[i][A[i][j]] = 1 15 | else: 16 | return 0 17 | if A[i][j] not in colD[j]: 18 | colD[j][A[i][j]] = 1 19 | else: 20 | return 0 21 | boxNumber = 3 * (i/3) + (j/3) 22 | if ele not in boxD[boxNumber]: 23 | boxD[boxNumber][ele] = 1 24 | else: 25 | return 0 26 | 27 | return 1 28 | 29 | -------------------------------------------------------------------------------- /Strings/AtoI.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : string 3 | # @return an integer 4 | def atoi(self, A): 5 | n = len(A) 6 | 7 | for i in range(n): 8 | if A[0] == ' ': 9 | A = A[1:] 10 | else: 11 | break 12 | 13 | num = 0 14 | pos = True 15 | for i in range(len(A)): 16 | if i == 0 and A[i] == '+' : 17 | pos = True 18 | elif i == 0 and A[i] == '-': 19 | pos = False 20 | elif not ('0' <= A[i] <= '9'): 21 | return num if pos == True else (-1)*num 22 | else: 23 | num = (num) * 10 + int(A[i]) 24 | if num > 2147483647 and pos == True: 25 | return 2147483647 26 | elif num > 2147483647 and pos == False: 27 | return -2147483648 28 | 29 | return num if pos == True else (-1) * num 30 | 31 | 32 | -------------------------------------------------------------------------------- /Linked Lists/SwapL.py: -------------------------------------------------------------------------------- 1 | # Definition for singly-linked list. 2 | # class ListNode: 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.next = None 6 | 7 | class Solution: 8 | # @param A : head node of linked list 9 | # @return the head node in the linked list 10 | def swapPairs(self, head): 11 | if not head or not head.next: 12 | return head 13 | 14 | pre_prev = None 15 | prev = head 16 | curr = head.next 17 | nex = curr.next 18 | head = curr 19 | while curr: 20 | if pre_prev: 21 | #print "fuck" 22 | pre_prev.next = curr 23 | prev.next = nex 24 | curr.next = prev 25 | pre_prev = prev 26 | prev = nex 27 | if nex: 28 | curr = nex.next 29 | if curr: nex = curr.next 30 | else: break 31 | else: 32 | break 33 | 34 | return head 35 | 36 | -------------------------------------------------------------------------------- /Linked Lists/PartitionList.py: -------------------------------------------------------------------------------- 1 | # Definition for singly-linked list. 2 | # class ListNode: 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.next = None 6 | 7 | class Solution: 8 | # @param A : head node of linked list 9 | # @param B : integer 10 | # @return the head node in the linked list 11 | def partition(self, A, B): 12 | small_list = [] 13 | large_list = [] 14 | 15 | curr = A 16 | while curr: 17 | if curr.val < B: 18 | small_list.append(curr.val) 19 | else: 20 | large_list.append(curr.val) 21 | 22 | curr = curr.next 23 | 24 | i = 0 25 | curr = A 26 | while curr: 27 | if i < len(small_list): 28 | curr.val = small_list[i] 29 | else: 30 | curr.val = large_list[i-len(small_list)] 31 | curr = curr.next 32 | 33 | i += 1 34 | 35 | return A 36 | 37 | -------------------------------------------------------------------------------- /Dynamic Programming/Paths2.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : list of list of integers 3 | # @return an integer 4 | def uniquePathsWithObstacles(self, A): 5 | m = len(A) 6 | n = len(A[0]) 7 | dp = [[0]* n for i in range(m)] 8 | 9 | if A[0][0] == 1 or A[-1][-1] == 1: return 0 10 | 11 | dp[0][0] = 1 12 | 13 | for i in range(1,m): 14 | if A[i][0] == 0: 15 | dp[i][0] = dp[i-1][0] 16 | else: 17 | dp[i][0] = 0 18 | 19 | for j in range(1,n): 20 | if A[0][j] == 0: 21 | dp[0][j] = dp[0][j-1] 22 | else: 23 | dp[0][j] = 0 24 | 25 | for i in range(1,m): 26 | for j in range(1,n): 27 | if A[i][j] == 0: 28 | dp[i][j] = dp[i][j-1] + dp[i-1][j] 29 | else: 30 | dp[i][j] = 0 31 | 32 | 33 | return dp[-1][-1] 34 | 35 | -------------------------------------------------------------------------------- /Graphs/List2Tree.py: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node 2 | # class TreeNode: 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.left = None 6 | # self.right = None 7 | 8 | # Definition for singly-linked list. 9 | # class ListNode: 10 | # def __init__(self, x): 11 | # self.val = x 12 | # self.next = None 13 | 14 | class Solution: 15 | # @param A : head node of linked list 16 | # @return the root node in the tree 17 | def sortedListToBST(self, A): 18 | ar = [] 19 | curr = A 20 | while curr: 21 | ar.append(curr.val) 22 | curr = curr.next 23 | 24 | def constructBST(l): 25 | if not l: 26 | return None 27 | 28 | mid = len(l)/2 29 | root = TreeNode(l[mid]) 30 | root.left = constructBST(l[:mid]) 31 | root.right = constructBST(l[mid+1:]) 32 | 33 | return root 34 | 35 | return constructBST(ar) 36 | 37 | -------------------------------------------------------------------------------- /Arrays/Flip.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : string 3 | # @return a list of integers 4 | def flip(self, A): 5 | B = [] 6 | for i in range(len(A)): 7 | if A[i] == '\n': continue 8 | s += int(A[i]) 9 | if A[i] == '1': 10 | B.append(-1) 11 | else: 12 | B.append(1) 13 | 14 | max_here = 0 15 | max_so_far = 0 16 | c_start = 1 17 | end = -1 18 | for i, x in enumerate(B): 19 | #print i 20 | if max_here+x < 0 : 21 | c_start = i + 2 22 | max_here = 0 23 | else: 24 | max_here += x 25 | 26 | 27 | if max_here > max_so_far: 28 | start = c_start 29 | end = i + 1 30 | max_so_far = max_here 31 | 32 | if end == -1: 33 | return [] 34 | else: 35 | return [start, end] 36 | 37 | 38 | 39 | -------------------------------------------------------------------------------- /Dynamic Programming/Scramble.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : string 3 | # @param B : string 4 | # @return an integer 5 | def isScramble(self, A, B): 6 | s1, s2 = A, B 7 | if s1 == s2: 8 | return True 9 | if not s1 or not s2: 10 | return False 11 | if len(s1) != len(s2): 12 | return False 13 | from collections import defaultdict 14 | lcount1 = defaultdict(int) 15 | lcount2 = defaultdict(int) 16 | rcount2 = defaultdict(int) 17 | n = len(s1) 18 | for i in range(n-1): 19 | lcount1[s1[i]] += 1 20 | lcount2[s2[i]] += 1 21 | rcount2[s2[n-i-1]] += 1 22 | if lcount1 == lcount2: 23 | if self.isScramble(s1[:i+1], s2[:i+1]) and self.isScramble(s1[i+1:], s2[i+1:]): 24 | return True 25 | elif rcount2 == lcount1: 26 | 27 | if self.isScramble(s1[:i+1], s2[n-i-1:]) and self.isScramble(s1[i+1:], s2[:n-i-1]): 28 | return True 29 | return False 30 | 31 | -------------------------------------------------------------------------------- /Trees/TreeIterator.py: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node 2 | # class TreeNode: 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.left = None 6 | # self.right = None 7 | 8 | class BSTIterator: 9 | # @param root, a binary search tree's root node 10 | def __init__(self, root): 11 | self.st = [] 12 | self.pushAllLeft(root) 13 | 14 | 15 | # @return a boolean, whether we have a next smallest number 16 | def hasNext(self): 17 | return True if self.st else False 18 | 19 | 20 | # @return an integer, the next smallest number 21 | def next(self): 22 | temp = self.st.pop() 23 | self.pushAllLeft(temp.right) 24 | return temp.val 25 | 26 | def pushAllLeft(self, root): 27 | if root: 28 | self.st.append(root) 29 | 30 | while root.left: 31 | self.st.append(root.left) 32 | root = root.left 33 | 34 | 35 | # Your BSTIterator will be called like this: 36 | # i = BSTIterator(root) 37 | # while i.hasNext(): print i.next(), 38 | 39 | -------------------------------------------------------------------------------- /Backtracking/Comb.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : list of integers 3 | # @param B : integer 4 | # @return a list of list of integers 5 | def combinationSum(self, A, B): 6 | A = set(A) 7 | A = list(A) 8 | A = sorted(A) 9 | comb_lis = self.combinationHelper(A, 0, B) 10 | return comb_lis[0] 11 | 12 | 13 | 14 | def combinationHelper(self, A, value, target): 15 | comb_lis = [] 16 | found = False 17 | if value == target: 18 | return comb_lis, True 19 | else: 20 | i = 0 21 | while i < len(A) and A[i] + value <= target: 22 | lis_of_lis, found = self.combinationHelper(A[i:], value + A[i], target) 23 | if lis_of_lis == [] and found == True: 24 | comb_lis.append([A[i]]) 25 | else: 26 | for lis in lis_of_lis: 27 | comb_lis.append( [A[i]] + lis ) 28 | 29 | i += 1 30 | 31 | return comb_lis, found 32 | 33 | 34 | -------------------------------------------------------------------------------- /Arrays/Spiral.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : integer 3 | # @return a list of list of integers 4 | def generateMatrix(self, A): 5 | n = A 6 | ret = [[0]*n] 7 | for i in range(n-1): 8 | ret.append([0]*n) 9 | 10 | T = 0 11 | B = n-1 12 | L = 0 13 | R = n-1 14 | direction = 0 15 | num = 1 16 | while T <=B and L <=R: 17 | if direction == 0: 18 | for i in range(L,R+1): 19 | ret[T][i] = num 20 | num += 1 21 | T += 1 22 | direction = 1 23 | elif direction == 1: 24 | for i in range(T,B+1): 25 | ret[i][R] = num 26 | num += 1 27 | R -= 1 28 | direction = 2 29 | elif direction == 2: 30 | for i in range(R,L-1,-1): 31 | ret[B][i] = num 32 | num += 1 33 | B -= 1 34 | direction = 3 35 | else: 36 | for i in range(B,T-1,-1): 37 | ret[i][L] = num 38 | num += 1 39 | L += 1 40 | direction = 0 41 | return ret 42 | 43 | -------------------------------------------------------------------------------- /Trees/Balanced.py: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node 2 | # class TreeNode: 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.left = None 6 | # self.right = None 7 | 8 | class Solution: 9 | # @param A : root node of tree 10 | # @return an integer 11 | def isBalanced(self, A): 12 | return False if self.findheight(A, 0) == -1 else True 13 | 14 | 15 | def findheight(self, A, depth): 16 | if not A.left and not A.right : return depth 17 | 18 | left_height = 0 19 | right_height = 0 20 | 21 | if A.left: 22 | left_height = self.findheight(A.left , depth + 1) 23 | #print "left", A.left.val, depth 24 | if A.right: 25 | right_height = self.findheight(A.right, depth + 1) 26 | #print "right", A.right.val, depth 27 | 28 | if left_height == -1 or right_height == -1: 29 | return -1 30 | 31 | if left_height - right_height > 1: 32 | return -1 33 | else: 34 | return max(left_height, right_height) 35 | 36 | 37 | -------------------------------------------------------------------------------- /Heaps and Maps/MergeKList.py: -------------------------------------------------------------------------------- 1 | # Definition for singly-linked list. 2 | # class ListNode: 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.next = None 6 | 7 | class Solution: 8 | # @param A : list of linked list 9 | # @return the head node in the linked list 10 | def mergeKLists(self, A): 11 | import heapq 12 | import sys 13 | 14 | k = [] 15 | merged_list = None 16 | 17 | for a in A: 18 | heapq.heappush(k, (a.val, a)) 19 | 20 | 21 | curr = k[0][1] 22 | merged_list = ListNode(curr.val) 23 | merged_last = merged_list 24 | 25 | while curr: 26 | least_node_val = sys.maxint 27 | least_node = None 28 | 29 | heapq.heappop(k) 30 | 31 | if curr.next: heapq.heappush(k , (curr.next.val, curr.next)) 32 | if not k: break 33 | curr = k[0][1] 34 | 35 | merged_last.next = ListNode(curr.val) 36 | merged_last = merged_last.next 37 | 38 | 39 | return merged_list 40 | 41 | -------------------------------------------------------------------------------- /Trees/Flatten.py: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node 2 | # class TreeNode: 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.left = None 6 | # self.right = None 7 | 8 | class Solution: 9 | # @param A : root node of tree 10 | # @return the root node in the tree 11 | def flatten(self, A): 12 | if A.left == None and A.right == None: 13 | return A 14 | elif A.left == None: 15 | self.flatten(A.right) 16 | return A 17 | elif A.right == None: 18 | A.right = self.flatten(A.left) 19 | A.left = None 20 | return A 21 | else: 22 | l = self.flatten(A.left) 23 | A.left = None 24 | r = A.right 25 | last = self.findRightMost(l) 26 | last.right = self.flatten(r) 27 | A.right = l 28 | return A 29 | 30 | 31 | def findRightMost(self, A): 32 | #if A.left != None: print "WTF", A.val 33 | if A == None: return None 34 | curr = A 35 | while curr.right != None: 36 | curr = curr.right 37 | return curr 38 | 39 | -------------------------------------------------------------------------------- /Strings/PrettyJSON.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : string 3 | # @return a list of strings 4 | def prettyJSON(self, A): 5 | curr_indent = "" 6 | res = [] 7 | curr = "" 8 | for i,c in enumerate(A): 9 | if c == "[" or c == "{": 10 | if curr: res.append(curr_indent + curr) 11 | curr = curr_indent + c 12 | res.append(curr) 13 | curr_indent += "\t" 14 | curr = "" 15 | elif c == "]" or c == "}": 16 | if curr: res.append(curr_indent + curr) 17 | curr_indent = curr_indent[:-1] 18 | curr = curr_indent + c 19 | res.append(curr) 20 | curr = "" 21 | elif c == " ": 22 | curr = "" 23 | elif c == ",": 24 | if A[i-1] == "}" or A[i-1] == "]": 25 | res[-1] = res[-1] + c 26 | else: 27 | curr = curr_indent + curr + c 28 | res.append(curr) 29 | curr = "" 30 | else: 31 | curr += c 32 | 33 | return res 34 | 35 | -------------------------------------------------------------------------------- /Dynamic Programming/MaxRectangle.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : list of list of integers 3 | # @return an integer 4 | def maximalRectangle(self, A): 5 | m = len(A) 6 | n = len(A[0]) 7 | left = [0] * n 8 | right = [n for i in range(n)] 9 | height = [0] * n 10 | max_area = 0 11 | 12 | for i in range(m): 13 | curr_left = 0 14 | curr_right = n 15 | for j in range(n): 16 | if A[i][j] == 1: 17 | left[j] = max(curr_left, left[j]) 18 | height[j] += 1 19 | else: 20 | left[j] = 0 21 | height[j] = 0 22 | curr_left = j + 1 23 | 24 | if A[i][-j-1] == 1: 25 | right[-j-1] = min(right[-j-1], curr_right) 26 | else: 27 | right[-j-1] = n 28 | curr_right = n-j-1 29 | 30 | for j in range(n): 31 | max_area = max(max_area, (right[j] - left[j]) * height[j]) 32 | 33 | return max_area 34 | 35 | 36 | 37 | -------------------------------------------------------------------------------- /Stacks and Queues/Histogram.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : list of integers 3 | # @return an integer 4 | def largestRectangleArea(self, height): 5 | st = [] 6 | maxArea = 0 7 | i = 0 8 | for i in range(len(height)): 9 | if not st or height[st[-1]] <= height[i]: 10 | st.append(i) 11 | else: 12 | #maxArea = max(maxArea, height[i]) 13 | 14 | while st and height[st[-1]] > height[i]: 15 | tp = st.pop() 16 | if st: 17 | maxArea = max(maxArea, height[tp] * ( i - st[-1] - 1)) 18 | else: 19 | maxArea = max(maxArea, height[tp] * i) 20 | #print maxArea, st 21 | 22 | st.append(i) 23 | 24 | i += 1 25 | while st: 26 | tp = st.pop() 27 | if st: 28 | maxArea = max(maxArea, height[tp] * ( i - st[-1] - 1)) 29 | else: 30 | maxArea = max(maxArea, height[tp] * i) 31 | #print maxArea, st, i 32 | 33 | return maxArea 34 | 35 | -------------------------------------------------------------------------------- /Strings/Power.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : string 3 | # @return an integer 4 | def power(self, A): 5 | #k = int(A) 6 | if len(A) == 1 and int(A) < 2: 7 | return 0 8 | #while k > 1: 9 | # if k % 2 == 1: 10 | # return 0 11 | # k /= 2 12 | 13 | res = [] 14 | carry = '0' 15 | while len(A) > 1 or int(A) > 1: 16 | if len(A) == 1: 17 | if int(A) == 2 or int(A) == 4 or int(A) == 8: 18 | return 1 19 | else: 20 | return 0 21 | for i in A: 22 | res.append(str(int(carry + i)/2)) 23 | if int(carry + i) % 2 == 1: 24 | carry = '1' 25 | else: 26 | carry = '0' 27 | 28 | while res[0] == '0': 29 | res = res[1:] 30 | 31 | A = ''.join(res) 32 | #print A 33 | if int(A[-1]) % 2 == 1: 34 | return 0 35 | 36 | 37 | res = [] 38 | 39 | 40 | return 1 41 | 42 | -------------------------------------------------------------------------------- /Linked Lists/InsertionSort.py: -------------------------------------------------------------------------------- 1 | # Definition for singly-linked list. 2 | # class ListNode: 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.next = None 6 | 7 | class Solution: 8 | # @param A : head node of linked list 9 | # @return the head node in the linked list 10 | def insertionSortList(self, A): 11 | head = A 12 | def insert_into_correct_place(head, curr, prev): 13 | if head.val > curr.val: 14 | prev.next = curr.next 15 | curr.next = head 16 | head = curr 17 | return curr, prev 18 | 19 | c = head 20 | while c.next.val < curr.val: 21 | c = c.next 22 | 23 | prev.next = curr.next 24 | curr.next = c.next 25 | c.next = curr 26 | return head, prev 27 | 28 | curr = head 29 | prev = None 30 | while curr: 31 | if prev and prev.val > curr.val: 32 | head, curr = insert_into_correct_place(head, curr, prev) 33 | 34 | prev = curr 35 | curr = curr.next 36 | 37 | return head 38 | -------------------------------------------------------------------------------- /Bit Manipulation/Divide.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param dividend : integer 3 | # @param divisor : integer 4 | # @return an integer 5 | def divide(self, dividend, divisor): 6 | if dividend > 2147483647 or divisor == 0: 7 | return 2147483647 8 | 9 | if dividend == 0: 10 | return 0 11 | if dividend * divisor < 0: 12 | negative = True 13 | else: 14 | negative = False 15 | 16 | #count = 0 17 | dividend = abs(dividend) 18 | divisor = abs(divisor) 19 | 20 | #while dividend>=divisor: 21 | # i = 1 22 | # x = divisor 23 | # while dividend >= x+x: 24 | # i += i 25 | # x += x 26 | # 27 | # dividend -= x 28 | # count += i 29 | 30 | t = 0 31 | q = 0 32 | for i in range(32): 33 | if t + (divisor << i) <= dividend: 34 | t += (divisor << i) 35 | q |= 1<= 2147483647 or q = -2147483648 else q 40 | 41 | 42 | -------------------------------------------------------------------------------- /Backtracking/Parenthesis.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : integer 3 | # @return a list of strings 4 | def generateParenthesis(self, A): 5 | paren_lis = self.helperParenthesis(A, 0, 0) 6 | return paren_lis 7 | 8 | 9 | 10 | def helperParenthesis(self, A, left_count , right_count): 11 | paren_lis = [] 12 | 13 | if A == left_count: 14 | st = "" 15 | while right_count < left_count: 16 | right_count += 1 17 | st = st + ")" 18 | return [st] 19 | #elif A = left_count and left_count == right_count: return [""] 20 | elif left_count > right_count : 21 | for st in self.helperParenthesis(A, left_count + 1, right_count): 22 | paren_lis.append( "(" + st ) 23 | for st in self.helperParenthesis(A, left_count, right_count + 1): 24 | paren_lis.append( ")" + st) 25 | return paren_lis 26 | 27 | elif left_count == right_count: 28 | for st in self.helperParenthesis(A, left_count + 1, right_count): 29 | paren_lis.append( "(" + st ) 30 | 31 | return paren_lis 32 | 33 | 34 | -------------------------------------------------------------------------------- /Two pointers/RemDup2.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : list of integers 3 | # @return an integer 4 | def removeDuplicates(self, A): 5 | ''' 6 | count = 0 7 | i = 0 8 | state = 0 9 | while i < len(A): 10 | if state == 0: 11 | if i == 0 or A[i] != A[count-1]: 12 | A[count] = A[i] 13 | state = 0 14 | count += 1 15 | elif A[i] == A[count-1]: 16 | A[count] = A[i] 17 | state = 1 18 | count += 1 19 | else: 20 | if A[i] != A[count-1]: 21 | A[count] = A[i] 22 | count += 1 23 | state = 0 24 | 25 | i += 1 26 | 27 | 28 | return count 29 | ''' 30 | if not A: 31 | return 0 32 | count = 0 33 | i = 1 34 | j = 0 35 | while i < len(A) and j < len(A): 36 | if i <= 1 or A[i] != A[j] or A[i] != A[j-1]: 37 | j += 1 38 | A[j] = A[i] 39 | i += 1 40 | 41 | 42 | return j + 1 43 | 44 | -------------------------------------------------------------------------------- /Strings/StrStr.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param haystack : string 3 | # @param needle : string 4 | # @return an integer 5 | def strStr(self, haystack, needle): 6 | if haystack is None or needle is None: return -1 7 | h = self.preprocess(needle) 8 | 9 | i = 0 10 | j = 0 11 | while i < len(haystack): 12 | if needle[j] == haystack[i]: 13 | j += 1 14 | i += 1 15 | if j == len(needle): return i - j 16 | elif i < len(haystack) and needle[j] != haystack[i]: 17 | if j!=0: 18 | j = h[j-1] 19 | else: 20 | i += 1 21 | return -1 22 | 23 | def preprocess(self, pattern): 24 | lps = [0] 25 | matching_prefix_position = 0 26 | for i in range(1,len(pattern)): 27 | while matching_prefix_position != 0 and pattern[i] != pattern[matching_prefix_position]: 28 | matching_prefix_position = lps[matching_prefix_position-1] 29 | if pattern[matching_prefix_position] == pattern[i]: 30 | matching_prefix_position += 1 31 | lps.append(matching_prefix_position) 32 | 33 | return lps 34 | 35 | 36 | -------------------------------------------------------------------------------- /Hashing/Fraction.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param numerator : integer 3 | # @param denominator : integer 4 | # @return a string 5 | def fractionToDecimal(self, numerator, denominator): 6 | if denominator == 0: 7 | return "NaN" 8 | 9 | if numerator * denominator < 0: 10 | neg = True 11 | else: 12 | neg = False 13 | 14 | numerator = abs(numerator) 15 | denominator = abs(denominator) 16 | s = str(numerator/denominator) 17 | 18 | remainder = numerator%denominator 19 | 20 | if remainder: 21 | s += '.' 22 | 23 | d = {} 24 | 25 | #d[remainder] = len(s) 26 | 27 | i = len(s) 28 | while remainder: 29 | numerator = remainder * 10 30 | digit = str(numerator/denominator) 31 | 32 | if remainder in d: 33 | s = s[:d[remainder]]+ "(" + s[d[remainder]:] + ")" 34 | break 35 | else: 36 | s += digit 37 | d[remainder] = i 38 | 39 | remainder = numerator%denominator 40 | i += 1 41 | 42 | return s if not neg else "-"+s 43 | 44 | -------------------------------------------------------------------------------- /Graphs/WordLadder1.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param start : string 3 | # @param end : string 4 | # @param dictV : list of strings 5 | # @return an integer 6 | def ladderLength(self, start, end, dictV): 7 | beginWord = start 8 | endWord = end 9 | wordList = dictV 10 | import string 11 | 12 | if beginWord == endWord: return 1 13 | wordLength = len(beginWord) 14 | fronts = [{beginWord}, {endWord}] 15 | levels = [1,1] 16 | 17 | while fronts[0] and fronts[1]: 18 | if len(fronts[0]) > len(fronts[1]): 19 | fronts.reverse() 20 | levels.reverse() 21 | newLevel = set() 22 | for word in fronts[0]: 23 | for i in range(wordLength): 24 | for c in string.lowercase: 25 | newWord = word[:i] + c + word[i+1:] 26 | if newWord in fronts[1]: 27 | return levels[0] + levels[1] 28 | if newWord in wordList: 29 | newLevel.add(newWord) 30 | wordList.remove(newWord) 31 | 32 | 33 | fronts[0] = newLevel 34 | levels[0] += 1 35 | 36 | return 0 37 | 38 | -------------------------------------------------------------------------------- /Dynamic Programming/Maxcoin.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : list of integers 3 | # @return an integer 4 | def maxcoin(self, nums): 5 | 6 | ''' 7 | if not nums: 8 | return 0 9 | n = len(nums) 10 | dp = [[0]*n for i in range(n)] 11 | for gap in range(n): 12 | for i in range(n-gap): 13 | if gap == 0: 14 | dp[i][i] = nums[i] 15 | elif gap == 1: 16 | dp[i][i+1] = max(nums[i],nums[i+1]) 17 | else: 18 | dp[i][i+gap] = max(nums[i] + min(dp[i+2][i+gap],dp[i+1][i+gap-1]), nums[i+gap] + min(dp[i+1][i+gap-1] , dp[i][i+gap-2])) 19 | 20 | return dp[0][-1] 21 | ''' 22 | cache = {} 23 | def helper(nums): 24 | if len(nums) == 2: 25 | return max(nums) 26 | 27 | if tuple(nums) in cache: 28 | return cache[tuple(nums)] 29 | 30 | choice1 = nums[0] + min(helper(nums[1:-1]), helper(nums[2:])) 31 | choice2 = nums[-1] + min(helper(nums[1:-1]), helper(nums[:-2])) 32 | cache[tuple(nums)] = max(choice1, choice2) 33 | return cache[tuple(nums)] 34 | 35 | return helper(nums) 36 | 37 | -------------------------------------------------------------------------------- /Strings/AddBinary.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : string 3 | # @param B : string 4 | # @return a strings 5 | def addBinary(self, A, B): 6 | a = A 7 | b = B 8 | result = [] 9 | carry = 0 10 | if len(a) < len(b): 11 | a , b = b, a 12 | i = 1 13 | 14 | while i <= len(b): 15 | res = int(a[-i]) + int(b[-i]) + carry 16 | if res > 1: 17 | if res == 2: 18 | res = 0 19 | else: 20 | res = 1 21 | carry = 1 22 | else: 23 | carry = 0 24 | 25 | result.append(str(res)) 26 | i +=1 27 | 28 | while i <= len(a): 29 | res = int(a[-i]) + carry 30 | if res > 1: 31 | if res == 2: 32 | res = 0 33 | else: 34 | res = 1 35 | carry = 1 36 | else: 37 | carry = 0 38 | i += 1 39 | 40 | result.append(str(res)) 41 | 42 | if carry : result.append(str(carry)) 43 | 44 | result = result[::-1] 45 | 46 | return ''.join(result) 47 | 48 | -------------------------------------------------------------------------------- /Strings/IPAddress.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : string 3 | # @return a list of strings 4 | def restoreIpAddresses(self, A): 5 | s = A 6 | if len(s) < 4 or len(s) > 12: 7 | return [] 8 | 9 | return sorted(restoreHelper(s, 3)) 10 | 11 | def restoreHelper(s, dots): 12 | 13 | l = [] 14 | #print "s: ", s, "dots: ", dots 15 | 16 | if dots == 0 and int(s) <= 255: 17 | if len(s) == 1: 18 | return [s] 19 | else: 20 | if int(s[0]) == 0: 21 | return [] 22 | return [s] 23 | 24 | if int(s[0]) == 0: 25 | if isValid(s[1:], dots-1): 26 | for ip in restoreHelper(s[1:], dots-1): 27 | full_ip = s[0] + "." + ip 28 | l.append(full_ip) 29 | return l 30 | 31 | for i in range(3): 32 | if int(s[:i+1]) <= 255 and isValid(s[i+1:], dots-1): 33 | for ip in restoreHelper(s[i+1:], dots-1): 34 | full_ip = s[:i+1] + "." + ip 35 | #print full_ip 36 | l.append(full_ip) 37 | return l 38 | 39 | def isValid(s, dots): 40 | if len(s) <= dots: 41 | return False 42 | if len(s) > (dots + 1) * 3: 43 | return False 44 | 45 | return True 46 | 47 | -------------------------------------------------------------------------------- /Linked Lists/LPalin.py: -------------------------------------------------------------------------------- 1 | # Definition for singly-linked list. 2 | # class ListNode: 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.next = None 6 | 7 | class Solution: 8 | # @param A : head node of linked list 9 | # @return an integer 10 | def lPalin(self, A): 11 | head = A 12 | def findMidandReverse(head): 13 | if not head or not head.next: 14 | return head, head 15 | curr1 = head 16 | curr2 = head 17 | 18 | while curr1 and curr2: 19 | curr2 = curr2.next 20 | if curr2: 21 | curr2 = curr2.next 22 | prev = curr1 23 | curr1 = curr1.next 24 | 25 | ##Found Mid now reversing 26 | p = curr1 27 | c = curr1.next 28 | while c: 29 | c.next , p, c = p, c, c.next 30 | 31 | curr1.next = None 32 | return head, p 33 | 34 | 35 | c1, c2 = findMidandReverse(head) 36 | 37 | while c1 and c2: 38 | if c1.val == c2.val: 39 | c1 = c1.next 40 | c2 = c2.next 41 | else: 42 | return 0 43 | 44 | return 1 45 | -------------------------------------------------------------------------------- /Graphs/Multiple.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : integer 3 | # @return a strings 4 | def multiple(self, A): 5 | #num = str(A) 6 | #level = ['0']*len(num) 7 | #level[0] = '1' 8 | #level = [int(''.join(level))] 9 | level = [1] 10 | seen = [0]*A 11 | par = [0]*A 12 | val = [0]*A 13 | from collections import deque 14 | qu = deque() 15 | qu.append(1%A) 16 | seen[1%A] = 1 17 | val[1%A] = 1 18 | 19 | 20 | res = "" 21 | while True: 22 | p = qu.popleft() 23 | if p == 0: 24 | #print "oK" 25 | res = "1" if val[p] == 1 else '0' 26 | p = par[p] 27 | while p != 0: 28 | res = "1" + res if val[p] == 1 else '0' + res 29 | p = par[p] 30 | return res 31 | 32 | q = (p*10)%A 33 | if seen[q] == 0: 34 | qu.append(q) 35 | seen[q], par[q], val[q] = 1, p, 0 36 | 37 | q += 1 38 | if q >= A: q -= A 39 | 40 | if seen[q] == 0: 41 | qu.append(q) 42 | seen[q], par[q], val[q] = 1, p, 1 43 | 44 | 45 | 46 | -------------------------------------------------------------------------------- /Trees/LCA.py: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node 2 | # class TreeNode: 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.left = None 6 | # self.right = None 7 | 8 | class Solution: 9 | # @param A : root node of tree 10 | # @param val1 : integer 11 | # @param val2 : integer 12 | # @return an integer 13 | import copy 14 | 15 | def findval(self,A, val, path): 16 | if not A: return -1 17 | else: 18 | if A.val == val: 19 | return path + [A.val] 20 | else: 21 | pl = self.findval(A.left, val, path + [A.val]) 22 | if pl != -1: return pl 23 | 24 | pr = self.findval(A.right, val, path + [A.val]) 25 | if pr != -1: return pr 26 | 27 | return -1 28 | 29 | 30 | def lca(self, A, val1, val2): 31 | #return "fuck" 32 | p1 = self.findval(A, val1, []) 33 | p2 = self.findval(A, val2, []) 34 | 35 | if p1 == -1 or p2 == -1: return -1 36 | 37 | i = 0 38 | while i < len(p1) and i < len(p2) and p1[i] == p2[i]: 39 | i +=1 40 | #print i 41 | 42 | return p1[i-1] 43 | 44 | 45 | -------------------------------------------------------------------------------- /Strings/Int2Roman.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : integer 3 | # @return a strings 4 | def intToRoman(self, A): 5 | roman = "" 6 | if A >= 1000: 7 | roman = "M"*(A/1000) 8 | A = A%1000 9 | if A >= 900 and A < 1000: 10 | roman += "CM" 11 | A -= 900 12 | if A >= 500 and A < 900: 13 | roman += "D" 14 | A -= 500 15 | if A >= 400 and A < 500: 16 | roman += "CD" 17 | A -= 400 18 | if A >= 100 and A < 400: 19 | roman += "C"*(A/100) 20 | A = A % 100 21 | if A >= 90 and A < 100: 22 | roman += "XC" 23 | A -= 90 24 | if A >= 50 and A < 90: 25 | roman += "L" 26 | A -= 50 27 | if A >= 40 and A < 50: 28 | roman += "XL" 29 | A -= 40 30 | if A >= 10 and A < 40: 31 | roman += "X"*(A/10) 32 | A = A % 10 33 | if A == 9: 34 | roman += "IX" 35 | A -= 9 36 | if A >= 5 and A < 9: 37 | roman += "V" 38 | A -= 5 39 | if A == 4: 40 | roman += "IV" 41 | if A >= 1 and A < 4: 42 | roman += "I"*(A) 43 | 44 | 45 | 46 | return roman 47 | 48 | 49 | -------------------------------------------------------------------------------- /Linked Lists/AddNum.py: -------------------------------------------------------------------------------- 1 | # Definition for singly-linked list. 2 | # class ListNode: 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.next = None 6 | 7 | class Solution: 8 | # @param A : head node of linked list 9 | # @param B : head node of linked list 10 | # @return the head node in the linked list 11 | def addTwoNumbers(self, A, B): 12 | l1, l2 = A, B 13 | carry = 0 14 | head = ListNode(0) 15 | curr = head 16 | while l1 or l2 or carry: 17 | if l1 and l2: 18 | curr.val = l1.val + l2.val + carry 19 | l1 = l1.next 20 | l2 = l2.next 21 | elif l1: 22 | curr.val = l1.val + carry 23 | l1 = l1.next 24 | elif l2: 25 | curr.val = l2.val + carry 26 | l2 = l2.next 27 | else: 28 | curr.val = carry 29 | carry = 0 30 | 31 | if curr.val > 9: 32 | carry = curr.val/10 33 | curr.val = curr.val%10 34 | else: 35 | carry = 0 36 | 37 | curr.next = ListNode(0) 38 | prev = curr 39 | curr = curr.next 40 | 41 | 42 | prev.next = None 43 | 44 | return head 45 | -------------------------------------------------------------------------------- /Linked Lists/RemDupLink2.py: -------------------------------------------------------------------------------- 1 | # Definition for singly-linked list. 2 | # class ListNode: 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.next = None 6 | 7 | class Solution: 8 | # @param A : head node of linked list 9 | # @return the head node in the linked list 10 | def deleteDuplicates(self, A): 11 | head = A 12 | def removeDup(prev, curr): 13 | while curr.next and curr.next.val == curr.val: 14 | curr = curr.next 15 | prev.next = curr.next 16 | return prev, curr.next 17 | 18 | if not head or not head.next: 19 | return head 20 | 21 | prev = head 22 | curr = head.next 23 | 24 | while curr and prev and prev.val == curr.val: 25 | while curr and prev and prev.val == curr.val: 26 | prev, curr = curr, curr.next 27 | if not curr: 28 | return curr 29 | prev = curr 30 | curr = curr.next 31 | 32 | head = prev 33 | 34 | while curr: 35 | if curr.next and curr.next.val == curr.val: 36 | prev, curr = removeDup(prev, curr) 37 | 38 | else: 39 | prev = curr 40 | curr = curr.next 41 | 42 | return head 43 | -------------------------------------------------------------------------------- /Dynamic Programming/Stocks3.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : tuple of integers 3 | # @return an integer 4 | def maxProfit(self, A): 5 | ''' 6 | if not A: 7 | return 0 8 | 9 | dp = [0]*len(A) 10 | currprofit = -A[0] 11 | totalprofit = 0 12 | smallest = A[0] 13 | for i,price in enumerate(A): 14 | if price < smallest: 15 | smallest = price 16 | currprofit = price - smallest 17 | totalprofit = max(currprofit, totalprofit) 18 | dp[i] = totalprofit 19 | 20 | currprofit = 0 21 | totalprofit = 0 22 | highest = A[-1] 23 | res = 0 24 | for i in range(len(A) -1, -1, -1): 25 | if A[i] > highest: highest = A[i] 26 | currprofit = highest - A[i] 27 | totalprofit = max(currprofit , totalprofit) 28 | res = max(res, totalprofit + dp[i]) 29 | 30 | return res 31 | ''' 32 | if not A: 33 | return 0 34 | buy1, sell1, buy2, sell2 = -A[0], 0, -A[0], 0 35 | 36 | for n in A: 37 | sell2 = max(sell2, buy2 + n) 38 | buy2 = max(buy2, sell1 - n) 39 | sell1 = max(sell1, buy1 + n) 40 | buy1 = max(buy1, -n) 41 | 42 | return sell2 43 | 44 | 45 | -------------------------------------------------------------------------------- /Graphs/WordSearch.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : list of strings 3 | # @param B : string 4 | # @return an integer 5 | def exist(self, board, word): 6 | #if len(word) >= 900: 7 | # return True 8 | word = word[:-1] 9 | for i in range(len(board)): 10 | for j in range(len(board[0])): 11 | if board[i][j] == word[0]: 12 | if self.existhelper(board, word[1:], i, j) == 1: 13 | return 1 14 | 15 | return 0 16 | 17 | def existhelper(self, board, word, i, j): 18 | #if word[0] == "C": print i,j 19 | if len(word) == 0: 20 | return 1 21 | else: 22 | if j > 0 and board[i][j-1] == word[0]: 23 | if self.existhelper(board, word[1:], i, j-1) == 1: 24 | return 1 25 | 26 | if j < len(board[0])-1 and board[i][j+1] == word[0]: 27 | if self.existhelper(board, word[1:], i, j+1) == 1: 28 | return 1 29 | 30 | if i > 0 and board[i-1][j] == word[0]: 31 | if self.existhelper(board, word[1:], i-1, j) == 1: 32 | return 1 33 | 34 | if i < len(board)-1 and board[i+1][j] == word[0]: 35 | if self.existhelper(board, word[1:], i+1, j) == 1: 36 | return 1 37 | 38 | return 0 39 | 40 | #return 1 41 | -------------------------------------------------------------------------------- /Hashing/Substring.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : string 3 | # @param B : tuple of strings 4 | # @return a list of integers 5 | def findSubstring(self, A, B): 6 | import collections 7 | need, missing = collections.Counter(B), len(B) 8 | total_length = 0 9 | for s in B: 10 | total_length += len(s) 11 | 12 | #print need, total_length, missing 13 | start_list = [] 14 | 15 | for i in range(len(A)- total_length + 1): 16 | start = i 17 | word_start = i 18 | j = i+1 19 | need, missing = collections.Counter(B), len(B) 20 | found = False 21 | while j < i + total_length + 1: 22 | if A[word_start:j] in need and need[A[word_start:j]] > 0: 23 | #print start, A[word_start:j] 24 | need[A[word_start:j]] -= 1 25 | missing -= 1 26 | if missing == 0: 27 | #print A[word_start:j] 28 | start_list.append(start) 29 | break 30 | if need[A[word_start:j]] < 0: 31 | break 32 | word_start = j 33 | #print word_start 34 | 35 | 36 | j += 1 37 | 38 | 39 | return start_list 40 | 41 | 42 | -------------------------------------------------------------------------------- /Dynamic Programming/RodCut.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : integer 3 | # @param B : list of integers 4 | # @return a list of integers 5 | def rodCut(self, A, B): 6 | B = [0] + B + [A] 7 | from sys import maxint 8 | n = len(B) 9 | dp = [[maxint]*(n) for i in range(n)] 10 | par = [[0]*(n) for i in range(n)] 11 | 12 | for i in range(n): 13 | dp[i][i] = 0 14 | if i < n - 1: 15 | dp[i][i+1] = 0 16 | 17 | for gap in range(3,len(B)+1): 18 | for i in range(n-gap+1): 19 | j = i + gap - 1 20 | for k in range(i+1, j): 21 | if dp[i][k] + dp[k][j] + B[j]-B[i] < dp[i][j]: 22 | dp[i][j]= dp[i][k] + dp[k][j] + B[j]-B[i] 23 | par[i][j] = k 24 | 25 | 26 | def make_par(i,j): 27 | #print res, i , j 28 | if i == j: 29 | res.append(B[i]) 30 | elif i == j - 1: 31 | pass 32 | #res.append(B[i]) 33 | else: 34 | k = par[i][j] 35 | #print k 36 | res.append(B[k]) 37 | make_par(i,k) 38 | make_par(k,j) 39 | 40 | res = [] 41 | i = 0 42 | j = n-1 43 | 44 | make_par(i,j) 45 | return res 46 | 47 | 48 | -------------------------------------------------------------------------------- /Hashing/Points.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : list of integers 3 | # @param B : list of integers 4 | # @return an integer 5 | def maxPoints(self, A, B): 6 | if len(A) == 1: return 1 7 | #print A, B 8 | finalMax = 0 9 | 10 | for i in range(len(A)-1): 11 | slopes = {} 12 | slopeCount = 0 13 | same_count = 0 14 | verticalCount = 0 15 | x1 , y1 = A[i] , B[i] 16 | for j in range(i+1, len(A)): 17 | if i != j: 18 | x2, y2 = A[j], B[j] 19 | if x1 == x2 and y1 == y2: same_count += 1 20 | elif x1 == x2: 21 | verticalCount += 1 22 | slopeCount = max(slopeCount, verticalCount) 23 | else: 24 | slope = ((y2-y1)*1.0/(x2-x1)) 25 | if slope not in slopes: 26 | slopes[slope] = 1 27 | slopeCount = max(slopeCount, slopes[slope]) 28 | else: 29 | slopes[slope] += 1 30 | #print i,j, slopes[slope], slope, y2, y1 31 | slopeCount = max(slopeCount, slopes[slope]) 32 | 33 | 34 | finalMax = max(slopeCount + same_count + 1 , finalMax) 35 | 36 | return finalMax 37 | 38 | -------------------------------------------------------------------------------- /Greedy/Candy.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param ratings : list of integers 3 | # @return an integer 4 | def candy(self, ratings): 5 | if not ratings: return 0 6 | 7 | min_total_count = 1 8 | curr_count = 1 9 | last_i = -1 10 | last_count = 1 11 | 12 | 13 | for i in range(1,len(ratings)): 14 | if ratings[i] > ratings[i-1]: 15 | last_i = i-1 16 | curr_count += 1 17 | last_count = curr_count 18 | min_total_count += curr_count 19 | 20 | elif ratings[i] < ratings[i-1]: 21 | #curr_count = 1 22 | 23 | if last_count == 1: 24 | last_count = 1 25 | curr_count = 1 26 | min_total_count += i - last_i 27 | elif last_count > 1: 28 | last_count -= 1 29 | curr_count = 1 30 | min_total_count += i - last_i -1 31 | else: 32 | curr_count = 1 33 | min_total_count += curr_count 34 | else: 35 | last_i = i-1 36 | last_count = 1 37 | curr_count = 1 38 | min_total_count += curr_count 39 | 40 | 41 | #print min_total_count, curr_count 42 | 43 | return min_total_count 44 | 45 | 46 | -------------------------------------------------------------------------------- /Arrays/Maxgap.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : tuple of integers 3 | # @return an integer 4 | def maximumGap(self, A): 5 | if len(A) < 2: 6 | return 0 7 | nums = A 8 | length = len(A) 9 | if length == 2: return abs(nums[0]- nums[1]) 10 | else: 11 | min_nums = min(nums) 12 | max_nums = max(nums) 13 | diff = max_nums - min_nums 14 | if diff == 0: return 0 15 | bucket = [[sys.maxint, -sys.maxint -1] for i in range(length-1)] 16 | 17 | for i in range(length): 18 | if bucket[int((length-2)*(nums[i]-min_nums)/diff)][0] > nums[i]: 19 | bucket[int((length-2)*(nums[i]-min_nums)/diff)][0] = nums[i] 20 | if bucket[int((length-2)*(nums[i]-min_nums)/diff)][1] < nums[i]: 21 | bucket[int((length-2)*(nums[i]-min_nums)/diff)][1] = nums[i] 22 | 23 | #print bucket 24 | 25 | max_diff = bucket[0][1] - bucket[0][0] 26 | prev_max = bucket[0][1] 27 | for i in range(1,length-1): 28 | if bucket[i][0] != sys.maxint: 29 | current_min = bucket[i][0] 30 | max_diff = max(max_diff, current_min-prev_max) 31 | max_diff = max(max_diff, bucket[i][1] - bucket[i][0]) 32 | prev_max = bucket[i][1] 33 | #print bucket[i] 34 | 35 | return max_diff 36 | 37 | -------------------------------------------------------------------------------- /Graphs/Multiple.cpp: -------------------------------------------------------------------------------- 1 | string Solution::multiple(int n) { 2 | vector flag, parent, val; 3 | flag.clear(), parent.clear(), val.clear(); 4 | flag.resize(n), parent.resize(n), val.resize(n); 5 | int p; 6 | int q; 7 | int i; 8 | int tot = 0; 9 | 10 | //final string 11 | string ret = ""; 12 | 13 | //queue for bfs 14 | queue Q; 15 | 16 | //initial node 17 | int temp = 1%n; 18 | flag[temp] = 1; 19 | val[temp] = 1; 20 | Q.push(temp); 21 | 22 | while(true) { 23 | 24 | //pop from queue 25 | temp = Q.front(); 26 | Q.pop(); 27 | p = temp; 28 | 29 | //reached final state 30 | //build solution here 31 | if(p == 0) { 32 | 33 | p =0; 34 | ret += (char)(val[p]+'0'); 35 | p = parent[p]; 36 | while(p != 0) { 37 | 38 | ret += (char)(val[p]+'0'); 39 | p = parent[p]; 40 | } 41 | 42 | reverse(ret.begin(), ret.end()); 43 | return ret; 44 | } 45 | 46 | //visit two neighbors p*10 and p*10+1 47 | //if already not visited 48 | q = (p*10) % n; 49 | 50 | if(flag[q] == 0) 51 | Q.push(q), flag[q] = 1, parent[q] = p, val[q]=0; 52 | 53 | q++; 54 | 55 | if(q >= n) q -= n; 56 | 57 | if(flag[q] == 0) 58 | Q.push(q), flag[q] = 1, parent[q] = p, val[q] = 1; 59 | } 60 | } 61 | 62 | 63 | 64 | -------------------------------------------------------------------------------- /Binary Search/SearchRotated.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : tuple of integers 3 | # @param B : integer 4 | # @return an integer 5 | def search(self, A, B): 6 | 7 | if len(A) == 1: 8 | return 1 if A[0] == B else 0 9 | 10 | i = 1 11 | start = 0 12 | end = len(A) - 1 13 | 14 | while A[start] > A[end]: 15 | mid = (start + end) / 2 16 | #print mid 17 | if A[mid] < A[start]: 18 | end = mid 19 | elif A[mid] > A[end]: 20 | start = mid + 1 21 | 22 | actual_start = start 23 | 24 | if actual_start != 0: 25 | if A[actual_start - 1] > B and A[0] < B: 26 | start = 0 27 | end = actual_start -1 28 | elif A[actual_start - 1] < B: 29 | return 0 30 | else: 31 | start = actual_start 32 | end = len(A) - 1 33 | else: 34 | start = 0 35 | end = len(A) - 1 36 | 37 | 38 | while start < end: 39 | mid = (start + end) /2 40 | 41 | if A[mid] < B: 42 | start = mid + 1 43 | elif A[mid] > B: 44 | end = mid 45 | else: 46 | return mid 47 | 48 | 49 | return end if A[end] == B else -1 50 | 51 | 52 | 53 | 54 | 55 | 56 | -------------------------------------------------------------------------------- /Trees/Path.py: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node 2 | # class TreeNode: 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.left = None 6 | # self.right = None 7 | 8 | class Solution: 9 | # @param A : root node of tree 10 | # @param B : integer 11 | # @return an integer 12 | def hasPathSum(self, root, target): 13 | ''' 14 | if not A: 15 | return 0 16 | return self.helper(A, B) 17 | 18 | def helper(self, root, target): 19 | 20 | if root: 21 | if not root.left and not root.right: 22 | if target == root.val: 23 | return 1 24 | else: 25 | return 0 26 | 27 | if root.left: 28 | if self.helper(root.left, target-root.val): 29 | return 1 30 | if root.right: 31 | if self.helper(root.right, target-root.val): 32 | return 1 33 | 34 | return 0 35 | 36 | ''' 37 | 38 | if not root: 39 | return 0 40 | else: 41 | target -= root.val 42 | if not (root.left or root.right): 43 | return 1 if not target else 0 44 | if root.left: 45 | if self.hasPathSum(root.left, target): 46 | return 1 47 | if root.right: 48 | if self.hasPathSum(root.right, target): 49 | return 1 50 | 51 | return 0 52 | 53 | -------------------------------------------------------------------------------- /Binary Search/SearchRange.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : tuple of integers 3 | # @param B : integer 4 | # @return a list of integers 5 | import copy 6 | def searchRange(self, A, B): 7 | start = 0 8 | end = len(A) - 1 9 | 10 | mid = (start + end)/2 11 | if A[start] > B: return [-1,-1] 12 | if A[end] < B: return [-1,-1] 13 | while not(B == A[mid] and B != A[mid-1]): 14 | if B < A[mid] or (mid > 0 and B == A[mid-1]): 15 | end = mid 16 | elif B > A[mid]: 17 | start = mid 18 | mid = (start + end) / 2 19 | if start == end -1 and A[mid] != B: 20 | return [-1,-1] 21 | if mid == 0 : 22 | break 23 | 24 | 25 | 26 | 27 | final_start = mid 28 | 29 | 30 | start = 0 31 | end = len(A) -1 32 | mid = (start + end )/2 33 | while B != A[mid] or (mid < len(A) -1 and B == A[mid+1]): 34 | if A[len(A)-1] == B: 35 | mid = len(A) -1 36 | break 37 | if B < A[mid]: 38 | end = mid 39 | elif B > A[mid] or (mid < len(A) - 1 and B == A[mid+1]): 40 | start = mid 41 | mid = (start + end)/2 42 | if mid == 0 and B== A[mid]: 43 | break 44 | 45 | if start == end -1 and A[mid] != B: 46 | return [-1,-1] 47 | 48 | 49 | return [final_start, mid] 50 | 51 | 52 | -------------------------------------------------------------------------------- /Trees/Recover.py: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node 2 | # class TreeNode: 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.left = None 6 | # self.right = None 7 | 8 | class Solution: 9 | # @param A : root node of tree 10 | # @return a list of integers 11 | def recoverTree(self, A): 12 | import sys 13 | anomaly1 = None 14 | anomaly2 = None 15 | last_value = - sys.maxint - 1 16 | st = [] 17 | #l = [] 18 | st.append(A) 19 | while st: 20 | u = st[-1] 21 | #st = st[:-1] 22 | if u.right: 23 | st = st[:-1] + [u.right] + [st[-1]] 24 | u.right = None 25 | #st.append(u) 26 | if u.left: 27 | st.append(u.left) 28 | u.left = None 29 | else: 30 | #print u 31 | st = st[:-1] 32 | if anomaly1 == None and last_value > u.val: 33 | anomaly1 = last_value 34 | #l.append(anomaly1) 35 | last_value = u.val 36 | anomaly1_next_val = u.val 37 | elif last_value < u.val: 38 | last_value = u.val 39 | elif anomaly1 != None and last_value > u.val: 40 | anomaly2 = u.val 41 | #l.append(anomaly2) 42 | break 43 | 44 | #print l 45 | if anomaly2 == None: return [anomaly1_next_val, anomaly1] 46 | else: return [anomaly2, anomaly1] 47 | 48 | 49 | -------------------------------------------------------------------------------- /Math/Rank2.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : string 3 | # @return an integer 4 | def findRank(self, A): 5 | l = sorted(list(A)) 6 | rank = 1 7 | length = len(A) 8 | 9 | for i in range(len(A)): 10 | shifts = calc_permus(length - i -1, l, A[i]) 11 | l.remove(A[i]) 12 | for s in shifts: 13 | rank += s % 1000003 14 | 15 | return rank % 1000003 16 | 17 | def calc_permus(n, l, a): 18 | 19 | #total permus 20 | f = 1 21 | for j in range(n): 22 | f *= (j + 1) % 1000003 23 | 24 | #preceding characters 25 | i = 0 26 | while l[i] != a: 27 | i += 1 28 | 29 | list_of_preceding_chars = l[:i] 30 | other_list = l[i:] 31 | rs = findRepeatedCharacters(list_of_preceding_chars) 32 | other_rs = findRepeatedCharacters(other_list) 33 | for r in other_rs: 34 | for j in range(r): 35 | f /= (j+1) 36 | 37 | shifts = [] 38 | for i in range(len(rs)): 39 | new_f = f 40 | for j in range(len(rs)): 41 | if i != j: 42 | for k in range(rs[j]): 43 | new_f /= (k + 1) % 1000003 44 | else: 45 | for k in range(0, rs[j]-1): 46 | new_f /= (k + 1) % 1000003 47 | shifts.append(new_f) 48 | 49 | return shifts 50 | 51 | 52 | 53 | def findRepeatedCharacters(l): 54 | n = [] 55 | from collections import Counter 56 | c = Counter(l) 57 | for i in c: 58 | #if c[i] > 1: 59 | n.append(c[i]) 60 | return n 61 | 62 | 63 | -------------------------------------------------------------------------------- /Trees/NextPointer2.py: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node 2 | # class TreeNode: 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.left = None 6 | # self.right = None 7 | 8 | class Solution: 9 | # @param A : root node of tree 10 | # @return a list of list of integers 11 | def zigzagLevelOrder(self, A): 12 | left_q = [] 13 | left_q.append(A) 14 | right_q = [] 15 | left = True 16 | traversal = [] 17 | curr_traverse = [] 18 | while left_q or right_q: 19 | if left: 20 | curr = left_q[-1] 21 | curr_traverse.append(curr.val) 22 | left_q.pop() 23 | 24 | if curr.left: right_q.append(curr.left) 25 | if curr.right: right_q.append(curr.right) 26 | if not left_q: 27 | left = False 28 | traversal.append(curr_traverse) 29 | curr_traverse = [] 30 | else: 31 | curr = right_q[-1] 32 | curr_traverse.append(curr.val) 33 | right_q.pop() 34 | if curr.right: left_q.append(curr.right) 35 | if curr.left: left_q.append(curr.left) 36 | if not right_q: 37 | left = True 38 | traversal.append(curr_traverse) 39 | curr_traverse = [] 40 | 41 | 42 | 43 | return traversal 44 | 45 | 46 | 47 | 48 | 49 | 50 | -------------------------------------------------------------------------------- /Trees/ZigZagTree.py: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node 2 | # class TreeNode: 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.left = None 6 | # self.right = None 7 | 8 | class Solution: 9 | # @param A : root node of tree 10 | # @return a list of list of integers 11 | def zigzagLevelOrder(self, A): 12 | left_q = [] 13 | left_q.append(A) 14 | right_q = [] 15 | left = True 16 | traversal = [] 17 | curr_traverse = [] 18 | while left_q or right_q: 19 | if left: 20 | curr = left_q[-1] 21 | curr_traverse.append(curr.val) 22 | left_q.pop() 23 | 24 | if curr.left: right_q.append(curr.left) 25 | if curr.right: right_q.append(curr.right) 26 | if not left_q: 27 | left = False 28 | traversal.append(curr_traverse) 29 | curr_traverse = [] 30 | else: 31 | curr = right_q[-1] 32 | curr_traverse.append(curr.val) 33 | right_q.pop() 34 | if curr.right: left_q.append(curr.right) 35 | if curr.left: left_q.append(curr.left) 36 | if not right_q: 37 | left = True 38 | traversal.append(curr_traverse) 39 | curr_traverse = [] 40 | 41 | 42 | 43 | return traversal 44 | 45 | 46 | 47 | 48 | 49 | 50 | -------------------------------------------------------------------------------- /Linked Lists/SortList.py: -------------------------------------------------------------------------------- 1 | # Definition for singly-linked list. 2 | # class ListNode: 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.next = None 6 | 7 | class Solution: 8 | # @param A : head node of linked list 9 | # @return the head node in the linked list 10 | def sortList(self, A): 11 | #partition the lists 12 | #merge them and return 13 | return self.mergeSort(A) 14 | 15 | 16 | 17 | def mergeSort(self, A): 18 | if A.next == None : 19 | return A 20 | else: 21 | p1, p2 = self.partitionList(A) 22 | p1 = self.mergeSort(p1) 23 | p2 = self.mergeSort(p2) 24 | A = self.mergeList(p1, p2) 25 | 26 | return A 27 | 28 | def mergeList(self, A, B): 29 | 30 | p1 = A 31 | p2 = B 32 | p1_prev = None 33 | while p1 and p2: 34 | if p1.val <= p2.val: 35 | p1_prev = p1 36 | p1 = p1.next 37 | else: 38 | if p1_prev != None : p1_prev.next = p2 39 | p1, p2 = p2, p1 40 | p1_prev.next = p2 41 | 42 | return A if A.val <= B.val else B 43 | 44 | 45 | def partitionList(self, A): 46 | curr = A 47 | halfway = A 48 | 49 | while curr: 50 | curr = curr.next 51 | if not curr: break 52 | prev = halfway 53 | halfway = halfway.next 54 | curr = curr.next 55 | 56 | prev.next = None 57 | return A, halfway 58 | 59 | -------------------------------------------------------------------------------- /Dynamic Programming/Arrange2.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : string 3 | # @param B : integer 4 | # @return an integer 5 | def arrange(self, A, B): 6 | if len(A.strip()) < B: 7 | return -1 8 | 9 | from sys import maxint 10 | def arrange_util(h, n): 11 | if n == 1: 12 | #print h 13 | white = 0 14 | black = 0 15 | for c in h: 16 | if c == "W": 17 | white += 1 18 | else: 19 | black += 1 20 | 21 | cache[(B-n, len(h))] = white * black 22 | return cache[(B-n, len(h))] 23 | else: 24 | if (B-n, len(h)) not in cache: 25 | num_of_horses = len(h) 26 | max_poss = num_of_horses - n + 1 27 | #print "max_poss: ", max_poss 28 | black = 0 29 | white = 0 30 | cache[(B-n, len(h))] = maxint 31 | 32 | for i in range(max_poss): 33 | if h[i] == "W": 34 | white += 1 35 | else: 36 | black += 1 37 | cache[(B-n, len(h))] = min(white*black + arrange_util(h[i+1:], n - 1), cache[(B-n, len(h))]) 38 | 39 | return cache[(B-n, len(h))] 40 | 41 | cache = {} 42 | res = arrange_util(A.strip(), B) 43 | #print cache 44 | return res 45 | 46 | -------------------------------------------------------------------------------- /Hashing/4Sum.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : list of integers 3 | # @param B : integer 4 | # @return a list of list of integers 5 | def fourSum(self, A, B): 6 | if len(A) < 4: return [] 7 | A = sorted(A) 8 | #print A 9 | d = [] 10 | i = 0 11 | while i < len(A) - 3: 12 | while i > 0 and i < len(A) - 3 and A[i] == A[i-1]: 13 | i += 1 14 | j = i + 1 15 | 16 | while j < len(A)-2: 17 | while j > i + 1 and j < len(A) and A[j] == A[j-1]: 18 | j += 1 19 | 20 | if j >= len (A)- 2: break 21 | 22 | first_pair = A[i] + A[j] 23 | k = j + 1 24 | l = len(A) - 1 25 | while k < l: 26 | while k > j + 1 and k < len(A) and A[k] == A[k-1]: 27 | k += 1 28 | 29 | if k == len(A) or k == l: break 30 | 31 | while l < len(A) - 1 and l > k+1 and A[l] == A[l+1]: 32 | l -= 1 33 | second_pair = A[k] + A[l] 34 | value = second_pair + first_pair 35 | if value == B: 36 | d.append([A[i], A[j], A[k], A[l]]) 37 | k += 1 38 | l -= 1 39 | elif value < B: 40 | k += 1 41 | else: 42 | l -= 1 43 | j += 1 44 | i += 1 45 | 46 | return sorted(d) 47 | 48 | -------------------------------------------------------------------------------- /Binary Search/MedianArray.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : tuple of integers 3 | # @param B : tuple of integers 4 | # @return a double 5 | def findMedianSortedArrays(self, A, B): 6 | m = len(A) 7 | n = len(B) 8 | if m > n: 9 | n,m = m,n 10 | A,B = B,A 11 | if m == 0: 12 | if n == 0: 13 | return 0 14 | if n%2: 15 | return B[n/2] 16 | else: 17 | return (B[n/2]+B[n/2-1])/2.0 18 | low = 0 19 | high = m 20 | while low <= high: 21 | i = (low+high)/2 22 | j = (m+n+1)/2-i 23 | if (j == 0 or i == m or B[j - 1] <= A[i]) and (i == 0 or j == n or A[i-1] <= B[j]): 24 | if (m+n)%2: 25 | if i == 0: 26 | return B[j-1] 27 | elif j == 0: 28 | return A[i-1] 29 | return max(A[i-1],B[j-1]) 30 | else: 31 | if i == 0: 32 | return (B[j-1] + min(A[i],B[j]))/2.0 33 | if j == 0: 34 | return (A[i-1] + min(A[i],B[j]))/2.0 35 | if i == m: 36 | return (max(A[i-1],B[j-1]) + B[j])/2.0 37 | if j == n: 38 | return (max(A[i-1],B[j-1]) + A[i])/2.0 39 | return (max(A[i-1],B[j-1]) + min(A[i],B[j]))/2.0 40 | elif (j == 0 or i == m or B[j - 1] > A[i]): 41 | low = i+1 42 | elif (i == 0 or j == n or A[i-1] > B[j]): 43 | high = i-1 44 | return -1 45 | 46 | 47 | -------------------------------------------------------------------------------- /Greedy/Seats.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : string 3 | # @return an integer 4 | def seats(self, A): 5 | xcount = 0 6 | pos = [] 7 | 8 | for i in range(len(A)): 9 | if A[i] == 'x': 10 | xcount += 1 11 | pos.append(i) 12 | 13 | if xcount == 0: return 0 14 | elif xcount == len(A): return 0 15 | 16 | centre_of_mass = pos[len(pos)/2] 17 | 18 | #print "centre of mass: ", centre_of_mass 19 | 20 | for i in range(centre_of_mass, -1, -1): 21 | start = i 22 | if A[i] != 'x': 23 | break 24 | 25 | for i in range(centre_of_mass, len(A)): 26 | max_i = i 27 | if A[i] != 'x': 28 | break 29 | 30 | start += 1 31 | max_i -= 1 32 | 33 | #print "start: ", start 34 | #print "end: ", max_i 35 | 36 | ldist = 0 37 | if start != 0: 38 | count = 0 39 | 40 | for i in range(start-1, -1, -1): 41 | if A[i] == 'x': 42 | ldist += start - i - count - 1 43 | count += 1 44 | 45 | #print "ldist: ", ldist 46 | rdist = 0 47 | if max_i != len(A): 48 | count = 0 49 | for i in range(max_i+1, len(A)): 50 | if A[i] == 'x': 51 | rdist += i - max_i - count -1 52 | count += 1 53 | 54 | 55 | #print "rdist: ", rdist 56 | 57 | return (ldist + rdist) % 10000003 58 | 59 | -------------------------------------------------------------------------------- /Dynamic Programming/AvgSet.py: -------------------------------------------------------------------------------- 1 | from collections import defaultdict 2 | 3 | def ispossible(A,start,inset,target,cache): 4 | #print (start,inset,target) 5 | if inset == 0: 6 | if abs(target) < 1e-6: 7 | #print '\tSuccess' 8 | return True 9 | else: 10 | #print '\tOut of elem fail' 11 | return False 12 | 13 | if start == len(A): 14 | #print '\tEnd of list fail' 15 | return False 16 | 17 | 18 | key = (start,inset,target) 19 | if key in cache: 20 | return cache[key] 21 | sol = ispossible(A,start+1,inset-1,target - A[start],cache)\ 22 | or ispossible(A,start+1,inset,target,cache) 23 | cache[key] = sol 24 | return sol 25 | 26 | class Solution: 27 | # @param A : list of integers 28 | # @return a list of list of integers 29 | def avgset(self, A): 30 | A = sorted(A) 31 | avg = float(sum(A)) / float(len(A)) 32 | 33 | I = None 34 | Total = None 35 | for i in xrange(1, len(A)/2 + 1): 36 | if not ispossible(A,0,i,i*avg,{}): 37 | continue 38 | I = i 39 | Total = i*avg 40 | break 41 | if not I: 42 | return [] 43 | 44 | cache = {} 45 | a = [] 46 | b = [] 47 | for j in xrange(len(A)): 48 | if ispossible(A,j+1,I-1,Total-A[j],cache): 49 | a.append(A[j]) 50 | I -= 1 51 | Total -= A[j] 52 | else: 53 | assert(ispossible(A,j+1,I,Total,cache)) 54 | b.append(A[j]) 55 | 56 | return [sorted(a),sorted(b)] 57 | 58 | -------------------------------------------------------------------------------- /Trees/Prefix.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : list of strings 3 | # @return a list of strings 4 | def prefix(self, A): 5 | trie = self.make_trie(*A) 6 | #print trie 7 | prefix_list = self.traverse_trie(trie) 8 | new_pre = [] 9 | for word in A: 10 | for pre in prefix_list: 11 | if word.startswith(pre): 12 | new_pre.append(pre) 13 | 14 | return new_pre 15 | 16 | 17 | def traverse_trie(self, root): 18 | prefix_list = [] 19 | 20 | if root[1] == 1: 21 | return root[0].keys() 22 | 23 | for node in root[0]: 24 | #prefix_list = [] 25 | #print "node is : ", node 26 | if root[0][node][1] <= 1: 27 | prefix_list.append(node[0]) 28 | 29 | else: 30 | for pre in self.traverse_trie(root[0][node]): 31 | prefix_list.append(node[0]+ pre) 32 | 33 | 34 | return prefix_list 35 | 36 | 37 | 38 | 39 | def make_trie(self, *words): 40 | _end = '_end_' 41 | root = [dict(), 0] 42 | #print words 43 | for word in words: 44 | #print word 45 | current_dict = root 46 | for letter in word: 47 | current_dict[1] += 1 48 | current_dict = current_dict[0] 49 | current_dict = current_dict.setdefault(letter, [{}, 0]) 50 | #current_dict = current_dict[0] 51 | current_dict[0][_end] = (_end,0) 52 | #print current_dict, word 53 | 54 | return root 55 | 56 | -------------------------------------------------------------------------------- /Backtracking/Sudoku.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : list of list of chars 3 | # @return nothing 4 | def solveSudoku(self, A): 5 | board = A 6 | flag = False 7 | 8 | for i in range(9): 9 | for j in range(9): 10 | tried_all_value = 9 11 | if board[i][j] == '.': 12 | for val in map(str,range(1,10)): 13 | if self.checkConstraint(board,val, i ,j): 14 | board[i][j] = val 15 | self.solveSudoku(board) 16 | if board: 17 | flag = True 18 | for row in board: 19 | if '.' in row: 20 | flag = False 21 | break 22 | if flag: break 23 | else: 24 | board[i][j] = '.' 25 | tried_all_value -= 1 26 | if tried_all_value ==0: 27 | return 28 | 29 | if flag:break 30 | 31 | if tried_all_value == 0: 32 | break 33 | if flag: break 34 | 35 | 36 | def checkConstraint(self, board, val,i,j): 37 | if val in board[i]: 38 | return False 39 | 40 | for row in board: 41 | if row[j] == val: 42 | return False 43 | 44 | for m in range(3): 45 | for n in range(3): 46 | if board[(i//3)*3 + m][(j//3)*3 + n] == val: 47 | return False 48 | 49 | return True 50 | 51 | -------------------------------------------------------------------------------- /Backtracking/NQueens.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : integer 3 | # @return a list of list of strings 4 | def solveNQueens(self, A): 5 | board = ["."*A for i in range(A)] 6 | return self.queensHelper(board) 7 | 8 | def queensHelper(self, board): 9 | list_of_boards = [] 10 | board_length = len(board) 11 | row = 0 12 | while row < board_length and 'Q' in board[row]: 13 | row += 1 14 | 15 | if row == board_length: 16 | return [board] 17 | 18 | for col in range(board_length): 19 | board[row] = ['.']*board_length 20 | board[row][col] = 'Q' 21 | board[row] = ''.join(board[row]) 22 | 23 | if self.constraintCheck(board, row, col): 24 | for final_board in self.queensHelper(board): 25 | list_of_boards.append(final_board) 26 | board = board[:row] + ["."*board_length]* (board_length- row) 27 | else: 28 | board = board[:row] + ["."*board_length]* (board_length- row) 29 | pass 30 | 31 | return list_of_boards 32 | 33 | 34 | 35 | def constraintCheck(self, board, row, col): 36 | for i in range(len(board)): 37 | for j in range(len(board)): 38 | if i != row or j != col: 39 | if board[i][j]== 'Q' and (abs(i - row) == abs(j - col)) : 40 | return False 41 | if board[i][j] == 'Q' and j == col: 42 | return False 43 | if board[i][j] == 'Q' and i == row: 44 | return False 45 | 46 | return True 47 | 48 | -------------------------------------------------------------------------------- /Strings/ValidNumber.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : string 3 | # @return an integer 4 | def isNumber(self, A): 5 | 6 | s= A.strip() 7 | 8 | state = 1 9 | for i in range(len(s)): 10 | if state == 1: 11 | if s[i] == '+' or s[i] == '-': state = 2 12 | elif s[i] == '.': state = 4 13 | elif s[i] <='9' and s[i] >='0': state = 3 14 | else: return False 15 | elif state == 2: 16 | if s[i] <='9' and s[i] >='0': state = 3 17 | elif s[i] == '.': state = 4 18 | else: return False 19 | elif state == 3: 20 | if s[i] <='9' and s[i] >='0': state = 3 21 | elif s[i] == '.': state = 4 22 | elif s[i] == 'e': state = 6 23 | else: return False 24 | elif state == 4: 25 | if s[i] <='9' and s[i] >='0': state = 5 26 | else: return False 27 | elif state == 5: 28 | if s[i] <='9' and s[i] >='0': state = 5 29 | elif s[i] == 'e': state = 6 30 | else: return False 31 | elif state == 6: 32 | if s[i] <='9' and s[i] >='0': state = 8 33 | elif s[i] == '+' or s[i] == '-': state = 7 34 | else: return False 35 | elif state == 7: 36 | if s[i] <='9' and s[i] >='0': state = 8 37 | else: return False 38 | elif state == 8: 39 | if s[i] <='9' and s[i] >='0': state = 8 40 | else: return False 41 | 42 | if state == 3 or (state == 5 and A[-1] != '.') or state == 8: return True 43 | else: return False 44 | 45 | -------------------------------------------------------------------------------- /Dynamic Programming/CNTTrue.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : string 3 | # @return an integer 4 | def cnttrue(self, A): 5 | if not A: 6 | return 0 7 | elif len(A) == 1: 8 | return True if A == 'T' else False 9 | 10 | symbols = "".join([A[i] for i in range(len(A)) if (A[i] == "T" or A[i] == "F")]) 11 | operators = "".join([A[i] for i in range(len(A)) if (A[i] != "T" and A[i] != "F")]) 12 | 13 | n = len(symbols) 14 | #print len(symbols) - len(operators) 15 | #print symbols, operators 16 | T = [[0]*n for i in range(n)] 17 | F = [[0]*n for i in range(n)] 18 | for i in range(n): 19 | T[i][i] = 1 if symbols[i] == "T" else 0 20 | F[i][i] = 1 if symbols[i] == "F" else 0 21 | 22 | for gap in range(1, n): 23 | i = -1 24 | for j in range(gap,n): 25 | i += 1 26 | for g in range(gap): 27 | k = i + g 28 | tot_ik = T[i][k] + F[i][k] 29 | tot_kj = T[k+1][j] + F[k+1][j] 30 | if operators[k] == "&": 31 | T[i][j] += T[i][k] * T[k+1][j] 32 | F[i][j] += (tot_ik * tot_kj - T[i][k] * T[k+1][j]) 33 | if operators[k] == "|": 34 | T[i][j] += (tot_ik * tot_kj - F[i][k] * F[k+1][j]) 35 | F[i][j] += F[i][k] * F[k+1][j] 36 | if operators[k] == "^": 37 | T[i][j] += (T[i][k] * F[k+1][j] + F[i][k]*T[k+1][j]) 38 | F[i][j] += (T[i][k] * T[k+1][j] + F[i][k]*F[k+1][j]) 39 | #print T[i][j] 40 | 41 | return T[0][-1]%1003 42 | 43 | -------------------------------------------------------------------------------- /Linked Lists/ReverseList.py: -------------------------------------------------------------------------------- 1 | # Definition for singly-linked list. 2 | # class ListNode: 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.next = None 6 | 7 | class Solution: 8 | # @param A : head node of linked list 9 | # @param m : integer 10 | # @param n : integer 11 | # @return the head node in the linked list 12 | def reverseBetween(self, A, m, n): 13 | head = A 14 | if A.next == None: return A 15 | start_prev = self.search_node(A,m-1) 16 | if start_prev == None: 17 | start = A 18 | part_list_head = self.reverseListTill_n(start, n - m + 1) 19 | return part_list_head 20 | else: 21 | start = start_prev.next 22 | part_list_head = self.reverseListTill_n(start, n - m + 1) 23 | start_prev.next = part_list_head 24 | #print(start_prev.val) 25 | #check what should be the starting node 26 | 27 | 28 | 29 | return head 30 | 31 | def reverseListTill_n(self, A, n): 32 | if A == None: return None 33 | elif A.next == None: return A 34 | else: 35 | count = 1 36 | start = A 37 | prev = A 38 | curr = A.next 39 | while count < n: 40 | next = curr.next 41 | curr.next = prev 42 | prev = curr 43 | curr = next 44 | count += 1 45 | A.next = curr 46 | return prev 47 | 48 | 49 | def search_node(self, A, m): 50 | if m == 0: return None 51 | count = 1 52 | curr = A 53 | while count < m: 54 | curr = curr.next 55 | count += 1 56 | 57 | return curr 58 | 59 | -------------------------------------------------------------------------------- /Arrays/Interval.py: -------------------------------------------------------------------------------- 1 | # Definition for an interval. 2 | # class Interval: 3 | # def __init__(self, s=0, e=0): 4 | # self.start = s 5 | # self.end = e 6 | 7 | class Solution: 8 | # @param intervals, a list of Intervals 9 | # @param newInterval, a Interval 10 | # @return a list of Interval 11 | def insert(self, intervals, newInterval): 12 | 13 | def overlaps(interval1, interval2): 14 | if interval1.start < interval2.start and interval1.end < interval2.start: 15 | return False 16 | if interval1.start > interval2.end and interval1.end > interval2.end: 17 | return False 18 | 19 | return True 20 | 21 | merged_intervals = [] 22 | overlapped = False 23 | if not intervals: 24 | return [newInterval] 25 | elif newInterval.end < intervals[0].start: 26 | return [newInterval]+intervals 27 | elif newInterval.start > intervals[-1].end: 28 | return intervals+[newInterval] 29 | 30 | for i, interval in enumerate(intervals): 31 | if overlaps(interval, newInterval): 32 | newInterval.start = min(newInterval.start, interval.start) 33 | newInterval.end = max(newInterval.end, interval.end) 34 | overlapped = True 35 | else: 36 | if not overlapped and newInterval.start > interval.end: 37 | merged_intervals.append(interval) 38 | else: 39 | break 40 | 41 | merged_intervals += newInterval, 42 | #print intervals[i].start 43 | if merged_intervals[-1].end < intervals[i].start: 44 | merged_intervals += intervals[i:] 45 | 46 | return merged_intervals 47 | -------------------------------------------------------------------------------- /Trees/T2Sum.py: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node 2 | # class TreeNode: 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.left = None 6 | # self.right = None 7 | 8 | class Solution: 9 | # @param A : root node of tree 10 | # @param B : integer 11 | # @return an integer 12 | def t2Sum(self, A, B): 13 | if not A: 14 | return False 15 | curr1 = A 16 | curr2 = A 17 | s1 = [] 18 | s2 = [] 19 | done1 = False 20 | done2 = False 21 | while True: 22 | while not done1: 23 | #inorder 1 24 | if curr1: 25 | s1.append(curr1) 26 | curr1 = curr1.left 27 | else: 28 | if not s1: 29 | done1 = True 30 | continue 31 | curr1 = s1.pop() 32 | val1 = curr1.val 33 | curr1 = curr1.right 34 | done1 = True 35 | 36 | 37 | while not done2: 38 | #inorder 2 39 | if curr2: 40 | s2.append(curr2) 41 | curr2 = curr2.right 42 | else: 43 | if not s2: 44 | done2 = True 45 | continue 46 | curr2 = s2.pop() 47 | val2 = curr2.val 48 | curr2 = curr2.left 49 | done2 = True 50 | 51 | if val1 >= val2: 52 | return 0 53 | 54 | if val1 + val2 == B and val1 != val2: 55 | return 1 56 | 57 | if val1 + val2 < B: 58 | done1 = False 59 | elif val1 + val2 > B: 60 | done2 = False 61 | 62 | 63 | 64 | 65 | 66 | 67 | -------------------------------------------------------------------------------- /Dynamic Programming/IsInterleave.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : string 3 | # @param B : string 4 | # @param C : string 5 | # @return an integer 6 | def isInterleave(self, s1, s2, s3): 7 | ''' 8 | if len(s1)+ len(s2) != len(s3): return 0 9 | elif s1 == '' or s2 == '': return s2==s3 or s1==s3 10 | else: 11 | Arr = [1 for i in range(len(s2)+1)] 12 | for i in range(1,len(s2)+1): 13 | Arr[i] = Arr[i-1] and s3[i-1] == s2[i-1] 14 | for i in range(1,len(s1)+1): 15 | Arr[0] = Arr[0] and s3[i-1] == s1[i-1] 16 | for j in range(1,len(s2)+1): 17 | Arr[j] = (Arr[j-1] and s3[i+j-1] == s2[j-1]) or (Arr[j] and s3[i+j-1]== s1[i-1]) 18 | 19 | return Arr[-1] 20 | ''' 21 | cache = {} 22 | 23 | 24 | def isInterleaveHelper(s1, s2, s3): 25 | if not s1 and not s2 and not s3: 26 | return True 27 | elif not s1: 28 | if s2 == s3: 29 | return True 30 | else: 31 | return False 32 | elif not s2: 33 | if s1 == s3: 34 | return True 35 | else: 36 | return False 37 | 38 | if (len(s1),len(s2),len(s3)) in cache: 39 | return cache[(len(s1),len(s2),len(s3))] 40 | 41 | cache[(len(s1),len(s2),len(s3))] = False 42 | if s1[0] == s3[0]: 43 | if isInterleaveHelper(s1[1:], s2, s3[1:]): 44 | cache[(len(s1),len(s2),len(s3))] = True 45 | return True 46 | 47 | if s2[0] == s3[0]: 48 | if isInterleaveHelper(s1, s2[1:], s3[1:]): 49 | cache[(len(s1),len(s2),len(s3))] = True 50 | return True 51 | 52 | return False 53 | 54 | return isInterleaveHelper(s1,s2,s3) 55 | 56 | -------------------------------------------------------------------------------- /Linked Lists/ReorderList.py: -------------------------------------------------------------------------------- 1 | # Definition for singly-linked list. 2 | # class ListNode: 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.next = None 6 | 7 | class Solution: 8 | # @param A : head node of linked list 9 | # @return the head node in the linked list 10 | def reorderList(self, A): 11 | #if empty list or single node return it as it is 12 | head = A 13 | if head and head.next: 14 | 15 | 16 | #find middle element 17 | #length = 0 18 | curr = head 19 | curr2 = head 20 | while curr: 21 | curr = curr.next 22 | prev = curr2 23 | if curr: 24 | curr = curr.next 25 | curr2 = curr2.next 26 | prev = curr2 27 | else: 28 | prev = curr2 29 | 30 | 31 | prev_p1 = head 32 | prev_p2 = self.reverseList(prev) #reverse the second half of list 33 | curr_p1 = prev_p1.next 34 | curr_p2 = prev_p2.next 35 | 36 | if curr_p1 == prev_p2: 37 | return head 38 | pass 39 | else: 40 | while curr_p1 and curr_p2: 41 | prev_p1.next = prev_p2 42 | prev_p2.next = curr_p1 43 | prev_p1 = curr_p1 44 | prev_p2 = curr_p2 45 | curr_p2 = curr_p2.next 46 | curr_p1 = curr_p1.next 47 | 48 | return head 49 | 50 | def reverseList(self, head): 51 | if not head or not head.next: 52 | return head 53 | 54 | prev = head 55 | curr = head.next 56 | 57 | prev.next = None 58 | 59 | while prev and curr: 60 | temp = curr.next 61 | curr.next = prev 62 | prev = curr 63 | curr = temp 64 | 65 | return prev 66 | 67 | -------------------------------------------------------------------------------- /Strings/TextJust.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param A : list of strings 3 | # @param B : integer 4 | # @return a list of strings 5 | def fullJustify(self, A, B): 6 | words = A 7 | maxWidth = B 8 | if not A: return [] 9 | 10 | if maxWidth == 0: return [""] 11 | 12 | para = [] 13 | line = [] 14 | line_length = 0 15 | no_of_words = 0 16 | 17 | for i in range(len(words)): 18 | 19 | if line_length + len(words[i]) <= maxWidth: 20 | line_length += (len(words[i]) + 1) 21 | line.append(words[i]) 22 | no_of_words += 1 23 | 24 | else: 25 | line_length -= 1 26 | extra_spacing = maxWidth - line_length 27 | s = "" 28 | if no_of_words > 1: 29 | extra_spacing_per_word = (maxWidth - line_length)/(no_of_words-1) 30 | left_extra = (maxWidth - line_length) % (no_of_words-1) 31 | j = 0 32 | 33 | for word in line[:-1]: 34 | if left_extra: 35 | k = 1 36 | left_extra -= 1 37 | else: 38 | k = 0 39 | j += 1 40 | s += word + " "*(extra_spacing_per_word+1) + " "*k 41 | 42 | else: 43 | line[0] = line[0] + (maxWidth - len(line[0]))*" " 44 | s += line[-1] 45 | para.append(s) 46 | 47 | line = [words[i]] 48 | line_length = len(words[i]) + 1 49 | no_of_words = 1 50 | 51 | words_covered = 0 52 | 53 | for line in para: 54 | words_covered += len(line.split()) 55 | 56 | para = para + [' '.join(words[words_covered:])] 57 | para[-1] = para[-1] + " "*(maxWidth- len(para[-1])) 58 | 59 | return para 60 | 61 | -------------------------------------------------------------------------------- /Graphs/WordLadder2.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param start : string 3 | # @param end : string 4 | # @param dictV : list of strings 5 | # @return a list of list of strings 6 | def findLadders(self, beginWord, endWord, dictV): 7 | if beginWord == endWord: 8 | return [[beginWord]] 9 | wordlist = set(dictV) 10 | wordLength = len(beginWord) 11 | fronts = [{beginWord}, {endWord}] 12 | ans = [] 13 | parents = {beginWord: None, endWord: None} 14 | wordlist.discard(beginWord) 15 | wordlist.discard(endWord) 16 | import string 17 | while fronts[0] and fronts[1] and not ans: 18 | if len(fronts[0]) > len(fronts[1]): 19 | fronts.reverse() 20 | 21 | newLevel = set() 22 | for word in fronts[0]: 23 | for i in range(wordLength): 24 | for c in string.lowercase: 25 | if c == word: 26 | continue 27 | newWord = word[:i] + c + word[i+1:] 28 | if newWord in fronts[1]: 29 | self.buildLadders(word, newWord, beginWord, endWord, parents, ans) 30 | if newWord in newLevel: 31 | parents[newWord].append(word) 32 | if newWord in wordlist: 33 | newLevel.add(newWord) 34 | wordlist.remove(newWord) 35 | parents[newWord] = [word] 36 | 37 | fronts[0] = newLevel 38 | 39 | return ans 40 | 41 | def buildLadders(self, aword, bword, beginWord, endWord, parents, ans): 42 | paths = [[],[]] 43 | path1 = [aword] 44 | self._build(path1, parents, paths[0]) 45 | path2 = [bword] 46 | self._build(path2, parents, paths[1]) 47 | 48 | if paths[0][0][-1] != beginWord: 49 | paths.reverse() 50 | 51 | for path in paths[0]: 52 | path.reverse() 53 | 54 | 55 | for prefix in paths[0]: 56 | for suffix in paths[1]: 57 | ans.append(prefix + suffix) 58 | 59 | def _build(self,path, parents, paths): 60 | #print path 61 | if not parents[path[-1]]: 62 | paths.append(path[:]) 63 | else: 64 | for nextWord in parents[path[-1]]: 65 | path.append(nextWord) 66 | self._build(path, parents, paths) 67 | path.pop() 68 | 69 | 70 | -------------------------------------------------------------------------------- /Trees/Order.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param heights : list of integers 3 | # @param infronts : list of integers 4 | # @return a list of integers 5 | 6 | def order(self, heights, infronts): 7 | h_i = zip(heights, infronts) 8 | sorted_heights = sorted(h_i) 9 | 10 | segment_tree = [[[0,0],0]] * 2 * (len(heights)+1) 11 | 12 | segment_tree[0] = [[0, len(heights)-1], 0] 13 | 14 | for i in range(len(segment_tree)/2 - 1): 15 | l = segment_tree[i][0][0] 16 | r = segment_tree[i][0][1] 17 | segment_tree[2*i+ 1] = [[l, (r+l)/2], 0] 18 | segment_tree[2*i + 2] = [[(r+l)/2 + 1, r], 0] 19 | 20 | 21 | #print segment_tree 22 | #print sorted_heights 23 | actual_order = ['-']*len(heights) 24 | 25 | # s = segment_tree(len(heights)) 26 | 27 | for i in range(len(sorted_heights)): 28 | #pos = s.findposition(sorted_heights[i]) 29 | pos, segment_tree = self.findposition(segment_tree, 0, sorted_heights[i][1]) 30 | #print pos 31 | #while k <= sorted_heights[i][1]: 32 | # if actual_order[j] == '-': 33 | # k += 1 34 | # j += 1 35 | #print actual_order 36 | 37 | actual_order[pos] = sorted_heights[i][0] 38 | 39 | return actual_order 40 | 41 | 42 | def findposition(self, segment_tree, i, pos): 43 | segment_tree[i][1] += 1 44 | #print segment_tree[i][1] 45 | if segment_tree[i][0][0] == segment_tree[i][0][1]: 46 | #print 47 | return segment_tree[i][0][0], segment_tree 48 | else: 49 | if segment_tree[2*i+1][0][1] - segment_tree[2*i+1][0][0] - segment_tree[2*i+1][1] >= pos: 50 | #print "going left ", segment_tree 51 | #print segment_tree[2*i+1][0][1], segment_tree[2*i+1][0][0], segment_tree[2*i+1][1], pos 52 | return self.findposition(segment_tree, 2*i + 1, pos) 53 | 54 | else: 55 | #print "going right ", segment_tree 56 | return self.findposition(segment_tree, 2*i + 2, pos - (segment_tree[2*i+1][0][1] + 1 - segment_tree[2*i+1][0][0] - segment_tree[2*i+1][1])) 57 | 58 | 59 | 60 | #class segment_tree: 61 | # def __init__(self, N): 62 | # self.N = N 63 | # self.val = 0 64 | # self.left = None 65 | # self.right = None 66 | # 67 | ## 68 | # def findposition(self, pos): 69 | # if (self.N)/2 == self.val: return ..... 70 | # 71 | # if (self.N)/2 - self.val >= i: 72 | # self.val += 1 73 | # if not self.left: 74 | # self.left = segment_tree(self.N/2) 75 | # 76 | # self.left.findposition(pos) 77 | 78 | 79 | 80 | 81 | --------------------------------------------------------------------------------