Finding longest substring in alphabetical order

Question

EDIT: I am aware that a question with similar task was already asked in SO but I\'m interested to find out the problem in this specific piece of code. I am

Answer 1

Python has a powerful builtin package itertools and a wonderful function within groupby

An intuitive use of the Key function can give immense mileage.

In this particular case, you just have to keep a track of order change and group the sequence accordingly. The only exception is the boundary case which you have to handle separately

Code

def find_long_cons_sub(s):
    class Key(object):
        '''
        The Key function returns 
            1: For Increasing Sequence
            0: For Decreasing Sequence
        '''
        def __init__(self):
            self.last_char = None
        def __call__(self, char):
            resp = True
            if self.last_char:
                resp = self.last_char < char
            self.last_char = char
            return resp
    def find_substring(groups):
        '''
        The Boundary Case is when an increasing sequence
        starts just after the Decresing Sequence. This causes
        the first character to be in the previous group.
        If you do not want to handle the Boundary Case
        seperately, you have to mak the Key function a bit 
        complicated to flag the start of increasing sequence'''
        yield next(groups)
        try:
            while True:
                yield next(groups)[-1:] + next(groups)
        except StopIteration:
            pass
    groups = (list(g) for k, g in groupby(s, key = Key()) if k)
    #Just determine the maximum sequence based on length
    return ''.join(max(find_substring(groups), key = len))

Result

>>> find_long_cons_sub('drurotsxjehlwfwgygygxz')
'ehlw'
>>> find_long_cons_sub('eseoojlsuai')
'jlsu'
>>> find_long_cons_sub('hixwluvyhzzzdgd')
'luvy'

Answer 2

I suppose this is problem set question for CS6.00.1x on EDX. Here is what I came up with.

s = raw_input("Enter the string: ")
longest_sub = ""
last_longest = ""
for i in range(len(s)):
    if len(last_longest) > 0:
        if last_longest[-1] <= s[i]:
            last_longest += s[i]
        else:
            last_longest = s[i]
    else:
        last_longest = s[i]
    if len(last_longest) > len(longest_sub):
        longest_sub = last_longest
print(longest_sub)

Answer 3

I came up with this solution

def longest_sorted_string(s):
    max_string = ''
    for i in range(len(s)):
        for j in range(i+1, len(s)+1):
            string = s[i:j]
            arr = list(string)
            if sorted(string) == arr and len(max_string) < len(string):
                max_string = string
    return max_string

Answer 4

first_seq=s[0]
break_seq=s[0]
current = s[0]
for i in range(0,len(s)-1):
    if s[i]<=s[i+1]:
        first_seq = first_seq + s[i+1]
        if len(first_seq) > len(current):
            current = first_seq
    else:
        first_seq = s[i+1]
        break_seq = first_seq
print("Longest substring in alphabetical order is: ", current)

Answer 5

def find_longest_order():
`enter code here`arr = []
`enter code here`now_long = ''
    prev_char = ''
    for char in s.lower():
        if prev_char and char < prev_char:
            arr.append(now_long)
            now_long = char
        else:
            now_long += char
        prev_char = char
    if len(now_long) == len(s):
        return now_long
    else:   
        return max(arr, key=len)

def main():
    print 'Longest substring in alphabetical order is: ' + find_longest_order()

main()

Answer 6

You can use nested for loops, slicing and sorted. If the string is not all lower-case then you can convert the sub-strings to lower-case before comparing using str.lower:

def solve(strs):
  maxx = ''
  for i in xrange(len(strs)):
      for j in xrange(i+1, len(strs)):
          s = strs[i:j+1]
          if ''.join(sorted(s)) == s:
              maxx = max(maxx, s, key=len)
          else:
              break
  return maxx

Output:

>>> solve('hixwluvyhzzzdgd')
'luvy'
>>> solve('eseoojlsuai')
'jlsu'
>>> solve('drurotsxjehlwfwgygygxz')
'ehlw'