Hinted clear solution for Binary Count by veky - python coding challenges

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

Hinted solution in Clear category for Binary Count by veky

checkio=lambda n:bin(n).count('1')

Feb. 20, 2014

Comments:

odwl on March 2, 2014, 9:03 p.m.
I guess this one is unbeatable in simplicity.

veky on March 2, 2014, 9:33 p.m.
In a few days, expect oduvan here, saying this is "Puzzle" because of lambda. :-P

odwl on March 3, 2014, 7:08 a.m.
I do agree though that I prefer the equivalent def checkio(n): return bin(n).count('1') to the lamda version, but I guess this is just philosophy.

veky on March 3, 2014, 9 a.m.
Yes. To defend my view: def makes a full-fledged Python function, that does something -- possibly not only to its argument, but to the world. It has a name, scope, its own (slightly magical) __dict__, and even more magic when contained in a class. It can possibly get stuck in an infinite loop. It is aware of itself, and inserts itself in stack backtraces. It returns something (or not), when it wants to communicate some output to its caller. It has a possibility to generate and catch exceptions, either its own or of its children. And so on. lambda, on the other side, defines a mathematical mapping. It takes one (or possibly more) argument(s), and when called, "inserts" them in an expression at precise places, and evaluates that expression. That's it. Nothing of those complicated magical stuff is happening behind the table. In that sense, it is like an operator. "subtract 1" does nothing to the world. It even does nothing to its argument (it's immutable). It just maps 5 to 4. And -7 to -8. :-) To understand the way I feel when I see a def where there should be a lambda: see <a href="http://www.youtube.com/watch?v=o9pEzgHorH0.">http://www.youtube.com/watch?v=o9pEzgHorH0.</a> It talks about an analogous thing higher up, when people write a full fledged class when an ordinary function (or closure) would do. Of course it is possible to do it that way too, but Python is not Java. We shouldn't do everything in the most general possible way. :-] Try to answer to yourself, how do you feel when you see a class where there could be just a def (or a package where there could be just a module:). Then just scale it down an order of magnitude. It is smaller, but it is still wrong. :-)

maurice.makaay on Nov. 3, 2014, 3:57 p.m.
OK, I'm beginning to understand how you see a lambda. You see it like the most true form of functional programming within Python. I can work with that. Some statements that I have troubles with: def has a name: so does "checkio = lambda ..." def has a possibility to generate exceptions: so does "lambda x: {}[x]" def has a _dict_: secretly a lambda has one too lambda does nothing to its argument: well.. kind of, however: <pre class='brush: python'>a = lambda x: x.pop() x = [1,2,3] print("CALL:", a(x)) print("X:", x) </pre> def has a scope: so does lambda. It has its own parameter scope, plus its enclosing scope. <pre class='brush: python'>d = 2 b = lambda x: d * x print(b(3)) </pre> So lambdas are _a lot _like defs in my view. One thing is definitely true though: lambdas do protect against side-effects a lot more than defs do. This is inherent to the body of the lambda only being a value statement that acts as the return value. There is less chance that a coder is doing world-altering stuff in there.

veky on Nov. 4, 2014, 8:20 a.m.
 <blockquote> OK, I'm beginning to understand how you see a lambda. </blockquote> Oh, finally. :-D <blockquote> def has a name: so does "checkio = lambda ..." </blockquote> Hm, no. Analogy: person has a name. Cat doesn't have a name, but it can be given a name. It can have no name, or it can be given two different names by two different people, and it doesn't take one of them as its. Look: <pre class='brush: python'>def f(): pass g = f f.__name__, g.__name__ f = lambda: None g = f f.__name__, g.__name__ </pre> <blockquote> def has a possibility to generate exceptions: so does "lambda x: {}[x]" </blockquote> Well, no. It's dict.__getitem__ that generates the exception here. You can see it plainly in the traceback. lambda just serves as a medium through which it bubbles. I should have used the right word: raise instead of generate, perhaps. <blockquote> def has a dict: secretly a lambda has one too </blockquote> Here you are correct. But I would argue this is just an implementation detail: since lambdas are implemented as a "scaled down functions", they have same __dict__s functions do. But if anyone implemented lambdas from scratch, I doubt they'd give them a __dict__. Each lambda having it's own attributes in my head makes as much sense as each int having them. :-) Also, functions' __dict__ is slightly magical: for example, value for key '__doc__' is set from inside the function code (when the object doesn't really exist yet), and that in a very peculiar (though completely practical:) way. <blockquote> lambda does nothing to its argument: well.. kind of, however: </blockquote> Same as with exceptions: list.pop does something to lambda's argument. lambda just delegates. But yes, here we have a grey zone (though much less so than in other imperative languages, since Python usually sticks with "either change argument and return None, or return copy of argument, changed". Of course, things like list.pop and dict.setdefault aren't conforming to that.) <blockquote> def has a scope: so does lambda. It has its own parameter scope, plus its enclosing scope. </blockquote> Yes, I was imprecise again (but you must forgive me, I have written this or similar comment about 10 times on CiO already - every time someone pesters me about my lambdas;). I meant to say a function has control over its scope (and relation with outer scopes). def can rebind names (permanently), lambda cannot. There is a strong reason why global, nonlocal, = and del are statements, and as such outside of lambda's reach.

