~Shortest clear solution for Non-unique Elements by veky - python coding challenges

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

~Shortest solution in Clear category for Non-unique Elements by veky

checkio=lambda d:[x for x in d if d.count(x)>1]

Nov. 6, 2013

Comments:

dadeap on Nov. 7, 2013, 3:42 a.m.
smart !

veky on Nov. 7, 2013, 5:33 a.m.
Can I get a thumb then? :-)

floord on Nov. 7, 2013, 10:33 a.m.
Got one from me ;)

veky on Nov. 7, 2013, 10:56 a.m.
I meant on the solution, but thanks. :-)

dadeap on Nov. 7, 2013, 5:33 p.m.
ok that's how it works here ;p

wind on Nov. 21, 2013, 11:21 a.m.
another from me

_Chico__5d82cee4f5234e78a5c65e on April 24, 2021, 8:24 a.m.
Someone follow for follow?

veky on April 24, 2021, 9:04 a.m.
Wat?

_Chico__5d82cee4f5234e78a5c65e on April 24, 2021, 10:40 a.m.
Yes or no :O

veky on April 25, 2021, 4:18 p.m.
It would be much easier if I understood what you're suggesting. :-)

_Chico__5d82cee4f5234e78a5c65e on April 27, 2021, 2:39 p.m.
So i mean if somebody could follow me, then i would follow him/her

veky on April 27, 2021, 3:30 p.m.
Ah, that. I don't see the point of it. If you want to see someone's solutions, you just follow them. If you don't, then don't. What's accomplished by having many people following you? This is not Instagram. :-D

_Chico__5d82cee4f5234e78a5c65e on April 27, 2021, 3:34 p.m.
Yes your right ;-)

_Chico__5d82cee4f5234e78a5c65e on May 15, 2021, 8:07 a.m.
No ;-pp

veky on May 15, 2021, 9:24 a.m.
Sniff. :-P

BpLife on Nov. 10, 2013, 1:54 p.m.
<pre class='brush: python'>checkio=lambda d:[x for x in d if d.count(x)>1] </pre> Great

veky on Nov. 13, 2013, 6:22 a.m.
Thanks.

veky on Aug. 3, 2016, 6:05 p.m.
@zwooters: May I ask what is your problem? It's obvious you didn't dislike this concrete comment of mine, you're just trying to "punish" me for something (probably attitude, but all the comments I wrote about that you've -1'd also). I should probably tell you your method is not really effective - I really have all the points I need in this system, -28 will not send me back much. :-9 It would be much more constructive if we engaged in a discussion about what exactly you don't like. Or, if it's just my style of conversation that bothers you, report it to the mods: but please, try to keep it reasonable. If you report 28 comments of mine, some of which are just trivial "Thanks." or similar, you probably won't be taken seriously.

Reloader on Nov. 12, 2013, 1:23 p.m.
Why using lambda when you can just: <pre class='brush: python'>def checkio(data): return [x for x in data if data.count(x)>1] </pre> Is there any difference actually?

veky on Nov. 12, 2013, 8:58 p.m.
For me, it's other way around: "why use def when you can use lambda?". :-]] Namely, you can use def wherever you can use lambda, but you can't use lambda wherever you can use def. You could have asked me "why use list comprehension when you can use loop and append?", the answer would be the same: it's shorter and more to the point. (I'm golfing, in case you didn't notice.:) Of course, there is always the tradeoff. For lambda, it is harder to debug, since lambda doesn't know it's name (as opposed to def), so in traceback it is written just as an anonymous function. But for me, that is a non-issue here: I know this program can't have any bugs (and even if it did, there is only one function in it, so there is no ambiguity:). :-] PEP8 discourages assignment of lambdas (in favor of def) for precisely this reason. So, don't use it in production code, and (obviously) never use it in a Python library. But for recreative golfing, why not? It's whole 5 characters shorter. ;-)

BranoZarnovican on June 13, 2014, 1:39 p.m.
Equivalent lambda is less readable.. <blockquote> So, don't use it in production code </blockquote> I thought "Clear" category is for production code.

veky on June 13, 2014, 2:33 p.m.
<blockquote> Equivalent lambda is less readable.. </blockquote> ...for you. <blockquote> I thought "Clear" category is for production code. </blockquote> Oh man, you're going to be severely disappointed. :-D

markusmeskanen on Nov. 16, 2014, 2:53 p.m.
This is just silly. I'd guess over 90% of the people consider <pre class='brush: python'>def f(x): ... </pre> to be more clear than <pre class='brush: python'>f=lambda x: ... </pre> And since this is "clear" category, maybe you should try to make it clear. Also, you're one hella cocky guy, stop acting like you're better than others please.

mikmiker on Nov. 23, 2014, 9:44 p.m.
I agree that def f(x) would be clear while lambda is much more complicated. I'd put this in the 'Creative' or even the 'Speedy' category.

veky on Nov. 24, 2014, 9:41 a.m.
Noted. But please see below for answer to your other comment.

veky on Nov. 16, 2014, 2:58 p.m.
First, you're missing return in def. And do you have any surveys to back that up, or is it just your impression? And second, you're welcome to contact me by mail, where you can practice your coffeeshop psychology. This is not the place to discuss my character.

veky on Dec. 16, 2014, 2:04 a.m.
<blockquote> you’re welcome to contact me by mail, where you can practice your coffeeshop psychology. This is not the place to discuss my character. </blockquote> I guess I haven't really explained my view of the world here. There is a much more detailed "rant" at <a href="http://www.checkio.org/mission/secret-message/publications/veky/python-3/filter/share/efd4e41ef30dcac9af99dcd6c84ae149/#comment-21350">this comment</a> (search for "Attitude:" item). Maybe it helps somebody.

makernaren on Dec. 24, 2014, 7:56 p.m.
Judge the code, not the coder.!

ZenMittal on Sept. 21, 2017, 4:33 a.m.
Beautiful <3

gannicusw9 on April 6, 2016, 8:26 a.m.
good

veky on April 6, 2016, 9:07 a.m.
What? :-)

hueyhuecoyotl on April 2, 2015, 12:59 p.m.
veky, Your solution is absolutely correct & equivelent to the solution using def. However it is not considered "pythonic". Check the python style guide, it is called PEP-8, just Google it & search the page for lambda. You can find the guide here: <a href="https://www.python.org/dev/peps/pep-0008/">Python Style Guide</a> <blockquote> Always use a def statement instead of an assignment statement that binds a lambda expression directly to an identifier. </blockquote> It says: <blockquote> Yes: def f(x): return 2*x No: f = lambda x: 2*x </blockquote>

veky on April 2, 2015, 1:58 p.m.
LOL. I admire your enthusiasm. But look: I'm level 19 here. I have few hundred followers, and I've written about two thousands comments here. Do you really think I don't know about PEP8? :-) Since you're so enthusiastic, you might as well learn something. Click on your link and read the first sentence of PEP8. You might be surprised. ;-)

polettix on Aug. 12, 2015, 1:12 p.m.
Not sure what you consider "the first sentence" - I read it as "This document gives coding conventions for the Python code comprising the standard library in the main Python distribution." and I'm still wondering why I'm not surprised :-) For someone totally new to the language (but not to programming in general) I can't judge on the 'pythoniness' of this solution. I do find it harder to read WRT others though, and I'd categorize it as "Creative". All in all a good golfing job, but not helping me too much here considering that it's my first exercise here in CiO and with Python in general.

veky on Aug. 12, 2015, 7:45 p.m.
"Pythonic" is not the same as "should be part of Python stdlib". There are many perfectly Pythonic programs (and modules) that don't have the ambition of entering standard library. It's perfectly ok to find it harder to read WRT to some others. No solution is perfect for everyone (and mine being on top is mostly just an artefact of this voting system). Go, look at some other solutions. I'm sure you'll find something you'll like. That's the whole point of CiO... you see many approaches, and each has the chance to be liked by somebody. What this solution surely is not, is creative. It uses plain vanilla filtering list comprehension, with a condition that's directly hinted in the task. It also uses the technique that's explicitly listed above (in PEP8), so by definition cannot be creative. :-)

polettix on Aug. 12, 2015, 11:29 p.m.
As already said, I can't judge on the whole concept of what "Pythonic" means. I now understand you were referring to the Python stdlib, I would have expected something more "surprising". I never said I don't like your solution as you seem to imply, just that I find it hard to read and difficult to classify as "Clear" for someone at my stage. As a matter of fact, I'll be happy when I'll be able to understand your solution just looking at it.

