Python 按字母顺序查找最长的子字符串_Python

Python 按字母顺序查找最长的子字符串

python

Python 按字母顺序查找最长的子字符串,python,Python,我在另一个主题中找到了这段代码，但它按连续字符而不是按字母顺序对子字符串进行排序。如何按字母顺序更正它？它打印出lk，我想打印ccl。谢谢附言：我是python的初学者 s = 'cyqfjhcclkbxpbojgkar' from itertools import count def long_alphabet(input_string): maxsubstr = input_string[0:0] # empty slice (to accept subclasses of st

我在另一个主题中找到了这段代码，但它按连续字符而不是按字母顺序对子字符串进行排序。如何按字母顺序更正它？它打印出

lk

，我想打印

ccl

。谢谢

附言：我是python的初学者

s = 'cyqfjhcclkbxpbojgkar'
from itertools import count

def long_alphabet(input_string):
    maxsubstr = input_string[0:0] # empty slice (to accept subclasses of str)
    for start in range(len(input_string)): # O(n)
        for end in count(start + len(maxsubstr) + 1): # O(m)
            substr = input_string[start:end] # O(m)
            if len(set(substr)) != (end - start): # found duplicates or EOS
                break
            if (ord(max(sorted(substr))) - ord(min(sorted(substr))) + 1) == len(substr):
                maxsubstr = substr
    return maxsubstr

bla = (long_alphabet(s))
print "Longest substring in alphabetical order is: %s" %bla

尝试更改此选项：

        if len(set(substr)) != (end - start): # found duplicates or EOS
            break
        if (ord(max(sorted(substr))) - ord(min(sorted(substr))) + 1) == len(substr):

为此：

        if len(substr) != (end - start): # found duplicates or EOS
            break
        if sorted(substr) == list(substr):

这将显示示例输入字符串的

ccl

。代码更简单，因为您试图解决一个更简单的问题：-）

s='cyqfjhcclkbxpbojgkar'
r=''
c=''
对于s中的字符：
如果（c=''）：
c=字符
elif（c[-1]字符）：
如果（len（r）len（r））：
r=c
印刷品（r）

您可以通过注意字符串可以被分解为最大长度的有序子字符串来改进算法。任何有序的子字符串都必须包含在其中一个运行中

这允许您只在字符串O（n）中迭代一次

在Python中，字符比较容易与java脚本进行比较，java脚本必须比较ASCII值。根据python

a> b给出布尔值False，b>a给出布尔值True

使用此方法，可以使用以下算法找到按字母顺序排列的最长子字符串：

def comp(a,b):
    if a<=b:
        return True
    else:
        return False
s = raw_input("Enter the required sting: ")
final = []
nIndex = 0
temp = []
for i in range(nIndex, len(s)-1):
    res = comp(s[i], s[i+1])
    if res == True:       
           if temp == []:
           #print i
               temp.append(s[i])
               temp.append(s[i+1])
           else:
               temp.append(s[i+1])
       final.append(temp)
        else:
       if temp == []:
        #print i
        temp.append(s[i])
       final.append(temp)
       temp = []
lengths = []
for el in final:
    lengths.append(len(el))
print lengths
print final
lngStr = ''.join(final[lengths.index(max(lengths))])
print "Longest substring in alphabetical order is: " + lngStr

def组件（a、b）：
如果实现略有不同，请按字母顺序建立所有子字符串的列表，并返回最长的子字符串：
def longest_substring(s):
    in_orders = ['' for i in range(len(s))]
    index = 0
    for i in range(len(s)):
        if (i == len(s) - 1 and s[i] >= s[i - 1]) or s[i] <= s[i + 1]:
            in_orders[index] += s[i]
        else:
            in_orders[index] += s[i]
            index += 1
    return max(in_orders, key=len)  

def最长_子字符串：
in_orders=[''表示范围内的i（len（s））]
索引=0
对于范围内的i（len（s））：
如果以递归方式（i==len（s）-1和s[i]>=s[i-1]）或s[i]，则可以从itertools导入count
或定义相同的方法：
def loops( I=0, S=1 ):
    n = I
    while True:
        yield n
        n += S

使用此方法，您可以在分析过程中创建任何子字符串时获取端点的值
现在来看分析方法（基于问题和先生的建议）
最后，对于测试或执行目标：
# for execution pourposes of the exercise:
s = "azcbobobegghakl"
print "Longest substring in alphabetical order is: " + anallize( s )

这项工作的主要部分由：开始，并由Mr.参与，是使用本机str方法和代码的可重用性
答案是：
按字母顺序排列的最长子字符串是：ccl另一种方式：
s = input("Please enter a sentence: ")
count = 0
maxcount = 0
result = 0
for char in range(len(s)-1):
    if(s[char]<=s[char+1]):
       count += 1        
    if(count > maxcount):
           maxcount = count
           result = char + 1

    else:

        count = 0
startposition = result - maxcount
print("Longest substring in alphabetical order is: ", s[startposition:result+1])