maurice.makaay on Nov. 4, 2014, 9:14 a.m.
One extra thing I forgot to mention about lambdas (not to pester you about lambdas, just to pester you in general ;-), is that they are pushed in the stack. <pre class='brush: python'>a = lambda x: {}[x] a(1) </pre> Gives: <pre class='brush: python'>Traceback (most recent call last): File "lambda_stack.py", line 2, in <module> a(1) File "lambda_stack.py", line 1, in <lambda> a = lambda x: {}[x] KeyError: 1 </pre> A lambda is not fully protected against accessing globals. Instead of global x, one can always use globals()["x"]. Of course, we should throw people that do this off a cliff. The name analogy is a bit crooked (as a person, I was given a name too and as such it is just a reference to me), but you're right that there is a slight difference in owning a name (as def does) or not (as lambda does). I should have talked about identifier instead of name. <pre class='brush: python'>def a(): return 1 assert a.__name__ == "a" b = a assert b.__name__ == "a" </pre>

veky on Nov. 4, 2014, 9:27 a.m.
First, same as with scope. Yes, evaluating a lambda generates a stack frame, but lambda doesn't have control over it in the same way function does. It mostly concerns exceptions, but not only. Second, you can use globals()["x"], but you still cannot rebind it this way. Yes, you can use globals().__setitem__, but about this see below. :-] About throwing people off a cliff: in principle I agree with you, though I wouldn't be so drastic. :-D Yes, Python always seeks balance between practicality and purity, and often practicality wins, as the Zen says. But we can agree that this is not Pythonic ideal of lambda use. It's, in most cases, something that's accidentally possible. Name analogy is not as crooked as it seems: function's name is also given to it by the Python system. The point is, Python system is formalized and all-encompassing in that context (just as society is), so we can rely on the fact that every function has a well-defined name. The fact that we can rely on it makes bureaucracy much simpler, just as with persons in real life.

maurice.makaay on Nov. 4, 2014, 11:48 a.m.
I've got a really bureaucratic vet, who turned my cat into a walking RFID tag and linked its id to its given name. I am really tempted now to call my next cat "Lambda" now. Goes well with the dog called "Widget" :)

veky on Nov. 4, 2014, 12:44 p.m.
Until you start calling them <pre class='brush: python'>lambda'); DROP TABLE cats; -- </pre> I guess you're ok. :-D

aotus on March 5, 2014, 6:32 p.m.
I often find myself "upgrading" a function to a class when my function requires many arguments -- all of which I MIGHT want to change -- but only a few of which I will change FREQUENTLY. An example: linear transformations. I have a series of x,y points in one coordinate system. I want to scale and offset those points to display them in any of several other linear coordinate systems. To establish the scale and offset values, I start by supplying two representative points in each coordinate system -- four values in all. Then, for each point I want to transform, I supply two more values. I could write a function which takes six arguments every time. In order to improve readability (and, in some cases, also execution speed), I defined a Transformer class. I construct each Transformer instance using the reference points. Then, for each point I want to convert, I supply the point as an argument to Transformer.call(). (NOTE: above, call() is supposed to be preceded and followed by double underscores -- but this web site automatically formats that as bold text! For shame, this is a PYTHON web site!!!!)