veky on Aug. 13, 2015, 7:21 a.m.
I don't know if you are the same user as @hueyhuecoyotl - my sentence "you might be surprised" was directed to them. And of course, to all the people who think that PEP8 applies with equal strength to all Python code, which is nonsense. If you want to see Pythonicity codified, PEP20 would be a much better choice. But the title ("Zen") should tell you it cannot be easily codified. [Note the PEP number, and the number of lines in it.;] You did say my solution was "not helping" you - so I told you it's not the only one, you should look at the others, too. You say you're not new to programming - you probably come from Kingdom of C, or one of its numerous colonies. But <a href="http://www.checkio.org/mission/calls-home/publications/dagger126/python-27/first/share/0ae15fe634802b992d1c46528e67bb13/#comment-25209">not all beginners are like you</a>. There is no general solution that can be clear to all the non-Python-knowing people. :-) <blockquote> I’ll be happy when I’ll be able to understand your solution just looking at it. </blockquote> And <a href="http://www.checkio.org/mission/skew-symmetric-matrix/publications/hanpari/python-3/first/#comment-21224">that day will probably come</a>. :-) <hr /> BTW can I do a little experiment? Please read the following sentence <blockquote> "checkio takes d, and gives a list of all x from d such d's count of x is greater than one" </blockquote> and tell me whether you find it equally (similarly) hard to read as the above code, or much easier (or much harder, but I don't think so:) than it. I'm trying to figure out if Python's pseudocode translation is unintuitive, or the pseudocode itself is.

polettix on Aug. 13, 2015, 6:53 p.m.
No, not the same user as hueyhuecoyotl (hope I wrote it fine). When I read a sentence like "you will be surprised" I get curious. I just wanted to say that I didn't understand where I would have to get surprised, really nothing different from that. I surely said it was not helping me and my consideration was only related to the classification as "Clear". You seemed to think I didn't like it, but I never said it. Regarding the experiment, the description is quite easy to read as well as all solutions that are basically its direct translation using 'def'. Last time I played with functional programming was at the University some 8+ years ago for about one month, so you will pardon me if I don't get the 'lambda' at first sight :-) Looking at your explanation (that the lambda and the def solutions are basically the same) it makes sense to me, but the solution per-se is not immediately clear (to me). Cheers!

veky on Aug. 13, 2015, 7:49 p.m.
Ah, so lambda is the culprit. :-) [Don't think it's obvious... about half of users find list comprehension much more impenetrable.] If you don't mind me continuing, would you find <pre class='brush: python'>checkio = from d: [x for x in d ...] </pre> much more readable? I'm trying to see whether it's the strange keyword, or are function expressions themselves the problem.

polettix on Aug. 13, 2015, 9:48 p.m.
I don't know what "from" means, although of course I can go and study it; just reading it, I find it quite not-readable. I can guess the expression on the rhs returns a function because it's what checkio is supposed to be... but nothing more. As I said, I'm really new to Python - you can take a look at my solutions to see that I only use very basic constructs. The thing you write seems very "not-baby" Python.

veky on Aug. 13, 2015, 10:20 p.m.
No, "from" in that context doesn't mean anything. I just wanted to see if some other word could make the concept of function expressions more palatable to you. Ok, how about this? <pre class='brush: python'>checkio(d) = [x for x in d ...] </pre> Yes, I've seen your solutions. You do use very elementary steps (but not always - for instance, using dicts with fixed keys as primitive namedtuples is not a problem for you), but you also use Py2 and some very archaic constructs (like set([a, b]) instead of {a, b}) that make your code harder to read. You say you're new to Python... may I ask, why do you use Python2? About babies... well, functions are complicated. Even with def, you can write many strange things. :-) But yes, I see the value of "illusion of imitating what you already know" that's apparent in ordinary defs.

polettix on Aug. 13, 2015, 10:43 p.m.
I'm using Py2 because 2.7.5 is what I get in Mac OS X Mavericks and 2.7.3 is what I get in the Debian I regularly use. I mostly search for stuff on the Internet and that is where I found the docs for set() - didn't know that {...} is equivalent! Neat trick I would say, thanks for hinting. The language I'm quite fluent with is Perl, this is probably why I feel at home using dicts. Please keep commenting if you have time to spare and nothing better to do, it's very appreciated.

veky on Aug. 14, 2015, 6:19 a.m.
Augh... then it's worse than I thought. IMO, certain situations (like dependencies on stubborn libraries) do warrant the use of Python2, but nothing below 2.7.10 should be used. And anyway, Python3 is just a better language. Just imagine someone gave you Perl4. :-O <a href="https://www.python.org/downloads/mac-osx/">https://www.python.org/downloads/mac-osx/</a> It's not hard. And `apt-get install python3` is even easier. ;-) <hr /> But I must say I find it puzzling that someone from Perl Anarchy has trouble with lambdas. At least Perl makes no difference at all between named and unnamed functions: <pre class='brush: python'>sub checkio($d){ return *whatever; } </pre> vs <pre class='brush: python'>checkio = sub($d) {*whatever} </pre> The only difference is that Python calls the first sub `def`, and the second `lambda` (and uses colons instead of braces:). <hr /> I'll try commenting, but currently I don't have much time (and these reviews really do take time:). If there is some specific solution of yours you want me to look at, you can post a link to it in response to my solution of the same task (or here).

polettix on Aug. 14, 2015, 11:23 a.m.
Well, there is a not-so-subtle difference in the two examples you gave (neither would compile btw) in that the first would lead to a sub definition in the current package, the latter most probably in a sub being assigned to a scalar for later usage, so you would use different syntaxes to call them. But I do get the idea, thanks for taking the time to craft an example. It's possible that I find 'def' a bit more "natural" just because it's so easier to find examples around that use that instead of lambda, but it's good to know that the difference is not that big anyway. Thanks also for the hint about the release, I'll do that. I have a curiosity then: why does CiO allow the choice then? I would be surprised to see anything supporting Perl 4 these days, unless in some obscure cave :-)

veky on Aug. 14, 2015, 3:10 p.m.
Well, `whatever` is obviously an `undef`, but besides that, I don't see why it wouldn't compile... ok, I forgot * in front of checkio in the second code block (or do I need & there?)... but first should compile. If I see right, Perl has recently finally got support for signatures. :-) What am I missing? <hr /> Yes, Perl differentiates them when calling, while Python differentiates them when defining them. Neither is essential - for instance, JavaScript does neither. :-) <blockquote> It’s possible that I find ‘def’ a bit more “natural” just because it’s so easier to find examples around that use that instead of lambda, </blockquote> That's the precise reason why I'm fighting for rehabilitation of lambda. People don't show them to beginners because it's thought they'd find it unnatural, and they find it unnatural because they don't see it anywhere. :-) <blockquote> why does CiO allow the choice then? </blockquote> Ah, that's a sad story. According to many people, transition from 2 to 3 wasn't managed well (think Perl6, only Python3 is sane;). Python3 was imagined to be cleaned from all warts and design mistakes of Python2, and it seems there were too many of them for a single switch. Despite heroic later attempts to reconcile the differences, some people out of laziness, some out of ignorance, and some out of pure spite, declined to upgrade. But the hardest reason was that many libraries that many people depended on, didn't switch for a long time. Now practically all of them have either switched or became obsolete (see <a href="https://python3wos.appspot.com/),">https://python3wos.appspot.com/),</a> but still, the inertia is overwhelming. Just this year, Python2 was supposed to be EOLifed (Py3 was released seven years ago), but Guido didn't really have much choice but to prolong the support for five more years. Amusingly, especially the <a href="https://jakevdp.github.io/blog/2013/01/03/will-scientists-ever-move-to-python-3/">scientific community</a> was very hard about the switch. Anyway, yes, for people having huge codebases or dependencies already, I understand their need to stay with Py2. But that's not a reason to punish new users with an objectively worse language. Whatever somebody thinks about the difference then, in the meantime development of new features in Py2 has practically stopped, while Py3 has got many great new features.

rhcoder on Nov. 12, 2013, 5:02 p.m.
awesome

veky on Nov. 12, 2013, 9 p.m.
How much awesome converted to thumbs? :-)

Scofield on Nov. 16, 2013, 11:19 a.m.
perfect

veky on Nov. 16, 2013, 10:58 p.m.
Thanks. Though... It always puzzles me when people obviously like my solution, but don't give it thumbs. Unintuitive interface?

Scofield on Nov. 17, 2013, 2:26 a.m.
Got one from me. Haha,it seems that you like thumbs very much

veky on Nov. 17, 2013, 6:31 a.m.
I, same as many people, like the acknowledgement that what I do is nice in some way, and somebody likes it. I often write my code in order to teach people some "hidden corners" of Python. Thumbs increase the chance that others will see it. Thanks.

floord on Nov. 17, 2013, 2:04 p.m.
Maybe it's UI. But I guess a large part is also behavior driven. We can work on a culture where giving a thumbs-up is more common - but as always: a better world starts with you! ;)

veky on Nov. 17, 2013, 6:09 p.m.
I don't consider others' code "perfect" often. But when I do, I surely give as many thumbs as I can. :-)

