Cycle (de)composition creative solution for Rolling 🎲! by veky - python coding challenges

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

Cycle (de)composition solution in Creative category for Rolling 🎲! by veky

import itertools

c = lambda *e: dict(itertools.pairwise([1, *e, 1]))
d = dict(N=c(2,6,5), W=c(3,6,4), S=c(5,6,2), E=c(4,6,3))

def rolling_dice(moves: str, s: int = 1) -> int:
    for m in reversed(moves): s = d[m].get(s, s)
    return s

May 1, 2023

Comments:

StefanPochmann on May 8, 2023, 9:29 p.m.
Combining your backwards idea with my "speedy" idea of using one lookup per move: ```python from functools import reduce u, f, r, l, b, d = ({'side': i} for i in range(1, 7)) def set(state, *NSWE): state |= zip('NSWE', NSWE) set(u, f, b, r, l) set(f, d, u, f, f) set(r, r, r, d, u) set(l, l, l, u, d) set(b, u, d, b, b) set(d, b, f, l, r) def rolling_dice(moves: str) -> int: return reduce(dict.get, reversed(moves), u)['side'] ```

veky on May 9, 2023, 2:34 a.m.
I also have the <a href="https://py.checkio.org/mission/rolling/publications/veky/python-3/authors-pythonified/">lookup version</a>, you might be interested to know about it. :-) Besides, your code can look much nicer without that much bureaucracy. :-] <pre class='brush: python'>from functools import reduce as R u, f, r, l, b, d = {}, {}, {}, {}, {}, {} u.update(s=1, N=f, S=b, W=r, E=l) f.update(s=2, N=d, S=u, W=f, E=f) r.update(s=3, N=r, S=r, W=d, E=u) l.update(s=4, N=l, S=l, W=u, E=d) b.update(s=5, N=u, S=d, W=b, E=b) d.update(s=6, N=b, S=f, W=l, E=r) rolling_dice = lambda m: R(dict.get, m[::-1]+'s', u) </pre> (My idea was to minimize the redundant information: cycles always contain the upper side, and it is enough to specify the rest of the cycle.)

StefanPochmann on May 9, 2023, 3:22 a.m.
Hmm, for each move, that "lookup version" builds four lists, a dict, does a dict lookup, three subtractions, and six assignments. Pretty much the opposite of my goal of minimizing the work. I like your above rewrite. Longer lines, but simpler/clearer/nicer. I hadn't much tried making that better, was happy enough to just get it done, and was actually hoping you'd have some improvement :-) It's funny you say you wanted to minimize the redundant information in yours. I had considered pointing out that you have redundant information, as the middle is always 6 and the other two add to 7, so this is less redundant: ``` c = lambda e: dict(itertools.pairwise([1, e, 6, 7-e, 1])) d = dict(N=c(2), W=c(3), S=c(5), E=c(4)) ```

StefanPochmann on May 9, 2023, 3:32 a.m.
<blockquote> I like your above rewrite. Longer lines, but simpler/clearer/nicer </blockquote> The middle parts, I mean. Not a fan of the lambda abuse, `R` name, and `m[::-1]+'s'` (creating two additional long strings, and I prefer the final side number lookup to be more separate).

veky on May 9, 2023, 6:14 a.m.
Well, it seems that both of us expect of each other to rewrite our respective work, because we can't be bothered to do it all the way properly. It's not a bad distribution of labour, currently. :-D <hr /> About your second post: <ul> <li>we talked about lambdas ad nauseam. I don't consider this usage "abuse". The fact that we need a function is just an artefact of CheckiO's testing system. In ordinary usage most of us would just write the expression after the colon.</li> <li>`R` is just a `r`andom name. :-) Surely `reduce` is just as random (considering Guido wanted to remove it from builtins precisely because it doesn't evoke the right intuition for most users). Maybe fold`r` could be more to your taste? :-D</li> </ul>

StefanPochmann on May 9, 2023, noon
Well I'm not saying it's terrible, I just mean abuse in the sense of using it in a way explicitly against what it's intended for (judging by documentation/help/PEP8). And I'm not saying you shouldn't do it, just saying that I don't like it. That's all. Also because I prefer to not change given task specs without really good reason (That's why I don't mind your `c = lambda` much, since that's your own). "foldr" just reminded me that I still haven't learned Haskell... sad :-(

veky on May 9, 2023, 12:39 p.m.
Well, in my view "abuse" is a pretty strong word for "something I don't like". But never mind. OMG, please never learn Haskell then. If you're this good at programming without knowing Haskell, I'm scared what might happen if you do. :-D

StefanPochmann on May 9, 2023, 1:20 p.m.
The "I don’t like it" aspect is just a consequence, I call it abuse purely because it's against the intended use. I guess "misuse" would be a better word? It's similar to when people in Python context say truthy/falsy. I don't mind those words in general, but in Python context, they're going against the official terminology of true/false, and that bothers me. Oh, so Haskell will make me a better programmer? Maybe it'll influence my Python, similar to how it's already a hobby of mine to rewrite Python code to not use Python looping, instead plugging itertools/builtins together. Stuff like `map(map, ...)` is quite fun.

