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 -1

strsearch('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 from
the last loop.

#Notes: c
1.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.

Example
Given s="abcd", t="dcab", return true.

Challenge
O(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=0
	for j in range(len(t)):    
            if s[i]==t[j]:
                r=r+1
            else:
		r=r+0
	if r!=1:
	    return False
    return True 
            
anagram('abcd','bdac')

##calculate the character counts. 
Notes:
1.draw the flow chart is useful for thinking
2.considering questions: None is first;two aspects for the second loop(true or false);the last is the last loop.

import collections
def 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.

Example
For 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.

Example
Given ["lint", "intl", "inlt", "code"], return ["lint", "inlt", "intl"].

Given ["ab", "ba", "cd", "dc", "e"], return ["ab", "ba", "cd", "dc"].
Note
All 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 result



The 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",return 2.NoteThe charactersin substring should occur continuously in 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