abesto on Nov. 20, 2013, 4:51 p.m.
Are you sure this is O(n)? d.count(x) counts the number of times x occurs in d for each element of d. Since d is a list, I'm assuming this takes n steps (compare x to each element of d). Since you need to do this for each element, this solution is O(n^2) instead of O(n). You can get O(n*logn) by building a map of `number -> occurences` pairs in one loop, and then filtering the original list based on that. This is also not O(n) because insert and lookup in a hash-map is typically O(logn). Correct me if I'm wrong, I'm always looking to learn.

veky on Nov. 20, 2013, 7:41 p.m.
You're not wrong about math. You're wrong about what I said. I never said this is O(n), nor is it meant to be. My other solution is for people obsessed with complexity classes. This one is for golfing. :-)

abesto on Nov. 20, 2013, 7:47 p.m.
Ah. I assumed the box on the right at the top is a description of this solution. Turns out it's a link to the next published solution. Sorry :)

veky on Nov. 20, 2013, 7:51 p.m.
Actually, they are links to all published solutions by me of that task.

hanpari on Dec. 17, 2014, 1:42 p.m.
Where? I never find them.

veky on Dec. 17, 2014, 4:15 p.m.
Maybe that's because you joined CiO after this horrible redesign. :-/

hanpari on Dec. 17, 2014, 6:42 p.m.
Wishful thinking :) I have been here for one year. I saw already two redesign. I have to admit I liked the best that one coming from time when I had registered.

marshall.zheng on Nov. 20, 2013, 10:52 p.m.
Statement is cool but I think it's not effective especially when the list is very big.

veky on Nov. 21, 2013, 7:46 a.m.
Of course. That's why I have other solution. Haven't you seen it? Read it, you'll probably learn something. ;-) BTW: see "how it is used". No mention of "effectiveness" (you mean efficiency, probably). And performance is one of most poorly understood aspects of Python.

Slerig on Dec. 11, 2013, 9:05 p.m.
Same way I was going to do it, but I was too lazy so I did it the boring way.

veky on Dec. 12, 2013, 8:58 a.m.
You have a weird definition of lazyness. :-P

Slerig on Dec. 13, 2013, 4:27 a.m.
Well I know how to do it that way in Haskell, but I am new to Python and didn't feel like looking up how to do list comprehensions in Python. Haha.

sgino209 on Dec. 17, 2013, 7:58 p.m.
very elegant

veky on Dec. 17, 2013, 7:59 p.m.
Thanks, but this is really straightforward. See other solution of mine for elegance. :-D

zulqarnain on Dec. 24, 2013, 3:16 p.m.
NERD!

veky on Dec. 24, 2013, 11:45 p.m.
Where? :-D

adam1410adam on Dec. 29, 2013, 12:58 a.m.
I did it similar way. One line solutions are the best! Regards

veky on Dec. 29, 2013, 3:50 p.m.
If you like oneliners, you should check out other solutions of mine. For some reason people call them oneliners even when they have five lines. :-D

Norore32 on Jan. 21, 2014, 4 p.m.
Thumb up for you. I really need to see how lambda functions! One day I will be able to use it! :)

veky on Jan. 21, 2014, 5:12 p.m.
You can use it now. Just take any function of the form <pre class='brush: python'>def func(args): return expression </pre> (for any "func", "args", and "expression") and convert it to <pre class='brush: python'>func = lambda args: expression </pre> That's all. No magic there. (Of course, PEP8 doesn't like it. But you have an option to not care about it.:)

oduvan on Jan. 21, 2014, 8 p.m.
You should find more solutions from veky and very soon you will start hating lambda function :)

veky on Jan. 21, 2014, 8:57 p.m.
... or loving them even more, you never know. :-P

oduvan on Jan. 21, 2014, 9:34 p.m.
Of course! I was just kidding :)

Gthegrey on Jan. 27, 2014, 8:44 p.m.
Impressive !

veky on Jan. 28, 2014, 4:28 a.m.
Thanks, but honestly, you ain't seen nothing yet. ;-)

Dubforce on Feb. 7, 2014, 1:51 a.m.
Can someone explain this?

veky on Feb. 10, 2014, 12:51 p.m.
What? :-) It's a list comprehension. Just read it, you'll probably understand. :-)

veky on Sept. 27, 2014, 5:42 a.m.
I've noticed a tendency: people come and like my solution, and then dislike comments like these. Fascinating. :-) Let's try this. If I wrote this sentence in this comment: "checkio takes d, and gives a list of all x from d such that number of occurances of x in d is greater than one" is it really so different than what I wrote above in fixedwidth font? If it is, please explain how. (I know about lambda, but I think people are puzzled by list comprehension more.) If you're just giving me -1s for my arrogance, that's ok. I have no problems with that. :-P But if you honestly read the above sentence in this comment much more easily than the equivalent sentence in Python code above, I'd really like to know.

MarwenOunis on Feb. 9, 2014, 5:19 p.m.
Awsome !!!!

ouyangyiyun on Feb. 10, 2014, 5:47 a.m.
That's good

odwl on Feb. 27, 2014, 7:11 p.m.
This is really inefficient o(n2). So it is actually not good at all for real usage because a o(n) solution exists.

thugwaffle on April 23, 2014, 2:45 a.m.
Isn't this O(n) because he only loops through the list once?

veky on April 23, 2014, 6:26 a.m.
No, because .count loops through the list every time. (Of course, it all depends on what you think are elementary operations. People usually think that + on int is O(1), but it isn't if you count memory locations and processor instructions.)

veky on Feb. 27, 2014, 7:38 p.m.
You did see that I have an "O(n) :-P" solution too, right? :-)

odwl on Feb. 27, 2014, 8:38 p.m.
Ah yes right. Sorry. But I have been hit some many times by inefficient one liner in my real life. Note that I love efficient one liner. Your O(n) is very good.

veky on Feb. 27, 2014, 8:40 p.m.
If you look at the comments, you'll see it's still too slow for many people. Or it uses too much memory. Or whatever. You can never please everyone. :-D

bryukh on Feb. 27, 2014, 8:44 p.m.
I've written this phrase in my notebook ;-)

veky on Feb. 27, 2014, 8:45 p.m.
The most amazing thing is that someone dared to consider it too long. :-DD

Tamerlaha on Dec. 20, 2014, 6:14 p.m.
Could you please point me to that solution?

veky on Dec. 21, 2014, 3:51 p.m.
No problem: <a href="http://www.checkio.org/mission/non-unique-elements/publications/veky/python-3/on-p/?ordering=most_voted">http://www.checkio.org/mission/non-unique-elements/publications/veky/python-3/on-p/?ordering=most_voted</a>

avalon3515 on March 21, 2014, 7:51 a.m.
very good. But the lambda function is not easy to the new user....

veky on March 21, 2014, 1:15 p.m.
Neither are list comprehensions. Neither is Python as a whole, if you're coming from C-like language. :-P

lbernardelli on April 17, 2014, 9:11 p.m.
It´s not a clear code

veky on April 25, 2014, 7:58 a.m.
I see you're not happy about it. If you want me to help, you'll have to be more specific. What exactly isn't clear?

veky on April 18, 2014, 7:03 p.m.
Sorry about that. :-]

Snake2k on April 25, 2014, 5:20 a.m.
Well although it might not be clear but it definitely is creative, didn't think of that.

veky on April 25, 2014, 6:30 a.m.
Wait a minute. Are we talking about the same task? <pre class='brush: python'>#Some hints #You can use list.count(element) method for counting. #Create new list with non-unique elements </pre> Don't people read the instructions anymore? :-) About clarity, I'm sure we'll disagree (it's a long discussion). But creative it surely isn't. :-]

Snake2k on April 25, 2014, 6:35 a.m.
Oh I didn't mean it in that way, it's just that lambdas tend to throw people off and by creative I meant "quick" and "short" :) I should've given a better detailed comment lol.

veky on April 25, 2014, 7:54 a.m.
Ah, lambdas. They are so uncreative that pep8 speaks about them specifically in the new revision: "Always use a def statement instead of an assignment statement that binds a lambda expression directly to a name." :-) No, really. That is just a straightforward find-replace. <pre class='brush: python'>func = lambda args: expr </pre> is the same as <pre class='brush: python'>def func(args): return expr </pre> (only shorter). A regex can do it without problem. For example, converting list comprehension to loops with append is much more work, and nobody complains it "throws people off". I guess it's about a name. "lambda" is a strange word. :-D

Snake2k on April 26, 2014, 2:21 a.m.
Yep the name is weird but it's just a name I guess lol

veky on Aug. 6, 2019, 10:25 a.m.
It's actually a misnomer. In the original writings by Alonzo Church, bound variables were indicated with a circumflex over them. So in fact it was something like â:a+3. But his handwriting was so horrible that the typesetter thought the circumflex was a separate letter, and the closest letter they could find was a greek lambda. :-)

