how do you know if your list is ascending in python

Question

I wrote this program in python to see if a list is ascending and its not working, can someone help me?

list1 = [1, 2, 3, 4]
print (list1)
length = len(list1)
run_started = False
for x in range(length - 1):
    t = list1[x + 1] - list1[x]
    if t > 0 :
        if run_started:
            run_length = x
        else:
            run_started = True
            run_length = x
    else:
        if run_started:
            print (True)
            print ("Run Length: {0}".format(run_length))
            break
if not run_started:
    print (False)

Answer 1

I'd say the easiest (although not the most efficient) way would be:

list1 = [3, 1, 2, 4]

if sorted(list1) == list1:
    print "list1 is sorted"

Answer 2

Well, here's my go at it. Some have suggested sorting the list, which would be O(nlogn). I propose a simpler O(n) solution

def isAscending(list):
    previous = list[0]
    for number in list:
        if number < previous:
            return False
        previous = number
    return True

Answer 3

How about a one-liner to tell if every number in the list x is strictly increasing?

[(x[k+1]-x[k])>0 for k in range(len(x)-1)].count(True) == len(x)-1

Answer 4

I think the OP is asking what is wrong with their own code. If that's the case, here goes:

It looks like you never reach the end condition that you want. I mean, you get your run_started variable to get to True. But then what? Nothing else happens in your code since you never trigger the else statement that is contrary to your if t > 0 statement. I think you should re-think the logic in your code and what you want it to do exactly

EDIT: your code commented, I've put numbers in {{}} to show what happens in what order

list1 = [1, 2, 3, 4]
print (list1)
length = len(list1)
run_started = False
for x in range(length - 1): # Loop begins {{1}}
    t = list1[x + 1] - list1[x]
    if t > 0 : 
        if run_started:
            run_length = x #You keep setting a new run_length {{3}}
        else:
            run_started = True #You've set run_started  {{2}}
            run_length = x
    else:
        if run_started:
            print (True)
            print ("Run Length: {0}".format(run_length))
            break
if not run_started: #Then this is called after the loop {{4}} but it doesn't return true
    print (False)

As you can see, you exit the for loop without ever calling else on line 13. Furthermore then final if not run_started is also never called. Your code works the way it is designed to work, though maybe not the way you want it to work. HTH

Answer 5

A way that is more efficient than fully constructing the sorted list (and should work for arbitrary iterable types, containing any data types that allow for greater-than comparisons):

def len_ascending_run_from_start(seq):
    vals = enumerate(seq)
    try:
        c,x = 1, vals.next()[1]
    except StopIteration:
        raise ValueError("Sequence is empty!")
    for i, cur_x in vals:
        if cur_x < x:
            break
        c,x = c+1, cur_x
    return c

E.g.:

In [44]: len_ascending_run_from_start([datetime.date(2012,1,4), datetime.date(2012,1,3), datetime.date(2012,1,5)])
Out[44]: 1

In [45]: len_ascending_run_from_start([datetime.date(2012,1,4), datetime.date(2012,1,6), datetime.date(2012,1,5)])
Out[45]: 2

In [46]: len_ascending_run_from_start([datetime.date(2012,1,4), datetime.date(2012,1,6), datetime.date(2012,1,7)])
Out[46]: 3

In [47]: len_ascending_run_from_start((1,2,3,4))
Out[47]: 4

In [48]: len_ascending_run_from_start((1,3,2,4))
Out[48]: 2

In [49]: len_ascending_run_from_start(set([1,3,2,4]))
Out[49]: 4

It could also be fun / useful to make a class such that len automatically reports this statistic about the underlying sequence (and keeps a simplistic cache of the result, to avoid calculating it repeatedly).

class AscendingRunFromStart(object):
    def __init__(self, seq):
        self.seq = seq

    def __repr__(self):
        return self.seq.__repr__()
    __str__ = __repr__

    def __len__(self):
        if hasattr(self, "_len"):
            return self._len
        vals = enumerate(self.seq)
        c,x = 1, vals.next()[1]
        for i, cur_x in vals:
            if cur_x < x:
                break
            c,x = c+1, cur_x
        self._len = c
        return self._len

E.g.:

In [76]: x = AscendingRunFromStart([1,3,2,4])

In [77]: x
Out[77]: [1, 3, 2, 4]

In [78]: len(x)
Out[78]: 2

A good extension would be to use a Descriptor pattern to make the seq attribute of the class read-only, or to invoke an updated len calculation whenever set is called. (Left as exercise for the reader...)