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)O(2L)O(2L),其中LLL为字符串长度。
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