timur.hamzin on June 9, 2014, 6:10 p.m.
wow! my code had like 15 lines!

veky on June 9, 2014, 6:14 p.m.
Impressive. :-P People usually solve it in five or so. :-D

rhemon on July 6, 2014, 5:28 p.m.
was it important to use the lambda?

veky on July 6, 2014, 7:28 p.m.
It depends on what you consider important. It was important for shortness, for mathematical conciseness, and for educational value. For functionality, it wasn't important. :-)

Gosha on July 17, 2014, 6:35 p.m.
Cool ! I can't do something like THIS !

veky on July 18, 2014, 9:49 a.m.
You probably can, you just don't dare. ;-)

debdeppeler on Aug. 19, 2014, 2:16 p.m.
very educational

peasant on Aug. 19, 2014, 2:48 p.m.
no new data structure as required.

veky on Aug. 20, 2014, 5:38 p.m.
I don't understand... are you trying to say that I modify the argument, instead of constructing a new list? Because that simply isn't true. (It's even disputable what's "required" here, but let's skip that argument for now.) List comprehension really does make a new list. If your complaint is about something else, please clarify.

jamestotle on Sept. 2, 2014, 1:11 a.m.
could be the most shortest.I use def instead.

veky on Sept. 2, 2014, 4:48 a.m.
If you see a shorter one, I'd very much like to know about it. :-)

gunmantheh on Sept. 26, 2014, 1:39 p.m.
lol, if I knew I could use lambda expression in Python, it would save me soooo much time. Thanks for this nice solution

veky on Sept. 26, 2014, 7:36 p.m.
"sooooo much time" to type def, newline, and return? Wow. :-)

gunmantheh on Sept. 29, 2014, 7:50 a.m.
didn't mean it just for this task. Meant it for python in general.

veky on Sept. 29, 2014, 7:53 a.m.
I also meant in general. Every lambda can be replaced with def, newline and return. And ok, you must invent a name. But that shouldn't be so hard. :-)

jy4446851 on Sept. 30, 2014, 10:11 a.m.
so smart!

ArchTauruS on Oct. 11, 2014, 1:35 a.m.
yeah :)

veky on Sept. 30, 2014, 11 a.m.
Not really, there are much smarter solutions. The word you're looking for is probably "simple". ;-)

typhoyder on Oct. 31, 2014, 2:30 p.m.
15 lines for me ^^.

veky on Oct. 31, 2014, 9:24 p.m.
That's above average. :-)

Olexandr-Statyshniuk on Nov. 2, 2014, 6:08 p.m.
Perfect!

veky on Nov. 2, 2014, 7:21 p.m.
Subjective. :-) But thanks.

mikmiker on Nov. 23, 2014, 9:47 p.m.
Yeah, "Shortest" is a good description for this. Probably fits better in the "Creative" or "Speedy" category. It's certainly not as clear and straightforward as other solutions I've seen.

veky on Nov. 24, 2014, 9:12 a.m.
First, it was written a long time ago, before categories. Second, about straightforwardness: please think about this, what do you think is more clear and straightforward? <pre class='brush: python'>index = 0 while index < len(sequence): print(index*2 + sequence[index]*3) index += 1 </pre> or <pre class='brush: python'>for index, item in enumerate(sequence): print(index*2 + item*3) </pre> And why? I would really like you to answer this. Then we can continue discussion. I promise you it will be interesting. ;-)

mikmiker on Nov. 30, 2014, 4:29 a.m.
I think the first example is more clear and straightforward because it uses all of the basic Python code that I, as a relative beginner, understand. In order to fully understand the second example, I have to learn about <a href="https://docs.python.org/2/library/functions.html#enumerate">enumerate()</a>. It's an extra step that I'd need to take in order to fully understand the code. I do not need to take this extra step (learning about enumerate) in order to fully understand the first example. That being said, once I learn about and understand enumerate(), the second would be more clear and straightforward to me.

veky on Nov. 30, 2014, 5:43 a.m.
Exactly. So, what morale can be deduced from that? <ol> <li>That people who write code must always write it in the most primitve possible way, just so newbies might consider it clear</li> <li>That we should teach newbies things like enumerate, so they too can write code that's more to the point, conveying more information while being less bureaucratic and less prone to fencepost errors</li> </ol> In fact both morales can be deduced. But the first one leads to stagnation, the second one to evolution. Here and now, evolution is much more needed. <hr /> This above was uncontroversial, I hope. Now you have to trust me: it's the same with this solution. It is the most straightforward solution of the given task. The fact that you don't see it is something that should be fixed, not the solution itself (nor its category).

mikmiker on Nov. 30, 2014, 5:40 p.m.
I appreciate your viewpoint even though I continue to disagree. I don't want to get too far into the weeds on semantics and such. Thanks for sharing, though. When I look back at your code, I still don't understand what it's doing. Maybe after I've spent some more time on CheckiO, I'll come back and be able to understand it better. I think your <a href="http://www.checkio.org/mission/non-unique-elements/publications/veky/python-3/shortest/#comment-18876">comment here</a> explains what's confusing to me ... list comprehensions. I can kind of understand the lambda and wonder why PEP8 prefers the def over lambda, but the list comprehension is the more difficult part of the solution to understand. What if instead of 'd' and 'x' you used 'data' and 'item'? Maybe that would make it more clear to more people? Like this: <pre class='brush: python'>checkio = lambda data:[item for item in data if data.count(item)>1] </pre>

veky on Nov. 30, 2014, 6:25 p.m.
<blockquote> I can kind of understand the lambda and wonder why PEP8 prefers the def over lambda, </blockquote> It's not so hard to deduce. I've written about that already, but search here is terrible. Try to locate it. :-) TF;DS (Too far; didn't search) version: when you're writing standard library, testing and debugging are much more important than catching the appropriate level of abstraction. But we're not writing standard library here on CheckiO. ;-) <blockquote> but the list comprehension is the more difficult part of the solution to understand. </blockquote> Thank you. Now tell that to oduvan, he doesn't want to believe me. :-Q (There are lot of people here who think that lambdas are somehow completely impenetrable to beginners. My experience teaching beginners tells me it is nonsense. Mathematical function, which is a notion many children have from school, is much more lambda than a def, after all.:) <blockquote> What if instead of ‘d’ and ‘x’ you used ‘data’ and 'item’? Maybe that would make it more clear to more people? Like this: </blockquote> Maybe. But "item" is too generic anyway, and "data" even more. "integer" and "integerlist" are most direct translation of task text. "elementiteratingthroughlist" and "argumentlistof_integers" is probably too much. :-D It's hard to put the line, especially when you don't know who will read the code. But I stand firmly that at least "data" in this context is in no way more informative than "d". ;-P "item" might be ok, and argument might be called "sequence", if CheckiO wasn't so obsessed with lists. ;-P <blockquote> I don’t want to get too far into the weeds on semantics and such. </blockquote> Ah, too bad. I think I might convince you given enough time. ;-P <blockquote> When I look back at your code, I still don’t understand what it’s doing. Maybe after I’ve spent some more time on CheckiO, I’ll come back and be able to understand it better. </blockquote> Incredibly relevant comment: <a href="http://www.checkio.org/mission/skew-symmetric-matrix/publications/hanpari/python-3/first/">http://www.checkio.org/mission/skew-symmetric-matrix/publications/hanpari/python-3/first/</a>#comment-21224 ;-D

Paul1 on Dec. 1, 2014, 5:03 p.m.
Nice!

veky on Dec. 1, 2014, 7:14 p.m.
Thanks.

forrest1988 on Jan. 14, 2015, 7:40 p.m.
Short and simple, nice

veky on Jan. 14, 2015, 8:41 p.m.
Thanks.

JConrad on Jan. 17, 2015, 5:25 p.m.
Very straightforward and nice :)

veky on Jan. 17, 2015, 6:32 p.m.
Thanks. You can give me some thumbs, too. ;-)

abe.dillon on Jan. 30, 2015, 7:20 a.m.
I want to say that while this is concise and the use of lambda is creative, this solution has a pretty awful time complexity of O(n^2). Normally, I prioritize clarity over optimization, but it pains me to see the [x for x in d if d.count(x)>1] solution tagged as speedy so often. This being an educational site, I really would like people to understand why that solution will bring their system to its knees when given a one-million-item list while the collections.Counter-based solution (or other O(n) solutions) finish in 250 ms. Sorry for being such a jerk. I'm commenting on yours mainly because it's the highest voted and has the most visibility. Also, if you ever get a chance, you should check out Julia's lambda syntax. It's super slick compared to Python IMHO.

