leetcode training_string(1)

STR

1. problem description:For a given source string and a target string, you should output thefirstindex(from 0) of target string in source string. If target does not exist in source, just return-1.

anlysis: for str searching, double for loops are needed; KMP algorithm may be more efficient.

code:

def strsearch(source,target):    if source is None or target is None:        return -1    for i in range(len(source)-len(target)+1):        for j in range(len(target)):            if source[i+j]!=target[j]:                break        else:        return 1    return -1strsearch('abcdefg','abd')#The first "else" focus on j,for any i, if there is proper j suitable for the conditions,return 1;The last "return" focus on i, if all i are not suitable, return -1 will occur after breaking fromthe last loop.#Notes: c1.considering questions, None is first; the second loop is second; the last loop is third.2.Time complexity: n*(n-m)  method: find the maximum counts for every execution and multiply them together.

Two Strings Are Anagrams

Write a method anagram(s,t) to decide if two strings are anagrams or not.ExampleGiven s="abcd", t="dcab", return true.ChallengeO(n) time, O(1) extra space

def anagram(s,t):    if s is None or t is None:        return -1    if len(s)!=len(t):        return -1    for i in range(len(s)):        r=0for j in range(len(t)):                if s[i]==t[j]:                r=r+1            else:r=r+0if r!=1:    return False    return True             anagram('abcd','bdac')##calculate the character counts. Notes:1.draw the flow chart is useful for thinking2.considering questions: None is first;two aspects for the second loop(true or false);the last is the last loop.import collectionsdef anagram(s,t):    return collections.Counter(s)==collections.Counter(t)or: sorted(s)==sorted(t)These two functions are useful.3.Time complexity for my code:n*m for the answer:n    

Compare Strings

Compare two strings A and B, determine whether A contains all of the characters in B.The characters in string A and B are all Upper Case letters.ExampleFor A = "ABCD", B = "ABC", return true.For A = "ABCD" B = "AABC", return false.

METHOD 1:
def compare(s,t):    if s is None or t is None:return False    return colletions.Counter(s)>=colletions.Counter(t)Python 的dict就是hash， 所以python 在处理需要用到hash的地方非常方便。METHOD 2:def compare(s,t):    letters=collections.defaultdict(int)    for a in s:        letters[a]+=1    for b in t:        if b not in letters:            return False    return True    compare('abccd','abcd')

NOtes:1.Time complecxity: 2n2.The two methods are both OK, and I thinkelifletters[b]<=0:returnFalse is not needed.
Anagrams
Given an array of strings, return all groups of strings that are anagrams.ExampleGiven ["lint", "intl", "inlt", "code"], return ["lint", "inlt", "intl"].Given ["ab", "ba", "cd", "dc", "e"], return ["ab", "ba", "cd", "dc"].NoteAll inputs will be in lower-case
anagram_list(["lint", "intl", "inlt", "code"])Notes:1.At first, I begin to think looking at the answers directly, during the thinking process, it occurs to me that it is useful to split complex questions into simple questions, which means to definite two functions of anagrams and anagram_list.class Solution:    # @param strs: A list of strings    # @return: A list of strings    # @return: A list of strings    def anagrams(self, strs):        if len(strs) < 2 :            return strs        result=[]        visited=[False]*len(strs)        for index1,s1 in enumerate(strs):            hasAnagrams = False            for index2,s2 in enumerate(strs):                if index2 > index1 and not visited[index2] and self.isAnagrams(s1,s2):                    result.append(s2)                    visited[index2]=True                    hasAnagrams = True            if not visited[index1] and hasAnagrams:                result.append(s1)        return result    def isAnagrams(self, str1, str2):        if  sorted (str1) == sorted(str2):                return True        return False


2.Acutally I think if there is no explicit requirements for true or false, numbers may be a more efficient tool to use.
The method above is too complex in my opinion.
3.Time complexity:私有方法isAnagrams最坏的时间复杂度为$O(2L)$,其中$L$为字符串长度。
  
def anagrams(strs):        strDict={}        result=[]        for string in strs:            if  "".join(sorted(string)) not in strDict.keys():                strDict["".join(sorted(string))] = 1            else:                 strDict["".join(sorted(string))] += 1        for string in strs:            if strDict["".join(sorted(string))] >1:                result.append(string)        return resultThe method above is deserved to think about.

Longest Common Substring
Given two strings, find the longest common substring.Return the lengthof it.ExampleGiven A="ABCD", B="CBCE",return2.NoteThe charactersin substring should occur continuouslyin original string.This is different with subsequence.
class Solution:    # @param A, B: Two string.    # @return: the length of the longest common substring.    def longestCommonSubstring(self, A, B):        # write your code here        ans = 0        for i in xrange(len(A)):            for j in xrange(len(B)):                l = 0                while i + l < len(A) and j + l < len(B) \                    and A[i + l] == B[j + l]:                    l += 1                if l > ans:                    ans = l        return ans
##source:  http://www.jiuzhang.com/solutions/longest-common-substring/
Notes: I don't solve this problem, and this is the answer I find.The core code is the most important as far as I'm concerned.
A[i + l] == B[j + l]: l += 1

Rotate String
Given a string and an offset, rotate string by offset. (rotate from left to
right)
offset=0 =>"abcdefg"offset=1 =>"gabcdef"offset=2 =>"fgabcde"offset=3 =>"efgabcd"
def rotate(s,offset):    offset=offset%len(s)    a=""    for i in range(offset):        a=a+(s[len(s)-offset+i])    for j in range(len(s)-offset):        a=a+(s[j])    return a        rotate("abcdefg",0)

Notes:
1.None is also the first and here I forget this one.
2.The answer below is useful. Reverse and slice in python should be kept in heart.
class Solution:    """    param A: A string    param offset: Rotate string with offset.    return: Rotated string.    """    def rotateString(self, A, offset):        if A is None or len(A) == 0:            return A        offset %= len(A)        before = A[:len(A) - offset]        after = A[len(A) - offset:]        # [::-1] means reverse in Python        A = before[::-1] + after[::-1]        A = A[::-1]        return A