veky on May 9, 2023, 1:54 p.m.
Now you're making the same mistake the truthy/falsey people do: thinking a scope covers something when in fact it doesn't. Please read <a href="https://docs.python.org/3/reference/expressions.html">https://docs.python.org/3/reference/expressions.html</a>#lambda and tell me: where the "intended use" you're talking about is specified? Of course, you might talk about the well-known document whose first sentence says "This document gives coding conventions for the Python code comprising the standard library in the main Python distribution." But that's obviously out of scope here. <hr /> Now, a bit more seriously: I'm quite sure that when Guido pondered whether to include lambda in the Python language, he never thought it might be used in systems like CiO. Not even a time machine helps with that. :-) (Even now, Guido obviously doesn't consider CiO an important part of Python ecosystem.) You can't predict every usage of your design -- and if you try, you become C#. That's why I love languages that don't try; or at least, try so subtly that I can pretend it doesn't exist. In my view, using lambdas on CiO is not misuse in the same way it is not a officially sanctioned use. It is in neither of those categories, simply because CiO was not even an idea in Bryukh's mind at the moment when "intended use" of lambdas was decided. <hr /> Yes, that's exactly why they call it "programming in functional style". (BTW, if you do learn Haskell, please use fmap instead of map. You'll understand and thank me later.:) But it's also why I'm so surprised you haven't learned Haskell yet. It seems you long for this language so much that you write it in other languages. :-D [Which is not strange at all for people who know language A well, to write it in language B which they know not so well. You're the first person where I've seen the opposite phenomenon.:]

StefanPochmann on May 9, 2023, 2:45 p.m.
No, I'm well aware of that scope of PEP 8. But as it's written by makers of Python, it can provide additional insight into their intentions with the language. The documentation/help are brief, they say "used to create anonymous functions". <a href="https://docs.python.org/3/reference/compound_stmts.html#function-definitions">Another part</a> extends that to "create anonymous functions (functions not bound to a name), for immediate use in expressions." That, together with what they wrote in PEP 8, makes me believe that your use is against their intentions (for the feature itself, not just for standard library code). Just posted an example of <a href="https://py.checkio.org/mission/second-index/publications/StefanPochmann/python-3/overkill-plug-itertoolsmap-together/">plugging itertools/builtins together for great good</a>.

StefanPochmann on May 9, 2023, 5:01 p.m.
<a href="https://py.checkio.org/mission/second-index/publications/StefanPochmann/python-3/overkill-plugging-itertoolsmap-together/">Improved example</a> for itertools contraptions (the earlier one was messy).

veky on May 9, 2023, 8:42 p.m.
PEP8: Additional insight into their intentions with the language as used when implementing its own standard library, sure. But that's a really small part of the usage of the language. Why else would they e.g. add the support for non-ASCII identifiers just to forbid them entirely in PEP 8? <hr /> Another part: Well, in my opinion you misquoted it. Here is the context: <blockquote> It is also possible to create anonymous functions (functions not bound to a name), for immediate use in expressions. This uses lambda expressions, described in section Lambdas. </blockquote> Note that it very carefully avoids saying that this is the only usage of lambdas. I really think this is intentional. <hr /> Yes, the great good example is exactly what I would expect from you. You might be interested to learn that Fibonacci sequence in Haskell can be defined as <pre class='brush: python'>fibs = 0 : 1 : zipWith (+) fibs (tail fibs) </pre> which kinda corresponds to Python's <pre class='brush: python'>fibs = (0, 1, *map(sum, *zip(*pairwise(fibs)))) </pre> though of course, without lazy evaluation it doesn't really work.

StefanPochmann on May 9, 2023, 10:39 p.m.
Did you mean like this? ```python fibs = (0, 1, *map(sum, pairwise(fibs))) ``` Working version (<a href="https://ato.pxeger.com/run?1=VVDLasMwEKRXfcUepeKG5FAoheZHSjGyvCJLbWmRVpR8Sy65tB-Vr4lcOy-dpNXM7Mwc_ngvuxiOx98i_uXt9LT1KY5AgkliHDLQyDEJuJ2l0IAgNsCW0g_leqM8kEOlevTgqYvBOkfavCuopw5atkkyfMCnXjewMV-Xj2n2L7ma1rXTOtsNqK8cc0W2sQgXaeaHR-w7674rv3qZ8At0sFWjXaRHyzqX8WZVP5CNeTS4sswYen3TmAEJpaRw70IpThREP8_J9V3omu_VmLnGpc1Lq2c">Attempt This Online!</a>): ```python from itertools import chain, tee, pairwise, islice def fibonacci(): fibparts = [(0, 1)] fibs = chain.fromiterable(fibparts) fibsoutput, fibsfeedback = tee(fibs) laterfibs = map(sum, pairwise(fibsfeedback)) fibparts.append(laterfibs) return fibsoutput print(*islice(fibonacci(), 15)) ``` On the one hand I'm looking forward to not needing such trickery in Haskell, on the other hand it's a fun puzzle :-) What difference does the extended quote/context make? I don't think I misquoted that. I just left out that that talks about lambdas, which was redundant since that's what we're talking about. And I think by binding the function to a name for later use you do go against all of "anonymous", "not bound to a name", and "for immediate use in expressions". <blockquote> Note that it very carefully avoids saying that this is the only usage of lambdas. I really think this is intentional. </blockquote> I don't. Or at least I don't think that that means other usages are intended as well, especially usage that's the opposite. You say what you intend, and you don't say what you don't intend. Especially when guided by <a href="https://devguide.python.org/documentation/style-guide/#economy-of-expression">Economy of Expression</a> and <a href="https://devguide.python.org/documentation/style-guide/#affirmative-tone">Affirmative Tone</a>.

veky on May 10, 2023, 6:08 a.m.
If it were the opposite, I'd agree with you. But I don't think so. As I said, naming the functions defined (or even defining them as functions) is just a technical detail necessary because we're living here on CiO, which has a certain architecture. The proof is simply that no CiO mission (that I'm aware of) cares about the `name` of the function defined. On some other systems, you wouldn't even (need to) define functions, let alone name them; you'd just `input` your test cases and `print` your results. Surely then, if someone used `read`, `readline`,...; or if they used `write`, `log` or any of the other ways to do I/O, you wouldn't say it's "abuse"?

The Game is Worth it!

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.