veky on Jan. 30, 2015, 10:13 a.m.
You have the right to comment on my solution, and I have the right to respond to your comments. ;-) <ul> <li>First, this is not tagged as speedy. I agree it would be very wrong to publish this in Speedy category, notwithstanding the fact that I think categories are missing the point on CiO. :-)</li> <li>Second, I have an O(n) solution. It's very funny that you comment on this solution because it's the top one, when my collections.Counter solution is also top one in the right (Speedy) category.</li> </ul> (Yes, "most visibility" is a bug, as far as I'm concerned. There is really no reason why "Clear" category should be the default when viewing solutions. Complain to the admins, I have.) And now to more interesting things: <ul> <li>Use of lambda is not creative. Just look at PEP8, it speaks exactly of that usage (in another context, so it's discouraged from the perspective of debugging - but my point is that something is really not creative at all, if a canonical document speaks about it:).</li> <li>More importantly, speed is not everything. Yes, it's often an important criterion, and even more often it's unjustifiedly neglected, but it is really not the most important thing - otherwise we would all write in assembler (or C, since gcc is smarter than programmers nowadays:).</li> </ul> Yes, algorithmic complexity class is very important, and quadratic algorithms are much worse than linear, but speaking about concrete milliseconds misses the point (unless you just quoted that number qualitatively, as an illustration of a huge improvement). Quadratic is bad not just because it's slow, but because it's nondistributive: processing 2n items takes much more time than processing two batches of n items. That usually implies you're doing more work than necessary. :-) <ul> <li>There is an factor you haven't mentioned, and it's especially important in CiO as a learning community: people come here and read the hints. One of hints is to use `.count`. You could argue that it's a bad hint from the performance perspective, but it's an excellent hint about how Python works: an enormous amount of functionality is available as simply verb-named methods on builtin types. That's a lesson whose importance is usually missed by the people who have already learned it. :-)</li> </ul> Yes, an even greater amount of refined functionality is available in stdlib, as your collections.Counter example shows, but you have to start somewhere. core is relatively small, Python stdlib is <a href="http://xkcd.com/353/">huge</a>. ;-) <ul> <li>I guess there is a reason why precondition says that len of input is less than 1000. Usually I'm against such pointless limitations, but on such a beginner task, I guess it's an implicit blessing of naive algorithms. Here it's much more important to learn how Python works, than to solve this task in the most efficient manner.</li> </ul> <hr /> And the least important thing: yes, Julia lambda syntax "->" is cute. But Python is made for interactive learning in a digital age. You can google "Python lambda" without problems. Not so with "Julia ->". Operators are cool when used reasonably, but can't replace keywords in many cases.

veky on Nov. 23, 2016, 5:24 a.m.
<blockquote> You could argue that it’s a bad hint from the performance perspective, but it’s an excellent hint about how Python works: an enormous amount of functionality is available as simply verb-named methods on builtin types. That’s a lesson whose importance is usually missed by the people who have already learned it. :-) </blockquote> Once again, prog21 says it much better than I do: <a href="http://prog21.dadgum.com/226.html">http://prog21.dadgum.com/226.html</a>

busthehero_28e07718e67f4c8fbb7 on March 1, 2015, 7:25 p.m.
Very concise!

aaaaxiaofei on April 26, 2015, 7:36 p.m.
Thumb!

veky on April 26, 2015, 10:36 p.m.
Thanks! :-)

tntC4stl3 on April 28, 2015, 8:44 a.m.
good example for lambda!

veky on April 28, 2015, 9:49 a.m.
Thanks. Of course, PEP8 wouldn't agree, but that's because it has a different goal. :-)

Solid_Wong on May 3, 2015, 12:25 a.m.
cool

veky on May 3, 2015, 5:08 a.m.
Thanks. :-)

IvanShen on May 25, 2015, 9:43 a.m.
nice

veky on May 25, 2015, 12:47 p.m.
Tnx.

KaaPex on May 28, 2015, 10:38 a.m.
What about precondition: 0 < len(data) < 1000 If the list will be empty or more than 1000. Everyone had forgotten about it, business remembers ;)

veky on May 28, 2015, 10:45 a.m.
I think you misunderstood what precondition is. <a href="http://en.wikipedia.org/wiki/Precondition">http://en.wikipedia.org/wiki/Precondition</a> It is "you may assume this". It is not "you have to check this".

srvanmeter on June 29, 2015, 10:12 a.m.
Beautiful. I just wish I could wrap my head around the concept of lambda. I'll sit there and stare listlessly at any use of it for minutes, understanding little.

veky on June 29, 2015, 1:15 p.m.
Have you read the <a href="http://www.checkio.org/mission/non-unique-elements/publications/veky/python-3/shortest/share/6e3291603834bb924b10feb1a3725be5/#comment-6441">comment</a> above?

kradew_d1d60566bb6a44649c899c3 on July 21, 2015, 11:31 a.m.
Would an extra space or two be an overkill? It is both clever and concise, not to mention idiomatic as hell (which is cool), but "import this" and refer to line 9.

veky on July 21, 2015, 2:38 p.m.
"Readability counts"? Of course. (Though line 8, "Sparse is better than dense.", might be a better fit for what you're probably trying to say.) Please see <a href="http://www.checkio.org/mission/binary-count/publications/veky/python-3/hinted/share/7bcd07614f4c5183a12b675c05cceb5d/#comment-15915">this comment</a>. Ok, this is a bit more complex than that solution, but I still think you can perfectly well read and understand it without spaces.

kradew_d1d60566bb6a44649c899c3 on July 21, 2015, 3:15 p.m.
I probably failed at conveying my point. I have absolutely no problem with understanding what you've done in both cases (and it probably can't be more concise), but would you say that it does not affect the readability in a positive way by switching to: <pre class='brush: python'>checkio = lambda data: [x for x in data if data.count(x) > 1] </pre> If you do, I sincerely do not wish you to debug a code after someone who is allergic to whitespace and addicted to as short as possible variable names. Still think it is the most pythonic answer I've seen so far. Edit: You've even used the whitespace and more readable names in your own <a href="http://www.checkio.org/mission/non-unique-elements/publications/veky/python-3/shortest/share/6e3291603834bb924b10feb1a3725be5/#comment-12224">comment</a>.

