double updown - no imports clear solution for Changing direction by juestr - python coding challenges

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

double updown - no imports solution in Clear category for Changing direction by juestr

def changing_direction(elements: list) -> int:
    cmp = lambda a, b: (a > b) - (a < b) 
    updown = lambda xs: list(filter(None, map(cmp, xs, xs[1:])))
    return len(updown(updown(elements)))

Aug. 20, 2022

Comments:

veky on Nov. 15, 2022, 9:28 p.m.
yes, it's nive that in absence of zeros, two first ducks are in fact the same. 🦆😅

bogdan.n.petru on Nov. 29, 2022, 7:16 a.m.
wow, the "(a > b) - (a < b)" part stayed in my mind for a while. I would of never thinked to substract booleans. Nice!

juestr on Nov. 29, 2022, 1:34 p.m.
The parent class of `bool` is `int`, and `True` and `False` are just specially typed constants `1` and `0`. 😀

H0r4c3 on April 30, 2023, 9:26 p.m.
This solution is a real lesson in Python! Lambda, filter, map. And the best, subtraction of booleans.

freeman_lex on April 10, 2024, 6:52 p.m.
This Python code defines a function `changing_direction` that takes a list of elements as input and returns the count of times the direction changes between consecutive elements in the list. Let's break down the code step by step: <ol> <li>`def changingdirection(elements: list) -> int:`: This line defines a function named `changingdirection` that takes a single argument `elements`, which is expected to be a list. The function is annotated to return an integer (`-> int`), indicating that it returns an integer value.</li> <li>`cmp = lambda a, b: (a > b) - (a < b)`: This line defines a lambda function `cmp` that takes two arguments `a` and `b` and returns 1 if `a` is greater than `b`, -1 if `a` is less than `b`, and 0 if `a` is equal to `b`. This effectively compares two elements and returns their relative order.</li> <li>`updown = lambda xs: list(filter(None, map(cmp, xs, xs[1:])))`: This line defines another lambda function `updown` that takes a list `xs` as input. <ul> <li>`map(cmp, xs, xs[1:])` applies the `cmp` function pairwise to the elements of `xs` and its consecutive elements (`xs[1:]`), effectively comparing each element with its next one.</li> <li>`filter(None, ...)` filters out elements from the result of the `map` operation where the comparison is 0 (meaning elements are equal), effectively removing consecutive equal elements.</li> <li>`list(...)` converts the filtered result into a list.</li> </ul></li> <li>`return len(updown(updown(elements)))`: This line applies the `updown` function twice to the `elements` list and then calculates the length of the result. <ul> <li>The first call to `updown(elements)` compares consecutive elements in `elements` and removes consecutive equal elements.</li> <li>The second call to `updown` then compares the modified list again, effectively detecting direction changes.</li> <li>`len(...)` calculates the length of the resulting list, which represents the count of direction changes.</li> </ul></li> </ol> In summary, this function calculates the number of times the direction changes between consecutive elements in the input list using lambda functions for comparison and filtering.

List but not the least

0 %

You ClassRoom Demo is Ready With the new tool CheckiO ClassRoom, you will be able to analyze your students' progress, have your own leaderboard, change missions order on the map, and so on.