veky on March 5, 2014, 6:41 p.m.
As far as I can see, you agree with me, so I won't comment on that. :-) Only this: <blockquote> (NOTE: above, call() is supposed to be preceded and followed by double underscores -- but this web site automatically formats that as bold text! For shame, this is a PYTHON web site!!!!) </blockquote> Of course, but that doesn't mean comments are written in Python (only I do so sometimes in interviews:)). If you want to embed python in prose, use \ (a backslash) to escape a formatting character.

veky on Jan. 28, 2015, 6:20 a.m.
In the meantime, we have got a better way to inline Python code: Use \` quotes. Example: `lambda x:(x//2,3*x+1)[x%2]` is a Collatz function.

Flid on July 25, 2014, 3:15 p.m.
Good solution, but with needless use of lambda and some PEP8 errors.

veky on July 25, 2014, 3:43 p.m.
Errors? Hm. :-)

Flid on July 25, 2014, 6:28 p.m.
<a href="http://pep8.readthedocs.org/en/latest/intro.html">http://pep8.readthedocs.org/en/latest/intro.html</a>#error-codes Missing spaces around "=" and after ":". Code readability matters!

DiracRules on July 26, 2014, 11:06 a.m.
I agree with code readability, but... one cannot simply ask veky to write readable code XD

veky on July 26, 2014, 12:24 p.m.
Sorry, this is just nonsense. What exactly do you find unreadable in the above? It is one line. Less than 20 tokens. It's a function made by composing a builtin and a method on str with a literal argument. It can't be simpler in any possible way. Language that had one builtin function for this purpose would be so complicated I wouldn't want to write (and you wouldn't want to read) it. Are you really, seriously, telling me that you somehow found it unreadable because i didn't write these 3 spaces? And try to answer this: if there were no PEP8 document, would you still find it unreadable?

DiracRules on July 28, 2014, 4:10 p.m.
nono, it was just a silly joke, I understand perfectly what you did here... But I found other solutions quite cryptical.. Mine was just a consideration on the fact that sometimes elegant code are little readable or written in unorthodox ways :D

veky on July 29, 2014, 10:30 a.m.
Ok, but comments like yours perpetuate the myth that "Veky's code must be unreadable by definition", that has started to hurt other people much more than me (you practically cannot hurt my reputation here anymore:). The problem is that people see something in my code, and automatically start viewing that as some heavy wizardry. For example, many people have started considering lambdas in general as unreadable, and I can't help but think it's at least in part because I use them in weird ways sometimes. :-) That disables them to see some really elegant ways of writing code, just because they perceive certain constructs to be "off limits".

veky on Sept. 15, 2016, 3:58 a.m.
... and again somebody has been feeling very smart sprinkling minuses all over my comments. What do you intend to accomplish? I have too many points here already. :-] But if you disagree with anything I said above, say so and we'll discuss it. We'll probably both learn something in the process. It will be constructive. Try it.

veky on July 25, 2014, 10:19 p.m.
LOL. I really can't say anything more. I just hope one day you'll realize what you just said. :-)

Czarinov on Aug. 1, 2015, 2:13 p.m.
<blockquote> Code readability matters! </blockquote> Sorry, one really couldn't care less about a fit that some little girl threw about formatting... By little girl I mean the webpage you've posted and, well, you too I guess. Adding spaces here would just mean more needless typing and zero use.

veky on Aug. 1, 2015, 11:51 p.m.
I think it's a bit too harsh (first paragraph, second is spot on). Flid probably really thought they were doing me a favor by pointing me to a document whose all three popular versions I know by heart. :-)

Czarinov on Aug. 2, 2015, 8:35 a.m.
<blockquote> I think it’s a bit too harsh </blockquote> Maybe. I'm just baffled by people trying to find a flaw in something so simple as this particular one-liner. Flaw in things that Python doesn't even care about.

veky on Aug. 2, 2015, 4:30 p.m.
There is a section about that phenomenon in that same document: Foolish consistency. ;-)

vshulkin on April 14, 2015, 3:19 a.m.
it wouldn't count '0's if needed.

