One alternative to use a function closure instead of a class:
import math
import itertools
def compare_with_previous():
prev = -math.inf
def compare(value):
nonlocal prev
test = prev < value
prev = value
return test
return compare
def monotonic(seq):
for is_increasing, group in itertools.groupby(seq, compare_with_previous()):
group = list(group)
if not is_increasing:
group.reverse()
yield group
print(list(monotonic([1, 2, 3, 2, 1, 4, 5, 6, 7])))
Another is to be more itertools oriented: import math
import itertools
# Given a pair (a, b), test if a < b
def lt_pair(pair):
return pair[0] < pair[1]
def monotonic(seq):
# iterate through a two-element window of the sequence, using -inf as the first term
seq1, seq2 = itertools.tee(seq)
window = zip(itertools.chain([-math.inf], seq1), seq2)
# group by increasing or decreasing (arbitrarily assume equal means increasing)
for is_increasing, group in itertools.groupby(window, lt_pair):
if not is_increasing:
# reverse the direction
group = list(group)[::-1]
yield [pair[1] for pair in group]
print(list(monotonic([1, 2, 3, 2, 1, 4, 5, 6, 7])))
NOTE! None of these solutions support monotonicity correctly for equal values! >>> print(list(monotonic([1, 1, 2, 3, 3, 2, 1, 1])))
[[1], [1], [2, 3], [1, 1, 2, 3]]
>>> list(mono_runs_simpler([1, 1, 2, 3, 3, 2, 1, 1]))
[[1], [1], [2, 3], [1, 2, 3], [1]]
That should be (IMO): [[1, 1, 2, 3, 3], [2, 1, 1]]
as the term "strictly monotonic" is for the always-increasing or always-decreasing.Handling this case is much easier in the first of these two implementations:
import math
import itertools
def monotonic_comparison():
prev_value = -math.inf
prev_test = True
def compare(value):
nonlocal prev_value, prev_test
if prev_test:
# Testing for monotonic increasing
test = prev_value <= value
else:
# Testing for monotonic decreasing
test = prev_value < value
prev_value = value
prev_test = test
return test
return compare
def monotonic(seq):
for is_increasing, group in itertools.groupby(seq, monotonic_comparison()):
group = list(group)
if not is_increasing:
group.reverse()
yield group
HOWEVER! At this point it's a lot of work structured around using groupby(). It's more readable, as Ned Batchelder points out, to just write the code directly, without groupby() or nonlocal: import math
def monotonic_direct(seq):
prev_value = -math.inf
prev_test = True
group = []
for value in seq:
if prev_test:
test = prev_value <= value
else:
test = prev_value < value
if test == prev_test:
group.append(value)
else:
if not prev_test:
group.reverse()
yield group
group = [value]
prev_value = value
prev_test = test
if group:
yield group
>>> print(list(monotonic_direct([1, 2, 3, 2, 1, 4, 5, 6, 7])))
[[1, 2, 3], [1, 2], [4, 5, 6, 7]]
>>> print(list(monotonic_direct([1, 1, 2, 3, 3, 2, 1, 1])))
[[1, 1, 2, 3, 3], [2, 1, 1]]
(I'm using -inf as a special sentinel, instead of special-casing the [0] element but I think that's a minor point.)EDIT: I am wrong. The initial -inf means the first term is always assumed to be in an increasing subsequence, even if it is part of a decreasing subsequence:
>>> list(monotonic_direct([10, 9, 8]))
[[10], [9, 8]]
As such, the original reference "Monotonic" implementation is wrong, as well as Ned's version! >>> list(mono_runs_simpler([10, 9, 8]))
[[10], [9, 8]]
It should be [[10, 9, 8]].