veky on July 21, 2015, 11:07 p.m.
<blockquote> would you say that it does not affect the readability in a positive way by switching to: </blockquote> Yes, I would. <blockquote> If you do, I sincerely do not wish you to debug a code after someone who is allergic to whitespace and addicted to as short as possible variable names. </blockquote> I think you're confusing very different things. If someone gave me the above line to debug, that would probably be a very short excercise. I mean, seconds or at most minutes. It all fits in the head. It's immediately graspable. It's a filtering comprehension with a condition that's a bound method result compared with a constant. I've written at least 10 of beasts of the same structure. It's practically an elementary step for me. You could say that to someone else, it might be not immediately graspable, that they have to read the source and tokenize/parse it before they can see what it's doing, but still, I really don't think these 5 spaces would help them. First two (around `=`) are completely irrelevant, and a def instead of lambda would probably help more if someone gets confused so soon - the point is that probably the bug lies to the right of that. Third one is completely ridiculous, I stand firmly by my opinion that `data:[x` is separated enough without any space. [Note that this still applies only to oneliners. I'm not advocating changing PEP8 rules. I'm just saying PEP8 doesn't apply to oneliners, for much the same reasons Chicago manual of style doesn't apply to haikus. They should be judged by their own criteria for readability. Programs have structure according to their length. If you strictly require same format rules for one token, one line, one function, one module and one software package, you get syntactic amorphousness of LISP. Which is cool, in a way; it's just not Python.] For last two (around `>`) I'm willing to give you a slight slack: yes, I can see that those could help a typical maintainer more easily see what's going on. But still, there is also a value of binding more/less tight visually: the space around `if` could be argued to have to be greater than space inside the condition. Guido does recommend spacing operands apart or glueing them together according to priority: <pre class='brush: python'>2*x + 3/y </pre> and it's not a big stretch to generalize to <pre class='brush: python'>x<6 and y>3 </pre> (especially if it's a part of larger expression), and `if` here is very similar. But as I said, I realize this is a stretch (after all, `and` and `if` are keywords, not just symbols, for a reason), and those spaces could help. <hr /> About `data` instead of `d`: I hold firmly that it doesn't buy you anything in this context. That's a whole different can of worms, but again, there are two things to consider. First is name collision. If you have one-letter names in a larger program, you're exposing yourself to a risk that you'll inadvertently name two completely different things the same, and that could lead to subtle bugs in an imperative language with weird ideas about scope. :-D Also, a simple typo can much more probably then make a working program into another program that "works", only it doesn't do what you want (instead of a NameError you'd get if you used longer names). It goes without saying that these considerations are completely irrelevant in this case. Second considerations are semantic. I'm all for naming objects according to what they mean to us. However, semantics is hard (precisely because it's useful). You can't fake it by just using longer names. `data` is as useless semantically as `d`. `datagiveninanargumenttoa_function` would be just as useless. `numbers` would be better. `listofintegers` too. Of course, best would be for a task setter to tell us what they want us to really do (see <a href="http://xyproblem.info/">XY problem</a>). Based on that, maybe `attempts` would be good. Or `standards` (see Bill Gates quote at the beginning). We don't know what it is, and it would help us crystallize the logic. But it's not fakeable just by using longer names. [Even the converse doesn't hold: one-letter names can be perfectly semantic. See Hettinger's video "Beyond PEP8", about naming of variables. In languages where you have typed declarations, <pre class='brush: python'>FILE *f; </pre> is a perfectly fine name. Python doesn't have name-contextual declarations, but it has name-contextual protocols, for example iterations, or context managing / exception handling. <pre class='brush: python'>for i, el in enumerate(sequence): except Exception as ex: (and pandan of above:) with open(filename, 'w') as f: </pre> are perfectly fine names for the same reasons.] <hr /> I should also say something that's not easily visible here. I am on the other side of the fence, too. I'm writing Python professionally. Currently I'm the lead developer of an IT team for a bank startup. We're writing a financial framework that now has about 10% of its intended functionality, and about 1K lines of code. We have coding standards not much different from PEP8. We have code reviews, in which everything is on the table, and we value readability and semantic naming. We showcase our Python code even on meetings with financial people who usually can't stand looking at code, and they find it readable. I know what I'm talking about. I'm not an amateur that learned Python a week ago, and only writes oneliners. I'm just saying that War and Peace has a very different structure, and should have very different style rules, than a sonnet. And it's not a bug, it's a feature.

alex.makhnov on July 25, 2015, 5:03 p.m.
great!

veky on July 25, 2015, 6:26 p.m.
Thanks. :-)

jonsudragunov on Aug. 7, 2015, 6:14 a.m.
lambda use less resource of machine, but no more easy for read.

veky on Aug. 7, 2015, 7:02 a.m.
Not more, and in this case, also not less. :-)

danilovmy on Aug. 10, 2015, 2:28 p.m.
why you do a for, wenn you can get "Filter"?

veky on Aug. 10, 2015, 3:03 p.m.
Because `filter` would be more complicated in this case, without any gain? And tangentially, it wouldn't be shortest. ;-)

widzard on Aug. 17, 2015, 7:01 a.m.
great !!!

remakio on Aug. 19, 2015, 12:45 p.m.
Beautifull!

veky on Aug. 19, 2015, 5:23 p.m.
Thanks. :-)

srikwit2 on Aug. 23, 2015, 5:56 p.m.
This will take some time to understand but till then have an upvote.

veky on Aug. 23, 2015, 6:38 p.m.
Hm... giving upvotes on credit is probably not a good idea. Would this: <pre class='brush: python'>def nonunique(elements): for number in elements: appearances = elements.count(number) if appearances > 1: yield number def checkio(elements): return list(nonunique(elements)) </pre> help? It's the same algorithm, just written vertically instead of horizontally. :-)

zaulan on Aug. 24, 2015, 8:36 a.m.
smart speed)

veky on Aug. 24, 2015, 10:56 a.m.
Speed? Not really, this is a quadratic algorithm. There are linear ones, see Speedy category for that.

Bronepoezd on Aug. 24, 2015, 12:37 p.m.
Thank you, veky, for the idea how to solve Univocalic Factaral problem (<a href="http://www.checkio.org/mission/univocalic-factaral/)">http://www.checkio.org/mission/univocalic-factaral/)</a> without return.

veky on Aug. 24, 2015, 6:53 p.m.
This is the most original benefit someone has had from this solution. :-))

cool_cool on Sept. 2, 2015, 5:02 p.m.
This is not CLEAR!

veky on Sept. 2, 2015, 5:16 p.m.
Would it hurt to give some arguments for your claim?

fd2fd4ad on Sept. 14, 2015, 4:27 p.m.
What is complexity your algorithm?

veky on Sept. 24, 2015, 4:43 a.m.
Sorry for not replying earlier, I didn't notice this comment. As usual in Python, it depends on what exactly you consider elementary operations. But in the "usual" sense, let's say that input has N values of M bits each. Then the inner loop is O(N) virtual machine instructions for list comprehension, times O(N) since each .count is going through the list, times O(M) for equality comparison. (Counting and reference keeping in iterators are all a lot smaller than that.) So, the total complexity is `O(N*2M)` for input of size `O(N*M)`. That means if M is dominating, then the algorithm is linear, and if N is dominating, then it is quadratic. ;-) In the usual sense, worst-case complexity, of course it is quadratic. But please also look at <a href="http://www.checkio.org/mission/buildings-visibility/publications/veky/python-3/closure/share/c1ed9f3521299ca8cac37d5c1bdcda28/#">this comment</a> for a wider perspective.

leusgalvan on Sept. 23, 2015, 10:25 p.m.
Wow, you really squeezed this one!

mzhang on Oct. 6, 2015, 4:34 p.m.
nice

veky on Oct. 6, 2015, 4:41 p.m.
Thanks.

BigBadBeaver_ab042b61dcac47ae8 on Feb. 12, 2016, 12:40 p.m.
good

godmodecoder on Feb. 15, 2016, 10:39 a.m.
Nice one!

suic on March 16, 2016, 8:36 a.m.
Crystal clear.

veky on March 17, 2016, 11:11 a.m.
;-))

arjweb on April 10, 2016, 5:44 p.m.
Truely Pythonic :)

veky on April 11, 2016, 5:42 a.m.
Thanks. :-)

Bakachou on April 23, 2016, 1:20 a.m.
Nice use of lambda

1062316792 on May 3, 2016, 1:43 p.m.
cool

veky on May 3, 2016, 4:16 p.m.
Tnx.

koko.webdev on May 19, 2016, 2:53 p.m.
This was awesome!

veky on May 19, 2016, 3:24 p.m.
Thanks. :-)

gwu on June 6, 2016, 4:21 a.m.
good use of lambda!

veky on June 6, 2016, 5:14 a.m.
Finally. :-)

codebreaker_10 on June 9, 2016, 6:50 a.m.
Nice solution

veky on June 9, 2016, 7:46 a.m.
Thanks.

qholness on June 9, 2016, 9:42 p.m.
Neat! I wasn't aware of the Python list.count method.

veky on June 10, 2016, 5:18 a.m.
When you start solving, look at the editor box. <pre class='brush: python'>#Some hints #You can use list.count(element) method for counting. </pre> Seriously, you didn't see this? :-) Ah, kids these days... :-]

dhiaagr on Aug. 8, 2016, 5:11 p.m.
Hey dude. That was very smart [ :

veky on Aug. 9, 2016, 12:47 p.m.
Thanks. :-)

Lukasz.Dolata on Aug. 17, 2016, 6:17 a.m.
Really clear and fast solution

veky on Aug. 17, 2016, 6:05 p.m.
Not really fast, this is O(n^2). See <a href="https://checkio.org/mission/non-unique-elements/publications/veky/python-3/two-bins/?ordering=most_voted">this</a> for fast. ;-]

Arduinoid on Sept. 13, 2016, 1:38 p.m.
Wow, very nice indeed

vkartz on Sept. 26, 2016, 5:33 a.m.
nice work!!

veky on Sept. 26, 2016, 7:54 a.m.
Thanks. :-)

mzuluagag on Sept. 29, 2016, 6:48 p.m.
amazing

Heejong_Lee on Oct. 20, 2016, 6:26 a.m.
oh my god

veky on Oct. 20, 2016, 8:38 a.m.
What? :-)

edgarpo on Nov. 1, 2016, 1:49 p.m.
huyase

oduvan on Nov. 1, 2016, 1:52 p.m.
* he is excited.

veky on Nov. 1, 2016, 4:18 p.m.
If you say so... :-)

enakyn on Nov. 7, 2016, 8:22 a.m.
Awesome!

oduvan on Nov. 22, 2016, 8:47 p.m.
I gave you -2 just to get a cool number. I hope you don't mind

veky on Nov. 23, 2016, 5:10 a.m.
Of course I don't mind, but as you can see, it's very short-lived. :-D

Kinito on Dec. 2, 2016, 5 p.m.
Nice one

portamundos on Dec. 7, 2016, 11:56 a.m.
Awesome! How do you find such amazing solutions? How to train this?)

oduvan on Dec. 7, 2016, 12:01 p.m.
this is a good question :)

veky on Dec. 7, 2016, 5:42 p.m.
<a href="http://www.makeuseof.com/tag/10000-hour-rule-wrong-really-master-skill/">http://www.makeuseof.com/tag/10000-hour-rule-wrong-really-master-skill/</a> <ol> <li>Feedback loop: Check(iO)</li> <li>Deliberate practice: Check(iO)</li> <li>Become a teacher: Check(iO)</li> </ol> ;-)

oduvan on Dec. 7, 2016, 8:03 p.m.
this is a good answer :)

Igor_Karbachinsky on Jan. 12, 2017, 1:39 p.m.
N^2 complexity, boring