veky on April 14, 2015, 6:37 a.m.
It would, it would just count one more. :-D [The number of 0's is not really well-defined in the usual sense, every natural number has infinitely many zeros in its binary notation.:] If you want to avoid that, you can use `format(n, "b")`. Here I just wanted to golf.

gnucian on June 21, 2015, 5:57 a.m.
The catch is bin() returns a string, not a number. Got it.

veky on June 21, 2015, 7:22 a.m.
Of course it returns a string. I don't understand "catch" - what else could it return? If it returned a number, it would be a really boring function: bin(5) would be a number five, of course. It surely wouldn't be a hundred and one. (Mthematically, it might return a tuple of digits, if a digit (bit in this case) were a separate type. But since Python doesn't even have 'character' as a type, it would be silly to have a digit as a type. Of course, Python might solve it in the same way as with str - characters are just len1 strs, digits are just singledigit ints - but since bases are fixed to just 2, 8 and 16, digits have natural representation as characters.)

PavloTaiko on July 15, 2015, 9 a.m.
yeah count, nice

n16bs on July 20, 2015, 8 a.m.
Identical to my answer, great minds think alike aye?

veky on July 20, 2015, 12:23 p.m.
Law of small numbers, I'd say. :-)

n16bs on July 20, 2015, 12:50 p.m.
Haha just being cheeky man :p

veky on July 20, 2015, 1:35 p.m.
Me too. :-)

M157q on Nov. 5, 2015, 3:02 p.m.
same as mine!

veky on Nov. 6, 2015, 4:31 a.m.
Yey. :-D

RonaldSwanson52 on Dec. 10, 2015, 4:27 p.m.
Simple,elegant and quite clever. You get two thumbs up.

veky on Dec. 10, 2015, 9:12 p.m.
Thanks. :-)

RonaldSwanson52 on Dec. 11, 2015, 11:34 a.m.
I especially liked the clarity. I've only been in python for a few months and I easily followed your code. It was far superior to my solution. You published "hinted" on Feb 20,2014 and I haven't got a clue how it works. If you have any reference that might help it would be appreciated.

veky on Dec. 11, 2015, 11:49 a.m.
Weird... you say you like the clarity, and you easily follow my code, yet you haven't got a clue how it works. I don't understand how that's possible. :-/ (If you're sarcastic, you'll have to be less subtle.:) "Hinted" means the solution was done using the hints in the task text. Look: <blockquote> You should convert it to the binary format and count how many unities (1) are ... </blockquote> See `help(bin)`, `bin(5)` and `help(bin(5).count)` for details.

RonaldSwanson52 on Dec. 12, 2015, 7:13 a.m.
I'm sorry I was unclear. I was referring to another of your programs when I said I had no clue. The one I said was clever was very easy to follow and that was part of its beauty. After checking how you used the int wrapper I understood the other program also so I actually deleted the "no clue" message but somehow it still went through. I now understand both programs and am impressed with your talent. You have given me some great ideas on how I can clean up my own programs.

veky on Dec. 12, 2015, 11:58 a.m.
Ah, ok. It's usual that comments to a solution refer to that solution, not to some other one. :-)

leije01 on Jan. 24, 2016, 3:49 a.m.
nice one, so much simpler than what i concocted... sum(map(lambda x: int(str(bin(number))[x]), range(2,len(str(bin(number))))))

veky on Jan. 24, 2016, 7:13 a.m.
Argh. This has a record number of Python antipatterns in one line: <ul> <li>WET (write everything twice) syndrom with str(bin(number))</li> <li>redundant "conversions" (bin is already a str)</li> <li>mapping lambdas (Pythonic is to use a genexp)</li> <li>iterating through range instead of object itself</li> </ul> The exact same thing you've written could be written much more Pythonically as <pre class='brush: python'>sum(map(int, bin(number)[2:])) </pre> Or, even better to use the right tool for the job (`bin` is a helper visualization for beginners, `format` is for programmatic access), <pre class='brush: python'>sum(map(int, format(number, 'b'))) </pre>

leije01 on Jan. 25, 2016, 2:07 a.m.
Thanks, Veky! Clearly I have much to learn yet. I appreciate your critique.

najikadri on Feb. 4, 2016, 5:09 p.m.
Why you always use lambda for most of your codes? What benefits it has over any other functions?

