Lion in Cairo clear solution for Reverse Every Ascending by veky - python coding challenges

Enable Javascript in your browser and then refresh this page, for a much enhanced experience.

Lion in Cairo solution in Clear category for Reverse Every Ascending by veky

def reverse_ascending(items):
    run, current = [], -float('inf')
    for element in items:
        if element > current:
            run.append(element)
            current = element
        else:
            yield from run[::-1]
            run, current = [element], element
    yield from run[::-1]

Dec. 6, 2018

Comments:

Phil15 on Dec. 7, 2018, 5:31 p.m.
I did use yield from too but I prefered `yield from reversed(run)` to slicing making a copy. I quibble a little. =)

veky on Dec. 8, 2018, 4:38 a.m.
Absolutely. This is an example of how CiO "lists everywhere" style (that it's currently going away from) has hurt me. I had a list result there, but then at the last moment saw that this is one of these newstyle missions where you can actually just write a generator, so I changed to yield from. I didn't think through all the consequences of that. :-) BTW do you know the source of "Lion in Cairo" metaphor? (Of course, I'd give you thumbs if only I could access your solution.;-/)

Phil15 on Dec. 8, 2018, 9:16 a.m.
I didn't know this metaphor and I still don't after a quick search. I thought too I had to return a list but didn't want it in my function. So I made a lambda decorator `to_list` before I realize it was not needed. Then I put it in comment.

veky on Dec. 8, 2018, 6:19 p.m.
<a href="https://py.checkio.org/mission/brackets/publications/veky/python-3/stack/share/9c7c708aa268a5130b5e5e0add474137/">https://py.checkio.org/mission/brackets/publications/veky/python-3/stack/share/9c7c708aa268a5130b5e5e0add474137/</a>#comment-19012 I have a better decorator, `@aggregate` with a parameter. So yours would be `@aggregate(list)`, but I have used all kinds of things there: `set`, `dict` (you yield pairs, and dict understands them as key-value), `''.join`, even things like `collections.Counter` or `sorted`. Of course, also `sum`, `max`, `any` and even `next`. ;-) Now, a homework for you: write `aggregate`. :-)

Phil15 on Dec. 8, 2018, 9:01 p.m.
I already have homework you know. I did backtracking for magic dominoes (this one take me a while...) and sudoku (easy one after dominoes). I'm on crossword solver and will create a mission if it wants to work well. But I like "meta decorators" (like everyone should) and I like the idea of your super `@aggregate(nearlyanythingI_want)`. And I really like it: <pre class='brush: python'># Of course it can be in one line and unreadable but first, I want to see its magnificence. # I didn't thought about a general "*my_args, **my_kwargs" before tonight. # Since we are doing the best decorator ever, we have to make it right! Even with documentation. from functools import wraps def aggregate(func, *my_args, **my_kwargs): def decorator(f): @wraps(f) def wrapper(*args, **kwargs): res = f(*args, **kwargs) return func(res, *my_args, **my_kwargs) return wrapper return decorator # Examples: @aggregate(''.join) # and not some @join('') @aggregate(sorted, key = len, reverse = True) @aggregate(next, None) @aggregate(sum, []) # to sum lists or ... @aggregate(max, key = sum, default = 0) @aggregate(collections.Counter) @aggregate(list.count, 0) # count 0 in result @aggregate(lambda res: set(map(len, res))) # A test: @aggregate(sorted, key = len) def func(m, n, L, a, b): """ A random function """ import random for _ in range(random.randint(m, n)): yield [random.choice(L) for _ in range(random.randint(a, b))] >>> func(3, 7, range(1,15), 2, 10) [[5, 11], [14, 12, 1, 7, 1, 2], [13, 9, 10, 4, 8, 14], [3, 11, 3, 13, 3, 8, 5], [5, 3, 13, 10, 11, 5, 5]] </pre> Well I thought that would be long and unreadable in one line but we have made worse than that, at least for the first version ^^: <pre class='brush: python'>aggregate=lambda F,*A,**K:lambda f:lambda*a,**k:F(f(*a,**k),*A,**K) aggregate=lambda F,*A,**K:lambda f:__import__('functools').wraps(f)(lambda*a,**k:F(f(*a,**k),*A,**K)) </pre> Thanks for inspiration. And the lion.

veky on Dec. 9, 2018, 6:35 a.m.
Great! Now solve it using `functools.partial`. :-]] I'm not really delighted that much with yourargs and yourkwargs feature... it really doesn't come up much often, and if it does, it seems it can almost always be solved with my simpler `aggregate` using `functools.partial` or `operator.methodcaller`. And yeah, adding `wraps` is a nice feature for something you're going to export, but I use my `aggregate` for years and never really missed that. Plus, in my implementation (which is in one line, that doesn't use `lambda`, but uses some other "standard extensions" of mine;) `wraps` would be nontrivial to add.

veky on Dec. 10, 2018, 9:36 a.m.
There is <a href="https://py.checkio.org/mission/roman-numerals/publications/veky/python-3/enum/share/22e044ab85d2e00f7c2bb4b0c7550f41/#comment-49265">another thread</a> about (among other things) `@aggregate` and how useful it really is.

Phil15 on Dec. 10, 2018, 11:20 a.m.
Yeah, I saw it. I'm happy you didn't tell me to make it with `functools.partial` at first because I have to admit I still have no idea yet about how partial appears here.

veky on Dec. 10, 2018, 2:29 p.m.
Well, look at the implementation of `functools.partial`. :-)

Phil15 on Dec. 10, 2018, 2:31 p.m.
I did it yesterday. I go for a second look, maybe it will be more clear after one day :-)

Phil15 on Dec. 11, 2018, 11:15 a.m.
It's about "composition of functions" so I don't see how to solve it (no matter how partial is awesome) without a function "compose". A "compose" function with two args would be enough to aggregate thing, but wanted a more general function. <pre class='brush: python'>def compose(*funcs): *funcs, f = funcs if not funcs: return f g = compose(*funcs) return lambda *args, **kwargs: g(f(*args, **kwargs)) </pre> Tried a little with `functools.reduce` but I couldn't have general (key-)arguments. Then partial is great <pre class='brush: python'>aggregate = partial(partial, compose) aggregate(func)(f) = partial(partial, compose)(func)(f) = partial(compose, func)(f) = compose(func, f) </pre> Tested on <pre class='brush: python'>@aggregate(sorted) def f(n, shift = 0): return [(-1)**i * (n - i) + shift for i in range(n)] </pre> Edit: Finally works with reduce <pre class='brush: python'>compose2 = lambda f, g: lambda *args, **kwargs: f(g(*args, **kwargs)) packing = lambda *args: args compose = compose2(partial(reduce, compose2), packing) >>> compose('~'.join, partial(map, str), reversed, range)(11) '10~9~8~7~6~5~4~3~2~1~0' </pre>

veky on Dec. 11, 2018, 5:34 p.m.
Well, yeah, I didn't have such generalizations in mind. :-) Yeah, binary compose is something I assume anyway. And I didn't really need *(*kw)args, so it was simpler. Anyway, it always amazes me when smart people prefer recursion over iteration for simple loops. For me <pre class='brush: python'>def compose(first, *functions): def composition(*args, **kwargs): x = first(*args, **kwargs) for f in functions: x = f(x) return x return composition </pre> is much simpler than what you wrote.

Phil15 on Dec. 11, 2018, 5:40 p.m.
I thought abouth both. I don't know why I choose one to the other. Anyway, it was good to better know `partial`.

List but not the least

0 %

PyCharm The Python IDE for Professional Developers. Enjoy productive Python, web and scientific development with PyCharm. Download it now!