veky on Jan. 12, 2017, 2:12 p.m.
Of course. But I hope you've seen other solutions of mine for the same task. I'd say <a href="https://py.checkio.org/mission/non-unique-elements/publications/veky/python-3/two-bins/?ordering=most_voted&filtering=choice">Two bins</a> is not boring at all. ;-)

Oliviu27 on Jan. 12, 2017, 2:05 p.m.
smart, hope I get this good soon

veky on Jan. 12, 2017, 2:13 p.m.
Soon? :-) It took me about 5 years. :-D [That's if you count Python only... otherwise about 30 years.;]

oduvan on Jan. 12, 2017, 2:36 p.m.
Kids learn much faster now days especially with all those learning tools we didn't have 5-10 years ago :)

veky on Jan. 12, 2017, 2:47 p.m.
That's true, but the criteria for time have changed also. 20 years ago, "soon" was two months in the future. Now, it's ten minutes. :-D

Kinito on Jan. 20, 2017, 8:26 p.m.
wow

veky on Jan. 21, 2017, 6:11 a.m.
:-)

chimaumeh on Feb. 3, 2017, 8:52 p.m.
wow! That was the first thing i said :-)

veky on Feb. 4, 2017, 10:10 a.m.
You ain't seen nothing yet. :-)

Angel99999999999999 on Feb. 17, 2017, 9:08 p.m.
This code is pretty short.

veky on Feb. 19, 2017, 2:40 a.m.
The title says it. :-)

Jason_Zhou on March 10, 2017, 5:11 a.m.
I always learn something new everyday, thanks for the good work!

informativeguy on March 14, 2017, 2:15 p.m.
that was smart!

veky on March 14, 2017, 3:15 p.m.
As redditors are fond of saying, the username checks out. :-P :-D

LAyer_8 on March 27, 2017, 10:49 a.m.
This is so smart

hdh3296 on April 5, 2017, 5:30 a.m.
..

veky on April 5, 2017, 8:14 p.m.
..?

edmdemonz on April 9, 2017, 11 a.m.
well played!! excellent idea

mirtest99 on April 18, 2017, 7:06 p.m.
Ur a beast

veky on April 19, 2017, 5:08 p.m.
The smaller the code, the bigger the beast. :-D

ychbbq on May 5, 2017, 5:50 a.m.
this one is clear, knowledge gained.

Dai4979 on May 8, 2017, 11:23 a.m.
cool!

Fares_Al_Majbri on May 22, 2017, 1:34 p.m.
Nice work L!KE

abehad701 on June 4, 2017, 1:42 a.m.
nice!

cs1g on June 5, 2017, 4:43 p.m.
Thank you.

abehad701 on June 6, 2017, 12:09 a.m.
very nice

Andrey_Klymchuk on June 19, 2017, 8:52 p.m.
Great! Your solution encouraged me to learn lambda.

StefanPochmann on June 20, 2017, 9 a.m.
Can still be shortened: <pre class='brush: python'>checkio=lambda d:[x for x in d if~-d.count(x)] </pre>

veky on June 20, 2017, 3:46 p.m.
And it took you 3.5 years to see that? :-D Well... now is better than never, the Zen says. :-]

StefanPochmann on June 20, 2017, 9 p.m.
Hey... no... I've only been a member for ~2 years, so not longer than that :-). But I do find it surprising that nobody mentioned it until now. Nice new title, btw.

pongem on July 9, 2017, 4:26 p.m.
.. very short indeed ..

veky on July 9, 2017, 7:02 p.m.
... but not the shortest, as the above comment shows. :-)

AlexBuster on July 27, 2017, 10:10 p.m.
Hello. Could you please explain the syntax of this solution? I am watching at it and still can't get how does it works.

veky on July 28, 2017, 6:17 a.m.
list comprehensions and lambdas, syntax wolves. :-] Anyway, the solution is the same as <pre class='brush: python'>def checkio(d): result = [] for x in d: if d.count(x)>1: result.append(x) return result </pre> ... only written horizontally instead of vertically. :-] Any more questions?

PavloV on Aug. 31, 2017, 11:31 p.m.
Nice solution but I'm not sure it follows all the instructions (ex. Your code here, or replace this for solution). Following is a cut out from the original. <pre class='brush: python'>def checkio(data): #Your code here #It's main function. Don't remove this function #It's used for auto-testing and must return a result for check. #replace this for solution return data </pre> Though, I just started with CheckiO yesterday, and maybe it's OK to break some rules. Hope not only for those with many "yes"-followers. :)

veky on Sept. 8, 2017, 12:21 p.m.
"Instructions" are not really well-defined here. :-) What has some weight is the so-called "mission text" (including pre-conditions, output expectations, and such), although it is also changed from time to time. What you refer to above is usually called "solution template", and is not really intended to be preserved once you write a solution. It is mostly meant as a "pre-hint".

PavloV on Sept. 16, 2017, 1:32 p.m.
I’m ok with you referring to it as a “solution template”, though I disagree that it is less important than “mission text”, particularly in this case. Since this is one of the first missions, those who just started with CheckiO should follow all that is written, after-all they may not know if there are any “non-output” test scenarios their code is ran against, say for ranking purposes. You must agree that using lambda, in this case, alters a template (I do not refer to removing of the commented lines). I have nothing against lambda as such, accept for some applications where speed is critical, but in many solutions on CheckiO it’s absolutely fine. To be honest, I noticed that you very effectively used it in other mission answers but “solution template” wasn’t that picky there.

veky on Sept. 16, 2017, 5:01 p.m.
It seems you do not realize the historic context. :-) When I came here (years and years ago:), almost nothing of that was true. This wasn't "one of first missions", criteria for ranking was precisely specified, and I think (though I'm not sure for obvious reasons) that solution template wasn't there at all. Also, this solution has a thousand and a half likes, and an editor's star. Besides not actually being the shortest. :-D I think that whoever is deciding, is ok with it.

PavloV on Sept. 27, 2017, 11:22 a.m.
No no contrary, historic context editing was one of the first explanations I though of in trying to understand your answer acceptance, but then if missions (with whatever verbiage) could alter over time, it would undermine ranking efficiency. With every change, ranking backlog would have to be reset, or maybe some branching mechanism would have to be implemented. So, I'm not certain either if missions get edited even a bit once posted, would be unfair since could create certain "solutions detour". CheckiO's a nice project but ranking probably could be improved/diversified, and your previous post I believe supports it. Only from this discussion I see useful: tests driven ranking (not only by vote), grouping solutions by syntax/logic (not only description), mission time-line. Anyways, this is not a place for CheckiO suggestions. Veky, I appreciate you taking time to answer my posts, editors star given rightfully, unless you have a few assistants on your side ;) Probably it's not necessary to drill this conversation deeper.

veky on Sept. 28, 2017, 1:57 a.m.
Ah, so young and naive... :-) Yes, CiO ranking is simply broken. But there is no nice and simple fix, so we just adapt to it.

schroedingersbells on Sept. 3, 2017, 4:06 p.m.
Not sure why lambda use is getting the hate. It is included exactly for this kind of use. A single line function which calculates an expression and will be used once. Sure, if any of the above aspects were not satisfied, then def is better. Not here.

veky on Sept. 3, 2017, 4:26 p.m.
"Single line" is irrelevant, "an expression" is what matters. You can have expression over multiple lines, and a non-expression statement in a single line (e.g. assert). Lambda is hated because it's often misused, and even more often overused. Also, PEP8 can't stand it. But of course, that's irrelevant here. :-]

StefanPochmann on Sept. 3, 2017, 11:01 p.m.
Is there any expression that's more than one logical line? Too tired/lazy to search for it myself now...

veky on Sept. 4, 2017, 5:05 a.m.
Thanks to having a context-free grammar, that question is actually decidable. :-D All you have to do is check <a href="https://docs.python.org/3/reference/grammar.html,">https://docs.python.org/3/reference/grammar.html,</a> whether `NEWLINE` token is generated by `testlist` variable. :-D My very hasty depth-first eyeball search says that no, there is not. But of course, I was talking about physical lines. It seemed to me that @schroedingersbells's point was that such functions must be "oneliners" in the sense of shortness, which is really not necessary. Of course, when embedding them inside greater expressions, it looks weird if they have many lines, but if the outer expression has even more lines, it's not so bad. You just start thinking of `from future import braces as (, )` :-PP And the real point, that I really think most people don't realize, is that other direction does not hold. There are many very short one-line statements that can't be part of a lambda. `del a`, for instance. :-)

StefanPochmann on Sept. 9, 2017, 2:46 p.m.
<blockquote> There are many very short one-line statements that can’t be part of a lambda. `del a`, for instance. :-) </blockquote> Oh yeah? ``` <blockquote> <blockquote> <blockquote> a = 42 (lambda: exec('global a; del a'))() a Traceback (most recent call last): File "<pyshell#27>", line 1, in <module> a NameError: name 'a' is not defined ``` </blockquote> </blockquote> </blockquote>

