Я хочу создать программу, которая находит самую длинную подстроку в алфавитном порядке, используя Python, используя основы

Question

Мой код для поиска самой длинной подстроки в алфавитном порядке с использованием Python

что я подразумеваю под самой длинной подстрокой в ​​алфавитном порядке? если вход был "asdefvbrrfqrstuvwxffvd", выход будет "qrstuvwx"

#we well use the strings as arrays so don't be confused
s='abcbcd'
#give spaces which will be our deadlines
h=s+'    (many spaces)                                                                      '
#creat outputs
g=''
g2=''
#list of alphapets
abc='abcdefghijklmnopqrstuvwxyz'

#create the location of x"the character the we examine"  and its limit 
limit=len(s)
#start from 1 becouse we substract one in the rest of the code
x=1
while (x<limit):
    #y is the curser that we will move the abc array on it
    y=0
    #putting our break condition first
    if ((h[x]==' ') or (h[x-1]==' ')):
        break
    for y in range(0,26):
        #for the second character x=1
        if ((h[x]==abc[y]) and (h[x-1]==abc[y-1]) and (x==1)):
            g=g+abc[y-1]+abc[y]

            x+=1
        #for the third to the last character x>1
        if ((h[x]==abc[y]) and (h[x-1]==abc[y-1]) and (x!=1)):
            g=g+abc[y]
            x+=1
        if (h[x]==' '):
            break
print ("Longest substring in alphabetical order is:" +g )

это не заканчивается, как будто это в бесконечном цикле, что мне делать? Я новичок, поэтому я хочу, чтобы некоторые с циклами for не функции из библиотек Заранее спасибо

Answer 1

s = 'abcbcdiawuhdawpdijsamksndaadhlmwmdnaowdihasoooandalw'
longest = ''
current = ''
for idx, item in enumerate(s):
    if idx == 0 or item > s[idx-1]:
        current = current + item
    if idx > 0 and item <= s[idx-1]:
        current = ''
    if len(current)>len(longest):
        longest = current
print(longest)

Выход:

dhlmw

Для вашего понимания 'b'>'a' является True, 'a'>'b' является False так далее

Редактировать:

Для самой длинной последовательной подстроки:

s = 'asdefvbrrfqrstuvwxffvd'
abc = 'abcdefghijklmnopqrstuvwxyz'
longest = ''
current = ''
for idx, item in enumerate(s):
    if idx == 0 or abc.index(item) - abc.index(s[idx-1]) == 1:
        current = current + item
    else:
        current = item
    if len(current)>len(longest):
        longest = current
print(longest)

Выход:

qrstuvwx

Answer 2

Вы можете перебирать строку и сравнивать с последним символом и добавлять к потенциально самой длинной строке, если текущий символ больше последнего символа на один порядковый номер:

def longest_substring(s):
    last = None
    current = longest = ''
    for c in s:
        if not last or ord(c) - ord(last) == 1:
            current += c
        else:
            if len(current) > len(longest):
                longest = current
            current = c
        last = c
    if len(current) > len(longest):
        longest = current
    return longest

чтобы:

print(longest_substring('asdefvbrrfqrstuvwxffvd'))

будет выводить:

qrstuvwx

Answer 3

def sub_strings(string):
    substring = ''
    string +='\n'
    i = 0
    string_dict ={}
    while i < len(string)-1:
        substring += string[i]
        if ord(substring[-1])+1 != ord(string[i+1]):
            string_dict[substring] = len(substring)
            substring = ''
        i+=1
    return string_dict   

 s='abcbcd'

 sub_strings(s)
  {'abc': 3, 'bcd': 3} 

Чтобы найти самое длинное, что вы можете сделатьmax(sub_strings(s))

Так вот, какой из них вы хотите принять как самый длинный?? Теперь это проблема, которую вам нужно решить

Answer 4

Чтобы избежать бесконечного цикла, добавьте x += 1 в самом конце вашего цикла. В результате ваш код работает, но в общем случае работает неправильно.

Причина, по которой он работает неправильно, заключается в том, что вы используете только одну переменную g сохранить результат. Используйте как минимум две переменные для сравнения предыдущей найденной подстроки и новой найденной подстроки или используйте список, чтобы запомнить все подстроки, а затем выберите самую длинную.