s=input（“请输入一个句子：”）
计数=0
最大计数=0
结果=0
对于范围（len（s）-1中的字符：
如果（s[char]maxcount）：
最大计数=计数
结果=字符+1
其他：
计数=0
startposition=结果-最大计数
打印（“按字母顺序排列的最长子字符串为：”，s[startposition:result+1]）
s=“azcbobegbegghakl”
ls=“”
对于范围（0，透镜-1）内的i：
b=“”
ss=“”
j=2
当jlen（ls）：
ls=ks
打印（“按字母顺序排列的最长子字符串为“+ls”）
使用list和max函数大幅减少代码
actual_string = 'azcbobobegghakl'
strlist = []
i = 0
while i < len(actual_string)-1:
    substr = ''
    while actial_string[i + 1] > actual_string[i] :
        substr += actual_string[i]
        i += 1
        if i > len(actual_string)-2:
            break
    substr += actual-string[i]
    i += 1
    strlist.append(subst)
print(max(strlist, key=len))

actual_string='azcbobobegbegghakl'
strlist=[]
i=0
而i实际字符串[i]时：
substr+=实际_字符串[i]
i+=1
如果i>len（实际_字符串）-2：
打破
substr+=实际字符串[i]
i+=1
strlist.append（subst）
打印（最大值（strlist，key=len））
s='cyqfjhclkbxpbojgkar'
最长=“”
max=“”
对于范围内的i（透镜-1）：
如果（s[i]len（max））：
最大值=最长
最长=“”
如果（len=1）：
最长=s
如果（len（最长）>len（最大））：
打印（“按字母顺序排列的最长子字符串为：“+最长”）
其他：
打印（“按字母顺序排列的最长子字符串为：“+max”）
这对我很有效
s = 'cyqfjhcclkbxpbojgkar'

lstring = s[0]
slen = 1

for i in range(len(s)):
    for j in range(i,len(s)-1):
            if s[j+1] >= s[j]:
                    if (j+1)-i+1 > slen:
                        lstring = s[i:(j+1)+1]
                        slen = (j+1)-i+1
            else:
                        break

print("Longest substring in alphabetical order is: " + lstring)

输出：按字母顺序排列的最长子字符串是：ccl
input\u str=“cyqfjhcclkbxpbojgkar”
input_str = "cyqfjhcclkbxpbojgkar"
length = len(input_str) # length of the input string
iter = 0
result_str = '' # contains latest processed sub string
longest = '' # contains longest sub string alphabetic order 
while length > 1: # loop till all char processed from string
    count = 1
    key = input_str[iter] #set last checked char as key 
    result_str += key # start of the new sub string
    for i in range(iter+1, len(input_str)): # discard processed char to set new range
      length -= 1
      if(key <= input_str[i]): # check the char is in alphabetic order 
        key = input_str[i]
        result_str += key # concatenate the char to result_str
        count += 1
      else:
        if(len(longest) < len(result_str)): # check result and longest str length
          longest = result_str # if yes set longest to result
        result_str = '' # re initiate result_str for new sub string
        iter += count # update iter value to point the index of last processed char
        break

    if length is 1: # check for the last iteration of while loop
        if(len(longest) < len(result_str)):
          longest = result_str

print(longest);

length=len（input_str）#输入字符串的长度
iter=0
结果_str=''包含最新处理的子字符串
最长=“”#包含按字母顺序排列的最长子字符串
当长度>1时：#循环直到从字符串处理所有字符
计数=1
key=input_str[iter]#将上次选中的字符设置为key
结果_str+=键#新子字符串的开始
对于范围内的i（iter+1，len（input#u str））：#丢弃已处理的字符以设置新范围
长度-=1
如果（key哇，这里有一些非常令人印象深刻的代码片段。。。
我想添加我的解决方案，因为我认为它非常干净：
s = 'cyqfjhcclkbxpbojgkar'

res = ''
tmp = ''

for i in range(len(s)):
    tmp += s[i]
    if len(tmp) > len(res):
        res = tmp
    if i > len(s)-2:
        break
    if s[i] > s[i+1]:
        tmp = ''

print("Longest substring in alphabetical order is: {}".format(res))

不使用库，但使用返回字符ascii值的函数ord（）。
假设：输入将使用小写，并且不使用特殊字符
s = 'azcbobobegghakl'

longest = ''

for i in range(len(s)):
    temp_longest=s[i]

    for j in range(i+1,len(s)):

        if ord(s[i])<=ord(s[j]):
            temp_longest+=s[j]
            i+=1
        else:
            break

    if len(temp_longest)>len(longest):
        longest = temp_longest

print(longest)