veky on Sept. 10, 2017, 5:20 p.m.
Yeah. There is no del statements there inside lambda's code. exec is doing all the work. It's almost analogous to <pre class='brush: python'>>>> a = 42 >>> def f(): global a; del a >>> (lambda: f())() >>> a NameError </pre> Here, f takes the role of exec... only it's a bit more specialized:-), so it doesn't need any input. But you can easily construct it such that <pre class='brush: python'>f('please delete name a from global scope') </pre> does the above, while <pre class='brush: python'>f('please write "Hello world" on the screen') </pre> does something else. And you wouldn't call <pre class='brush: python'>'please delete name a from global scope' </pre> a del statement, would you? :-)

StefanPochmann on Sept. 10, 2017, 8:25 p.m.
That's different. You have it clearly outside of the lambda. I have it inside. And no self-made support for it outside whatsoever. I think I can legitimately call it a "part of" (that's how you phrased it) my lambda while you can't with yours.

veky on Sept. 10, 2017, 9:14 p.m.
I have it outside, yes. But you don't have it inside. What you have is a string that looks kinda like it, and signifies as a signal to exec to do a concrete action. I don't have Berlin if I have a map of it.

StefanPochmann on Sept. 3, 2017, 11:03 p.m.
<blockquote> It is included exactly for this kind of use </blockquote> Citation needed / I doubt it.

veky on Sept. 4, 2017, 5:19 a.m.
"exactly" is of course an exaggeration, since nothing is included in Python just to cover CheckiO's architectural ideas (except maybe lists:)), but it's not so far from intended lambda usage: a function where you need an expression. Naming it (and "function"ing it) is of course a CiO artifact.

StefanPochmann on Sept. 4, 2017, 9:03 a.m.
The "exactly" increases the claim, but I already disagree with the claim without it. The official Python reference introduces lambdas with: <a href="https://docs.python.org/3.6/reference/expressions.html#boolean-operations">"Lambda expressions (sometimes called lambda forms) are used to create anonymous functions."</a> The official Python tutorial introduces them with: <a href="https://docs.python.org/3/tutorial/controlflow.html">"Small anonymous functions can be created with the lambda keyword."</a> Guido himself wrote: <a href="http://python-history.blogspot.de/2009/04/origins-of-pythons-functional-features.html">"Lambda was really only intended to be a syntactic tool for defining anonymous functions."</a> And: "many people didn't like the fact that you [had] to define the operation that you were applying to the list elements as a completely separate function. Languages such as Lisp allowed functions to simply be defined "on-the-fly" when making the map function call." PEP 8 explains: <a href="https://www.python.org/dev/peps/pep-0008/">"the sole benefit a lambda expression can offer over an explicit def statement [is] that it can be embedded inside a larger expression"</a> Clearly the anonymity was and is a (the?) key point, along with the "on-the-fly"-ness and embedding. Claiming that lambda is included for such directly non-anonymous non-"on-the-fly" non-embedded use is simply wrong.

veky on Sept. 4, 2017, 11:41 a.m.
First part: interesting. With your careful quoting, it really appears so. :-P But in wider context, the expressionnness of lambda is always mentioned somewhere around. :-) And I really think that "having to think of a name" is much less pain than "having to escape from expression into a statement". Second part: as I said, the fact that it's non-anonymous and non-embedded (and it's not hard to imagine the situation for on-the-fly) is just an artifact of CiO's architecture. On many other similar sites, where tasks read input from stdin and write output to stdout, I almost never use lambda.

DubeySandeep on Sept. 15, 2017, 7:30 p.m.
Don't you think this runs in O(n^2).. this looks shorter but it's way bigger. isn't it?

veky on Sept. 16, 2017, 4:24 p.m.
Yes, this runs in O(n^2)... and it is short while being slow. It seems weird (at least to me:) to call slow code "big". :-)

ZenMittal on Sept. 20, 2017, 5:07 a.m.
For anyone who does not understand lambda <a href="https://www.programiz.com/python-programming/anonymous-function">https://www.programiz.com/python-programming/anonymous-function</a> A very concise and clear article.

veky on Sept. 20, 2017, 7:03 a.m.
... with a completely wrong focus. First it completely inverts the reason for naming. They being called "lambda expressions" (terms) long predates Python. Python used the `lambda` keyword precisely because those kinds of things were called lambda terms. Then it shows how lambda makes an unnamed function by naming it. LOL. (Yes, the naming is different, but the article never explains the difference between internal and external name.) (And of course you still don't need lambda for that function: it can be defined much more easily just by accessing `2 .rmul`.) Then it gives, as example of higher-order functions, the very ones (2-arg map and filter) where you shouldn't use lambda at all, comprehensions were added to the language for precisely that purpose. OMG.

ZenMittal on Sept. 21, 2017, 4:14 a.m.
I don't know, for me (who didn't know what lambda actually did), it was a nice and easy intro, maybe the fine subtleties can be understood later as I progress with the language.

veky on Sept. 21, 2017, 6:39 a.m.
If you just wanted to know what lambda actually did, <a href="https://py.checkio.org/mission/non-unique-elements/publications/veky/python-3/shortest/share/6e3291603834bb924b10feb1a3725be5/#comment-12224">this comment</a> would have been enough. :-)

Amy_Oliver on Aug. 6, 2019, 7:49 a.m.
Helpful

veky on Aug. 6, 2019, 7:49 a.m.
Glad

Teja_002 on March 15, 2021, 6:16 a.m.
Learned a new function today!. I Will try to use it in my programs from now on. Thanks a lot. Your solution is pretty impressive.

veky on March 15, 2021, 6:17 a.m.
Well, I guess noone reads help any more. :-]

_Chico__5d82cee4f5234e78a5c65e on April 24, 2021, 8:27 a.m.
Short clear!

_Chico__5d82cee4f5234e78a5c65e on May 15, 2021, 7:23 a.m.
First: this solution is loading like one hour until I can see the comments xD

_Chico__5d82cee4f5234e78a5c65e on May 15, 2021, 7:23 a.m.
Second: I need to follow you :)

veky on May 15, 2021, 7:25 a.m.
<blockquote> First: this solution is loading like one hour until I can see the comments xD </blockquote> It surely doesn't help if you add three comments to the poor page instead of one. :-PP <blockquote> Second: I need to follow you :) </blockquote> It won't help either. ;-D

_Chico__5d82cee4f5234e78a5c65e on May 15, 2021, 7:33 a.m.
Yes, yes and yes(Don’t ask me why I wrote 3 ‘yes’) =]

veky on May 15, 2021, 7:34 a.m.
I don't have to ask, I know. It's in anticipation to my next comment. ;-))

_Chico__5d82cee4f5234e78a5c65e on May 15, 2021, 7:38 a.m.
Yes =)

veky on May 15, 2021, 7:39 a.m.
Ok, now I'm confused. :-P

_Chico__5d82cee4f5234e78a5c65e on May 15, 2021, 7:41 a.m.
Yes, you should be confused ;D

veky on May 15, 2021, 7:43 a.m.
<a href="https://py.checkio.org/mission/i-love-python/publications/veky/python-3/magnum-opus/">It's only fair</a>. :-D

_Chico__5d82cee4f5234e78a5c65e on May 15, 2021, 7:47 a.m.
?,now I’M confused...;o

veky on May 15, 2021, 7:48 a.m.
... and the world is back to normal. ;-]]

_Chico__5d82cee4f5234e78a5c65e on May 15, 2021, 7:54 a.m.
;-o

_Chico__5d82cee4f5234e78a5c65e on May 15, 2021, 7:59 a.m.
Question: can you follow me, please? Then unfollow me , because then I would get 5 follower badge;)

veky on May 15, 2021, 7:59 a.m.
You don't deserve it. :-P

_Chico__5d82cee4f5234e78a5c65e on May 15, 2021, 8:01 a.m.
CoL...

_Chico__5d82cee4f5234e78a5c65e on June 14, 2021, 2:04 p.m.
Your brain is like about 1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 0000000000000000000000000000000000000000000000000000000000000000000000000 0000000000000000000000000000000000000000000000000000000000000000000000000 0000000000000000000000000000000000000000000000000000000000000000000000000 0000000000000000000000000000000000000000000000000000000000000000000000000 0000000000000000000000000000000000000000000000000000000000000000000000000 0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000000000000000000000000000000000 0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 times bigger than my... :-p :-)

henry10694 on Oct. 9, 2022, 5:29 a.m.
Brilliant!

veky on Oct. 13, 2022, 2:51 a.m.
Not really, but nice. :-)

goodenough2021 on July 17, 2023, 2:38 p.m.
good

veky on July 17, 2023, 5:32 p.m.
...enough? :-D

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!