6 more

Author: RealHacker

186_reverse_words_in_a_string/problem.txt

@@ -0,0 +1,11 @@
+Given an input string, reverse the string word by word. A word is defined as a sequence of non-space characters.
+
+The input string does not contain leading or trailing spaces and the words are always separated by a single space.
+
+For example,
+Given s = "the sky is blue",
+return "blue is sky the".
+
+Could you do it in-place without allocating extra space?
+
+Related problem: Rotate Array

186_reverse_words_in_a_string/reverse.py

@@ -0,0 +1,24 @@
+class Solution(object):
+    def reverseWords(self, s):
+        """
+        :type s: a list of 1 length strings (List[str])
+        :rtype: nothing
+        """
+        if not s:
+            return
+        start=-1
+        for i, c in enumerate(s):
+            if c==" ":
+                if start>=0:
+                    for k in range((i-start)/2):
+                      s[start+k], s[i-1-k] = s[i-1-k], s[start+k]
+                    start = -1
+            else:
+                if start<0:
+                    start = i
+        i = len(s)
+        if start>=0:
+            for k in range((i-start)/2):
+                s[start+k], s[i-1-k] = s[i-1-k], s[start+k]
+        s.reverse()
+        

243_shortest_word_distance/problem.txt

@@ -0,0 +1,10 @@
+Given a list of words and two words word1 and word2, return the shortest distance between these two words in the list.
+
+For example,
+Assume that words = ["practice", "makes", "perfect", "coding", "makes"].
+
+Given word1 = ��coding��, word2 = ��practice��, return 3.
+Given word1 = "makes", word2 = "coding", return 1.
+
+Note:
+You may assume that word1 does not equal to word2, and word1 and word2 are both in the list.

243_shortest_word_distance/shortest.py

@@ -0,0 +1,22 @@
+class Solution(object):
+    def shortestDistance(self, words, word1, word2):
+        """
+        :type words: List[str]
+        :type word1: str
+        :type word2: str
+        :rtype: int
+        """
+        idx1 = -1
+        idx2 = -1
+        shortest = len(words)+1
+        for i, word in enumerate(words):
+            if word==word1:
+                idx1 = i
+                if idx2>=0 and idx1-idx2<shortest:
+                    shortest = idx1-idx2
+            elif word==word2:
+                idx2 = i 
+                if idx1>=0 and idx2-idx1<shortest:
+                    shortest = idx2-idx1
+        return shortest
+                    

244_shortest_word_distance_ii/problem.txt

@@ -0,0 +1,12 @@
+This is a follow up of Shortest Word Distance. The only difference is now you are given the list of words and your method will be called repeatedly many times with different parameters. How would you optimize it?
+
+Design a class which receives a list of words in the constructor, and implements a method that takes two words word1 and word2 and return the shortest distance between these two words in the list.
+
+For example,
+Assume that words = ["practice", "makes", "perfect", "coding", "makes"].
+
+Given word1 = ��coding��, word2 = ��practice��, return 3.
+Given word1 = "makes", word2 = "coding", return 1.
+
+Note:
+You may assume that word1 does not equal to word2, and word1 and word2 are both in the list.

244_shortest_word_distance_ii/shortest.py

@@ -0,0 +1,46 @@
+from collections import defaultdict
+class WordDistance(object):
+    def __init__(self, words):
+        """
+        initialize your data structure here.
+        :type words: List[str]
+        """
+        self.indice = defaultdict(list)
+        self.memo = {}
+        self.MAXLEN = len(words)
+        for i, word in enumerate(words):
+            self.indice[word].append(i)
+        
+    def shortest(self, word1, word2):
+        """
+        Adds a word into the data structure.
+        :type word1: str
+        :type word2: str
+        :rtype: int
+        """
+        if (word1, word2) in self.memo:
+            return self.memo[(word1, word2)]
+            
+        l1, l2 = self.indice[word1], self.indice[word2]
+
+        idx1, idx2 = 0, 0
+        min_distance = self.MAXLEN
+        while True:
+            if idx1 >= len(l1) or idx2 >= len(l2):
+                break
+            if l1[idx1]<l2[idx2]:
+                if l2[idx2]-l1[idx1]<min_distance:
+                    min_distance = l2[idx2]-l1[idx1]
+                idx1 +=1
+            else:
+                if l1[idx1]-l2[idx2]<min_distance:
+                    min_distance = l1[idx1]-l2[idx2]
+                idx2+=1
+        self.memo[(word1, word2)] = min_distance
+        return min_distance
+            
+            
+# Your WordDistance object will be instantiated and called as such:
+# wordDistance = WordDistance(words)
+# wordDistance.shortest("word1", "word2")
+# wordDistance.shortest("anotherWord1", "anotherWord2")

245_shortest_word_distance_iii/shortest.py

@@ -0,0 +1,32 @@
+class Solution(object):
+    def shortestWordDistance(self, words, word1, word2):
+        """
+        :type words: List[str]
+        :type word1: str
+        :type word2: str
+        :rtype: int
+        """
+        if word1!=word2:
+            idx1 = -1
+            idx2 = -1
+            shortest = len(words)+1
+            for i, word in enumerate(words):
+                if word==word1:
+                    idx1 = i
+                    if idx2>=0 and idx1-idx2<shortest:
+                        shortest = idx1-idx2
+                elif word==word2:
+                    idx2 = i 
+                    if idx1>=0 and idx2-idx1<shortest:
+                        shortest = idx2-idx1
+            return shortest
+        else:
+            idx = -1
+            shortest = len(words)
+            for i, word in enumerate(words):
+                if word==word1:
+                    if idx>=0:
+                        shortest = min(shortest, i-idx)
+                    idx = i
+            return shortest
+                    

246_strobogrammatic_number/strobo.py

@@ -0,0 +1,18 @@
+class Solution(object):
+    def isStrobogrammatic(self, num):
+        """
+        :type num: str
+        :rtype: bool
+        """
+        pairs = {"1":"1","0":"0", "8":"8", "6":"9","9":"6"}
+        if len(num)%2==0:
+            half = len(num)/2
+        else:
+            half = len(num)/2+1
+        for i in range(half):
+            if num[i] not in pairs:
+                return False
+            if pairs[num[i]]!=num[len(num)-1-i]:
+                return False
+        return True
+        

247_strobogrammatic_number_ii/problem.txt

@@ -0,0 +1,10 @@
+A strobogrammatic number is a number that looks the same when rotated 180 degrees (looked at upside down).
+
+Find all strobogrammatic numbers that are of length = n.
+
+For example,
+Given n = 2, return ["11","69","88","96"].
+
+Hint:
+
+Try to use recursion and notice that it should recurse with n - 2 instead of n - 1.

247_strobogrammatic_number_ii/strobo.py

@@ -0,0 +1,25 @@
+class Solution(object):
+    pairs = [("0","0"), ("1","1"),("8","8"),("6","9"), ("9","6")]
+    def findStrobogrammatic(self, n):
+        """
+        :type n: int
+        :rtype: List[str]
+        """
+        return self.recurse(n, n)
+        
+    def recurse(self, n, N):
+        if n==0:
+            return [""]
+        elif n==1:
+            return ["0", "1", "8"]
+        else:
+            result = []
+            if n!=N:
+                for s in self.recurse(n-2, N):
+                    for prefix, suffix in self.pairs:
+                        result.append(prefix+s+suffix)
+            else:
+                for s in self.recurse(n-2, N):
+                    for prefix, suffix in self.pairs[1:]:
+                        result.append(prefix+s+suffix)
+            return result