s='azcbobebeghakl'
最长=“”
对于范围内的i（len（s））：
最长温度=s[i]
对于范围（i+1，len（s））内的j：
如果作战需求文件长度（最长）：
最长=温度最长
打印（最长）
在Python中按字母顺序查找最长的子字符串
在pythonshell'a'<'b'或'a'len（结果）中：
结果=温度
打印（'按字母顺序排列的最长子字符串为：'，结果）
s=input（）
温度=s[0]
输出=s[0]
对于范围内的i（透镜-1）：
如果s[i]len（输出）：
输出=温度
其他：
温度=s[i+1]
打印（'按字母顺序排列的最长子字符串为：'+输出）
在EDX online某物的一次测试中，我遇到了类似的问题。花了20分钟进行头脑风暴，但找不到解决方案。但我得到了答案。这很简单。在其他解决方案中阻止我的事情-光标不应该停止或具有唯一值，因此如果我们有edx字符串s='Azcbobeghakl'，它应该输出-'beggh'而不是'begh'（唯一集）或'kl'（根据与字母字符串相同的最长值）。这是我的答案，它是有效的
n=0
for i in range(1,len(s)):
    if s[n:i]==''.join(sorted(s[n:i])):
        longest_try=s[n:i]
    else:
        n+=1

在某些情况下，输入是混合字符，如“Hello”或“HelloWorld”
**骗局
s = 'cyqfjhcclkbxpbojgkar'

lstring = s[0]
slen = 1

for i in range(len(s)):
    for j in range(i,len(s)-1):
            if s[j+1] >= s[j]:
                    if (j+1)-i+1 > slen:
                        lstring = s[i:(j+1)+1]
                        slen = (j+1)-i+1
            else:
                        break

print("Longest substring in alphabetical order is: " + lstring)

input_str = "cyqfjhcclkbxpbojgkar"
length = len(input_str) # length of the input string
iter = 0
result_str = '' # contains latest processed sub string
longest = '' # contains longest sub string alphabetic order 
while length > 1: # loop till all char processed from string
    count = 1
    key = input_str[iter] #set last checked char as key 
    result_str += key # start of the new sub string
    for i in range(iter+1, len(input_str)): # discard processed char to set new range
      length -= 1
      if(key <= input_str[i]): # check the char is in alphabetic order 
        key = input_str[i]
        result_str += key # concatenate the char to result_str
        count += 1
      else:
        if(len(longest) < len(result_str)): # check result and longest str length
          longest = result_str # if yes set longest to result
        result_str = '' # re initiate result_str for new sub string
        iter += count # update iter value to point the index of last processed char
        break

    if length is 1: # check for the last iteration of while loop
        if(len(longest) < len(result_str)):
          longest = result_str

print(longest);

s = 'cyqfjhcclkbxpbojgkar'

res = ''
tmp = ''

for i in range(len(s)):
    tmp += s[i]
    if len(tmp) > len(res):
        res = tmp
    if i > len(s)-2:
        break
    if s[i] > s[i+1]:
        tmp = ''

print("Longest substring in alphabetical order is: {}".format(res))

s = 'azcbobobegghakl'

longest = ''

for i in range(len(s)):
    temp_longest=s[i]

    for j in range(i+1,len(s)):

        if ord(s[i])<=ord(s[j]):
            temp_longest+=s[j]
            i+=1
        else:
            break

    if len(temp_longest)>len(longest):
        longest = temp_longest

print(longest)

result = ''
temp = ''
for char in s:
    if (not temp or temp[-1] <= char):
        temp += char
    elif (temp[-1] > char):
        if (len(result) < len(temp)):
            result = temp
        temp = char
    
if (len(temp) > len(result)):
    result = temp
    
print('Longest substring in alphabetical order is:', result)

s=input()
temp=s[0]
output=s[0]
for i in range(len(s)-1):
    if s[i]<=s[i+1]:
        temp=temp+s[i+1]
        if len(temp)>len(output):
            output=temp           
    else:
        temp=s[i+1]

print('Longest substring in alphabetic order is:' + output)

n=0
for i in range(1,len(s)):
    if s[n:i]==''.join(sorted(s[n:i])):
        longest_try=s[n:i]
    else:
        n+=1

   string ="HelloWorld"
    s=string.lower()
    r = ''
    c = ''
    last=''
    for char in s:
        if (c == ''):
            c = char
        elif (c[-1] <= char):
            c += char
        elif (c[-1] > char):
            if (len(r) < len(c)):
                r = c
                c = char
            else:
                c = char
    if (len(c) > len(r)):
        r = c
    for i in r:
        if i in string:
            last=last+i
        else:
            last=last+i.upper()
    if len(r)==1:
        print(0)
    else:
        print(last)

```python
s = "cyqfjhcclkbxpbojgkar"  # change this to any word
word, temp = "", s[0]  # temp = s[0] for fence post problem
for i in range(1, len(s)):  # starting from 1 not zero because we already add first char
    x = temp[-1]  # last word in var temp
    y = s[i]  # index in for-loop
    if x <= y:
        temp += s[i]
    elif x > y:
        if len(temp) > len(word):  #storing longest substring so we can use temp for make another substring
            word = temp
        temp = s[i]  #reseting var temp with last char in loop
    if len(temp) > len(word):
        word = temp
print("Longest substring in alphabetical order is:", word)
```