#求字符串的全排列
if __name__ == "__main__":
str1 = "abcd"
def permunation_transe(str1):#permunation序列，排序
list_str = list(str1)
Permunation(list_str,0)
def swap(str,i,j):
str[i],str[j] = str[j],str[i]
def Permunation(list_str,start):
if list_str ==None:
return
assert 0<=start<len(list_str)
if start == len(list_str)-1:
print("".join(list_str))
else:
i =start
while i <len(list_str):
swap(list_str,start,i)
Permunation(list_str,start+1)
swap(list_str,start,i)
i+=1
if __name__ == "__main__":
str1 = "abab"
permunation_transe(str1)
#如何去掉重复排列
def isDuplicate(str,begin,end):
i =begin
while i < end:
if str[i] == str[end]:
return False
i+=1
return True
def swap(str,i,j):
str[i],str[j]=str[j],str[i]
def Permutation(str_list,start):
assert str_list != None
assert 0<=start < len(str_list)
if start == len(str_list)-1:
print("".join(str_list))
else:
i =start
while i < len(str_list):
if not isDuplicate(str_list,start,i):
i+=1
continue
swap(str_list,start,i)
Permutation(str_list,start+1)
swap(str_list,start,i)
i+=1
def permutation_transe(str1):
str_list = list(str1)
Permutation(str_list,0)
if __name__ == "__main__":
str1 = "abab"
permutation_transe(str1)
#求两个字符串的最长公共子串
def getMaxSubStr(str1,str2):
len1 = len(str1)
len2=len(str2)
maxs=0 #公共最大个数
maxI = 0 #公共字符串最后一个位置
Matrix = [[None]*(len1+1) for i in range(len2+1)]
i = 0
while i <len1+1:
Matrix[i][0]=0
i+=1
j = 0
while j <len2+1:
Matrix[0][j]=0
j+=1
i=1
while i<len1+1:
j=1
while j < len2+1:
if list(str1)[i-1] == list(str2)[j-1]:
Matrix[i][j]= Matrix[i-1][j-1]+1
if Matrix[i][j]>maxs:
maxs=Matrix[i][j]
maxI=i
else:
Matrix[i][j] =0
j+=1
i+=1
i = maxI-maxs
return str1[i:maxI]
if __name__ == "__main__":
s1="abccade"
s2="dgcadde"
print(getMaxSubStr(s1,s2))
#对字符串进行反转
def reverseStr(strs):
chs = list(strs)
lens = len(chs)
i=0
j=lens-1
while i<j:
chs[i] = chr(ord(chs[i])^ord(chs[j]))
chs[j] = chr(ord(chs[i])^ord(chs[j]))
chs[i] = chr(ord(chs[i])^ord(chs[j]))
i+=1
j-=1
return "".join(chs)
#单词反转
def reverseStr1(chs,start,end):
i=start
j=end
while i<j:
chs[i] = chr(ord(chs[i])^ord(chs[j]))
chs[j] = chr(ord(chs[i])^ord(chs[j]))
chs[i] = chr(ord(chs[i])^ord(chs[j]))
i+=1
j-=1
def swapWord(strs):
lens = len(strs)
chs = list(strs)
reverseStr1(chs,0,lens-1)
#print(chs)
begin = 0
i =0
while i < lens:
if chs[i]==" ":
reverseStr1(chs,begin,i-1)
begin=i+1
i+=1
reverseStr1(chs,begin,lens-1)
print("".join(chs).strip())
#判断两个字符串是否为换位字符串
def compared(s1,s2):
dict_char = dict()
for char in list(s1):
if char in dict_char:
dict_char[char]+=1
else:
dict_char[char]=1
for char in list(s2):
if char in dict_char:
dict_char[char]-=1
for v in dict_char.values():
if v!=0:
return False
return True
s1 = "a@aaabbc"
s2="abcba@aa"
print(s1+"和"+s2,end="")
if compared(s1,s2):
print("是换位字符")
else:
print("不是换位字符")
from copy import deepcopy
#判断两个字符串的包含关系
def compared(s1,s2):
dict_char = dict()
for char in list(s1):
if char in dict_char:
dict_char[char]+=1
else:
dict_char[char]=1
for char in list(s2):
if char not in dict_char:
return False
return True
s1 = "a@aaabbc"
s2="abcbwa"
print(compared(s1,s2))
#判断两个字符串的包含关系
def isContain(s1,s2):
len1 = len(s1)
len2 = len(s2)
flag = [0]*52
count = 0#记录短字符串的不同个数
if len1<len2:
maxStr = s2
maxlen = len2
minStr = s1
minlen = len1
else:
maxStr = s1
maxlen = len1
minStr = s2
minlen = len2
for char in minStr:
if ord(char) >= ord("A") and ord(char)<=ord("Z"):
k = ord(char)-ord("A")
else:
k = ord(char)-ord("a")+26
if flag[k] == 0:
flag[k]=1
count+=1
for char in maxStr:
if ord(char) >= ord("A") and ord(char)<=ord("Z"):
k = ord(char)-ord("A")
else:
k = ord(char)-ord("a")+26
if flag[k] == 1:
flag[k]=0
count-=1
if count == 0:
return True
return False
s1="abcdef"
s2="acffeddb"
print(isContain(s1,s2))
#对大小写字母组成的字符数组排序
def ReverseArr(s1):
chs = list(s1)
lens = len(chs)
start = 0
end = lens-1
while start<end:
while chs[start]>="a" and chs[end]<="z" and start<end:
start+=1
while chs[start]>="A" and chs[end]<="Z" and start<end:
end-=1
chs[start],chs[end] = chs[end],chs[start]
return "".join(chs)
s1="AbcDef"
print(ReverseArr(s1))
#消除字符串的内嵌括号
def remove_extra_parenthesis(s1):
chs = list(s1)
count = 0
chs1=[]
if chs[0] != "(" and chs[-1] !=")":
return None
chs1.append("(")
i=1
while i < len(chs)-1:
if chs[i]=="(":
count+=1
elif chs[i] == ")":
count-=1
if count<0:
return print("error")
else:
chs1.append(chs[i])
i+=1
if count!=0:
return print("error")
chs1.append(")")
chs1 = "".join(chs1)
return chs1
strs="(1,(2,3),(4,(5,6),7))"
print(remove_extra_parenthesis(strs))
#判断字符串为整数
def isNumber(char):
return char>="0" and char<="9"
def strToint(s):
res=0
flag = False#是否为负数
if s[0]=="-":
flag = True
s = s[1:]
if s[0] == "+":
s = s[1:]
for char in s:
if isNumber(char):
res =res*10+int(char)
else:
print("is not number")
return
return -res if flag else res
num=strToint("123")
print(type(num),num)
#实现最长回文子串
def getLongestSubStr(s1):
k = len(s1)
longestSubStr = ""
longstLen = 0
M = [[0 for j in range(k)] for i in range(k)]
for j in range(0,k):
for i in range(0,j+1):
if j-i <=1:
if s1[i] == s1[j]:
M[i][j] = 1
if longstLen<j-i+1:
longstLen = j-i+1
longestSubStr=s1[i:j+1]
else:
if s1[i]==s1[j] and M[i+1][j-1]:
M[i][j]=1
if longstLen<j-i+1:
longstLen = j-i+1
longestSubStr=s1[i:j+1]
return longestSubStr
s1="abcdefgfedxyz"
print(getLongestSubStr(s1))
#实现最长回文子串
def getLongestSubStr(s1):
s3=s1
s2= "*" + "*".join(s1) + "*"
maxRight=0
pos=0
start=0
maxLen=0
RL=[0 for i in range(len(s2))]
for i in range(len(s2)):
if i<maxRight:
RL[i] = min(RL[2*pos-i],maxRight-i)
else:
RL[i]=1
while i-RL[i]>=0 and i+RL[i]<len(s2) and s2[i - RL[i]]==s2[i + RL[i]]:
RL[i]+=1
if RL[i]+i-1<maxRight:
maxRight=RL[i]+i-1
pos=i
if RL[i]>maxLen:
start = (i-RL[i])//2+1
maxLen=RL[i]-1
return s3[start:start + maxLen]
s1="abcdefgfed"
print(getLongestSubStr(s1))
#按照给定的字母序列对字符数组排序
def compare(str1,str2,dict_chartoint):
len1 = len(str1)
len2 = len(str2)
list1 = list(str1)
list2 = list(str2)
i=j=0
while i < len1 and j<len2:
if list1[i] not in dict_chartoint:
dict_chartoint[list1[i]] = -1
if list2[j] not in dict_chartoint:
dict_chartoint[list2[j]] = -1
if dict_chartoint[list1[i]] <dict_chartoint[list2[j]]:
return -1#s1大
elif dict_chartoint[list1[i]] >dict_chartoint[list2[j]]:
return 1#s2大
else:
i+=1
j+=1
if i == len1 and j==len2:
return 0
elif i==len1:
return -1
else:
return 1
def quick_sort(arr,dic):
last_index = len(arr)-1
quick_sort_c(arr,0,last_index,dic)
def quick_sort_c(arr,start,finish,dic):
if start < finish:
pivot = partition(arr,start,finish,dic)
quick_sort_c(arr,start,pivot-1,dic)
quick_sort_c(arr,pivot+1,finish,dic)
else:
return
def partition(arr,head,tail,dic):
i = head
last_element = arr[tail]
for j in range(head,tail):
if compare(arr[j],last_element,dic)==-1:
#if arr[j] < last_element:
arr[i],arr[j] = arr[j],arr[i]
i+=1
arr[i],arr[tail] = arr[tail],arr[i]
return i
def dict_ctoi(sqe):
dic = dict()
for i,char in enumerate(sqe):
dic[char]= i
return dic
s=["bed","dog","dog1","dear","eye"]
sqe="dgecfboa"
dict_chartoint=dict_ctoi(sqe)
print(compare("bed","be",dict_chartoint))
quick_sort(s,dict_chartoint)
print(s)
#判断字符串是否有重复字符
def isDup(str):
dic=dict()
for i in str:
if i not in dic:
dic[i]=True
else:
return False
return True
print(isDup("fod"))
#a=[1,2]
#print(a[2:])#[]
#找到由其他单词组成的最长单词
class findlongeststr(object):
def getLongestStr(self,str_list):
strArr = sorted(str_list,key=len,reverse=True)
print(strArr)
i =0
while i<len(str_list):
if self.iscontain(strArr,strArr[i],len(strArr[i])):
return strArr[i]
i+=1
return None
def iscontain(self,strArr,word,length):
lens = len(word)
#只有find()为T时，word[i:]才会进行判断，lens==0，说明之前都已匹配
if lens == 0:
return True
i=1
while i<=lens:
#i==length只有一种情况，就是没有任何匹配的子串
#而且仅在最初迭代的时候
if i == length:
return False
substr=word[0:i]
if self.find(strArr,substr):
if self.iscontain(strArr,word[i:],length):
return True
i+=1
#return False
def find(self,strArr,word):
i=0
while i<len(strArr):
if strArr[i] == word:
return True
i+=1
return False
str_list = ["te","st","t","op","yt","tt","testopytt"]
l = findlongeststr()
print(l.getLongestStr(str_list))
def getMaxDupChar(str,start,curMaxlen,maxlen):
if start == len(str)-1:
return max(curMaxlen,maxlen)
if str[start] == str[start+1]:
return getMaxDupChar(str,start+1,curMaxlen+1,maxlen)
else:
return getMaxDupChar(str,start+1,1,max(curMaxlen,maxlen))
s1="aaaass"
s=getMaxDupChar(s1,0,1,1)
print(s)
#求连续最长递增子序列长度
def get(strs):
lens=len(strs)
list1=list(strs)
maxLen = [None]*lens
max1=1
maxAscendingLen=1
i=1
while i <lens:
maxLen[i]=1
if list1[i-1]<list1[i]:
maxAscendingLen+=1
max1=max(max1,maxAscendingLen)
else:
maxAscendingLen=1
i+=1
return max1
#求最长递增子序列长度
def get(strs):
lens=len(strs)
list1=list(strs)
maxLen = [None]*lens
maxLen[0]=1
maxAscendingLen=1
i=1
while i <lens:
maxLen[i]=1
j=0
while j<i:
if list1[j]<list1[i] and maxLen[j]>=maxLen[i]:
maxLen[i]=maxLen[j]+1
maxAscendingLen=maxLen[i]
j+=1
i+=1
return maxAscendingLen
s="xabzsdyezfzga"
print(get(s))
#求一个串中出现的第一个最长重复子串
def getSuffix(txt):
suffixs=[]
i=0
while i<len(txt):
suffixs.append(txt[i:])
i+=1
suffixs.sort()
return suffixs
def getMaxsubstr(s1,s2):
i=j=0
while i<len(s1) and j<len(s2):
if s1[i]==s2[j]:
i+=1
j+=1
else:
break
return i
def get(txt):
suffixs = getSuffix(txt)
lens=len(suffixs)
maxStr=""
i=0
while i < lens-1:
index=getMaxsubstr(suffixs[i],suffixs[i+1])
maxStr=max1(suffixs[i][:index],maxStr)
i+=1
return maxStr
def max1(s1,s2):
str1=s1
str2=s2
if type(s1) is tuple:
s1=s1[0]
if type(s2) is tuple:
s2=s2[0]
len1=len(s1)
len2=len(s2)
if len1<len2:
return str2
elif len1>len2:
return str1
else:
return str1,str2
txt = "aaaa"
print(getSuffix(txt))
print(getMaxsubstr("asde","ased"))
print(get(txt))
print(type(max1("abc","def")) is tuple)
#求解字符串中字典序最大的子序列
def func(str):
str_list=list(str)
reverse_str(str_list)
new_str= list()
new_str.append(str_list[0])
for i in str_list[1:]:
if i>new_str[-1]:
new_str.append(i)
reverse_str(new_str)
return "".join(new_str)
def reverse_str(s):
j=len(s)-1
i=0
while i<j:
s[i],s[j]=s[j],s[i]
i+=1
j-=1
str1="acbdxmng"
print(func(str1))
#判断字符串是否由另一个旋转得到
def isSubStr(s1,s2):
return s1.find(s2) !=-1
def func(s1,s2):
assert len(s1)>0 and len(s2)>0 and len(s1)==len(s2)
lens=len(s1)
i=0
list1=list(s1)
daStr=[None]*(2*lens)
while i<lens:
daStr[i]=list1[i]
daStr[lens+i]=list1[i]
i+=1
return isSubStr("".join(daStr),s2)
s1="waterbottle"
s2="teroottlewa"
print(func(s1,s2))
#如何求字符串的编辑距离
def min_dist(s1,s2):
len1=len(s1)
len2=len(s2)
matrix = [[None for i in range(len1+1)]for j in range(len2+1)]
#print(matrix)
for i in range(len2+1):
matrix[i][0]=i
for j in range(len1+1):
matrix[0][j]=j
for i in range(1,len1+1):
for j in range(1,len2+1):
delta = 0 if s1[i-1]==s2[j-1] else 2
matrix[j][i]= min(matrix[j-1][i-1]+delta,matrix[j-1][i]+1,matrix[j][i-1]+1)
return matrix[len2][len1]
s1="bcilnd"
s2="bcilno"
print(min_dist(s1,s2))
#如何求二维数组中寻找最短距离
def min_dist(arr):
assert len(arr)>0
for i in arr:
assert len(i)==len(arr[0])
row=len(arr[0])#横
col=len(arr)
M = [[None for i in range(row)] for j in range(col)]
M[0][0]=arr[0][0]
for i in range(1,row):
M[0][i]= M[0][i-1]+arr[0][i]
for i in range(1,col):
M[i][0]=M[i-1][0]+arr[i][0]
for i in range(1,row):
for j in range(1,col):
M[j][i]=min(M[j-1][i],M[j][i-1])+arr[j][i]
return M
arr=[[1,4,3],[8,7,5],[2,1,5]]
print(min_dist(arr))
#根据两文件的绝对路径算出相对路径。如 a=”/qihoo/app/a/b/c/d/new.c”,b=”/qihoo/app/1/2/test.c’，
# 那么b相对于a的相对路径是”../../../../1/2/test.c”(若在a中导入b)
def func(a,b):
len1=len(a)
len2=len(b)
i=j=0
dif1=0
dif2=0
com_front=""
while i<len1 and j<len2:
if a[i]==b[j]:
dif1=i
dif2=j
i+=1
j+=1
else:
dif1+=1
dif2+=1
break
while dif1<len1:
if a[dif1] == "/":
com_front+="../"
dif1+=1
com_front+=b[dif2:]
return com_front
a="/qihoo/app/a/b/c/d/new.c"
b="/qihoo/app/1/2/test.c"
print(func(a,b))
浙公网安备 33010602011771号