In my opinion, when n=0, the answer should be null. But the test data is {0}. I think it needs a better explanation. Except for this, the problem is okay.
Why {0} for n=0?

Since we're supposed to return a list of integers, I'd say [0] is really the correct answer.
Think of bit strings instead of numbers. For n=2, the answer could be ["00", "01", "11", "10"]. For n=1, it's ["0", "1"]. And for n=0, it is [""]. Not [] or even "null". There is a bit string of length zero. The empty string.
Back to integers: What's the integer value of the empty bit string? For example for "101", the value is 1·2^{2}+0·2^{1}+1·2^{0}=5. Now if you do the same for the empty string, you get an empty sum, and the value of that is zero.

Typo at for
n=2
the second time.I disagree a little, I think the correct answer is
[]
. Consider this: write down elements of the 0bit Gray code immediately followed by the the elements of the 1bit Gray code, followed by the 2bit Gray code. I understand you would write""  "0" "1"  "00" "01" "11" "10"
, but with numbers would you really write0  0 1  00 01 11 10
or just 0 1  00 01 11 10
? (
for clarity only)If anything it would be
[null]
the first item in the list being:(Integer)null
, but I guess it was just coerced to0

Fixed the typo, thanks.
with numbers would you really write
0  0 1  00 01 11 10
or just 0 1  00 01 11 10
?I wouldn't write the first one, as it's an inconsistent mix of fixedlength and nonfixedlength representation. The second one at least is consistent, but I don't like it, either. Really I'd either write
""  "0" "1"  "00" "01" "11" "10"
or0  0 1  0 1 3 2
(or0  0 1  0 1 11 10
if I have a good reason to write in binary).What's your point with that, though? And why would it be null?

I don't know why I didn't realize this earlier, but... the problem statement says:
Given a nonnegative integer n representing the total number of bits in the code, print the sequence of gray code. A gray code sequence must begin with 0.
So
[]
can't be the answer, as it doesn't begin with 0.

Oh, that's right :) They could've just said positive
n
. There isn't much point is 0length code. Following Wikipedia's motivation example: it would be a wall with no switches.I said
null
in the list because if you write down0
you've written down one bit (which is "turned off"), which is not zero length;null
, i.e. "nothing" better approximates a zerolength number IMO.If we notice the pattern that an
n
bit code has2^n
codepoints2^0=1
. I guess we both agree that single codepoint is the empty number, the question is how do we represent it. With that sentence the problem writer coerced that emptyness to0
.0 can be confusing...

I guess we both agree that single codepoint is the empty number
No, I disagree. It's the empty code. And it represents the number zero.
It's odd that you have no problem with "too many" zeros (leading zeros) but can't accept "too few" zeros. If you can accept "00000" to represent 0, why can't you accept "" to represent 0 as well? What's your reason to accept "00000" for 0? How do you evaluate "00000" to 0? I suspect that if you're consistent and evaluate "" the same way, you'll get 0.
"nothing" better approximates a zerolength number IMO
Numbers don't have lengths. Only representations of numbers do.

No, I disagree. It's the empty code. And it represents the number zero.
Yep, that's what I meant, sorry, bad choice of words there.
Numbers don't have lengths. Only representations of numbers do.
Hmm, that sound right. And I guess this is where 0leftpadded numbers come in as well. My first and mostly only exposure to binary was when I was learning Architecture 101 at uni, which was the only course incorporating "bittwiddling, numeral systems and assembly". As you know CPUs always have limited space for numbers and it was easier to understand 7(dec) being 00000111(bin) on an 8bit architecture, less surprises if that's your mental model (also notice that you can't pad decimals consistently this way). I always write decimal numbers without padding (like everyday people) and nondecimals are usually padded (in IT, just think about
#0000FF
representing blue in CSS). It's inconsistent, but that's how it stuck. Thanks for making me notice the difference between number and representing a number."nothing" better approximates a zerolength number IMO
Based on the above you should see that in my mind on a 0bit architecture there wouldn't be space to store even a 0.
If you can accept "000", "00" to represent 0, why can't you accept ""
I guess it's too exceptional there, you can easily say "0001" = "001" = "01" = "1" = 1 (for anything
> 0
there always remains something (2^312 times on 32bits), but for 0 it's nothing (1 times, the exception).I hope you don't mind this quarrel about nothing (pun intended:
0
) It's nice to have someone to discuss these things with!

in my mind on a 0bit architecture there wouldn't be space to store even a 0
Only because you make an exception for it, an extra rule that a representation can't be empty. I think it needs zero bits, and a 0bit architecture has enough room for that :)
Thanks for making me notice the difference between number and representing a number.
Haha, nice, that's actually one of my goals in life. Make everybody aware that there's a difference. It seems most people are so used to decimal representation that they think the representations are the numbers. Well, usually it doesn't matter and of course I use decimal representation, too. But sometimes it does matter.
A nice example is 0.(9) and 1 being the same. The two representations aren't the same, but of course I only use representations in order to communicate. I'm really talking about the sameness of the represented numbers, and the two numbers are the same. But for people who never distinguish between representations and the represented numbers, I think this is a major reason why they have trouble with this example.
I hope you don't mind this quarrel about nothing
Not at all :). I have btw noticed you quite a lot lately and enjoy and agree with many of your posts here.

I really do think you would enjoy this Numberphile video about numbers a lot, or this one about
0
if you're more into math.

I think I've watched the first one before but I just watched it again and did enjoy it. At least until the end, when he says stuff like "I don't think [pi] is anything other than that endless sequence". Sequence? What sequence? Maybe "3.14159..."? That's not pi, that's a representation of pi. Grrr :)
I did watch the second one before, but might watch it again later as well. Anyway, thanks.