veky on Feb. 5, 2016, 5:10 a.m.
`lambda` is not a function, it is a way of constructing functions (like `def` is, for example). But `def` constructs functions as statements, while `lambda` constructs them as expressions. Python has a fine distinction between expressions and statements, I'm using that here. Of course, you can write any expression as a statement, just `return expression`, but that's redundant. Note that in most of real-life code, you wouldn't use lambdas, you'd just write expressions themselves. <pre class='brush: python'>... n = whatever way to get a number bincount = bin(n).count('1') ... do whatever you want with bincount (e.g. print it) </pre> But since CiO wants a function, I construct a function. And `lambda` is the most natural way to do it when all you need is just an expression. Of course, there are many people who abuse `lambda`, writing (what would naturally be) statements as expressions (using many tricks). I like to think I'm not one of them. At least most of the time, I only use `lambda` when the most natural statement of a `def` function would just be `return expression`. In many such situations, a function is an overkill, but that's just CiO's way of interacting with your program.

ljy95135 on May 25, 2016, 7:43 a.m.
lambda constructs a function and give to checkio, it's quite concise.

veky on May 25, 2016, 10:04 a.m.
Imagine if the system was different. Imagine the task says: you have an integer named n. Write a statement that counts the number of ones in its binary representation, and names it checkio. I'd write <pre class='brush: python'>checkio = bin(n).count('1') </pre> and I'm sure nobody would say it's confusing. Or, if the system was "read an int from stdin, and print its number of ones in binary", I'd write <pre class='brush: python'>print(bin(int(input())).count('1')) </pre> and though in this case there would be people saying I do too much in one line, I'm quite sure noone would say the code is "creative". Referencing n and naming the result, or reading input and printing output, or defining a function and returning a value, is just an accidental complexity of CheckiO (or some other) system. It has nothing to do with the task itself. And I like to keep it to a minimum - because it doesn't really matter. It's just a boilerplate, existing only because CiO expects some universal interface for its task.

DahliaSR on June 13, 2016, 7:01 p.m.
Yeah, I expected your solution exactly to be like this. And it's same as mine.

veky on June 13, 2016, 7:36 p.m.
Not really surprising, I'd say. :-)

dannystaple on Nov. 3, 2016, 9:29 a.m.
I like this - short and sweet. Ah - and simply counting the ones means no need to chop off the "0b".

Brandon_Carlino on Nov. 6, 2016, 1:35 a.m.
I've been studying programming for about 3 months now and have yet to feel comfortable enough with lambda to even consider using it in my solutions... meaning my thought process doesn't even acknowledge it yet.

veky on Nov. 6, 2016, 8:50 a.m.
HTH: <pre class='brush: python'>name = lambda args: whatever <~~~> def name(args): return whatever </pre>

Paul-Yuchao-Dong on Nov. 22, 2016, 6:53 a.m.
While astonished by the solution's simplicity I would humbly propose to change it to below: ``` checkio=lambda n:bin(n)[2:].count('1') ``` reason being, it is more obvious that we are doing a string operation, and maybe more future proof? I cannot imagine what ppl would put in the first 2 char in the future, maybe a '1'?

veky on Nov. 22, 2016, 8:56 a.m.
Ok, you raise two points. Both are wrong, but for a different reason. <ol> <li>How could slicing make it more obvious that we are doing a string operation? Any standard container sliced gives an object of its own type. Lists sliced are lists, tuples sliced are tuples. Nothing in "[2:]" says "str" in any way.</li> <li>Futureproofing is nice (when applicable), but this is wrong way to do it. Why do you think the header will always be 2 chars? It seems to me that it's much more probable that it will get longer (0binary1011), not replaced by something else of the same length.</li> </ol> Fortunately, we can address both your concerns in the right way to do it: <pre class='brush: python'>checkio = lambda n: format(n, 'b').count('1') </pre> Here it is obvious that format gives a string, and normal 'b' formatting gives just the value without a header.

Paul-Yuchao-Dong on Nov. 22, 2016, 9:18 a.m.
I concur! I think the format way is much clearer and better. Thanks!

stonegz on Nov. 1, 2019, 6:41 a.m.
really neat

piter239 on April 23, 2020, 1:05 p.m.
I'm really glad I came up with this solution as well (without the lambda part))

veky on April 23, 2020, 1:27 p.m.
As I said, it was hinted.

GitHub

0 %

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