- 60.0%

https://leetcode.com/problems/counting-bits/

Given a non negative integer number num. For every numbers i in the range 0 ≤ i ≤ num calculate the number of 1’s in their binary representation and return them as an array.

1 | Example: |

Follow up:

It is very easy to come up with a solution with run time O(n* sizeof(integer)). But can you do it in linear time O(n) /possibly in a single pass?

Space complexity should be O(n).

Can you do it like a boss? Do it without using any builtin function like __ builtin_popcount in c++ or in any other language.

Hint:

You should make use of what you have produced already.

Divide the numbers in ranges like [2-3], [4-7], [8-15] and so on. And try to generate new range from previous.

Or does the odd/even status of the number help you in calculating the number of 1s?

方法一：

i&(i-1) 是消除最小的一位1，取其个数，再加1。

考虑的是两段，最小的一位1，与这位1更新为0的数字，两段的个数的和。

1 | class Solution { |

方法二：

分两段求个数，一段是最后一位，一段是除最后一位的前一段。

1 | class Solution { |

#### cpp

https://discuss.leetcode.com/topic/40262/four-lines-c-time-o-n-space-o-n

Four lines, C++, time O(n), space O(n)

位运算 i&(i-1)可以出掉最低位的一位1.

i&(i-1) drops the lowest set bit. For example: i = 14, its binary representation is 1110, so i-1 is 1101, i&(i-1) = 1100, the number of “1” in its binary representation decrease one, so ret[i] = ret[i&(i-1)] + 1. (Sorry, my English is so poor and I have tried my best to make it clearly, I hope you can understand my explanation)

1 | class Solution { |

124ms, April.24th, 2016

1 | class Solution { |

#### python

https://discuss.leetcode.com/topic/45331/simple-python-solution

Simple Python Solution

Code works by constantly extending a list with itself but with the values incremented by 1.

Simple python solution that runs in O(n) time. Let me know if there are any ways to improve it.

1 | def countBits(self, num): |

A four liner that does the same thing as above. The above had a few redundancies.

1 | def countBits(self, num): |

#### java

https://discuss.leetcode.com/topic/40162/three-line-java-solution

An easy recurrence for this problem is f[i] = f[i / 2] + i % 2.

1 | public class Solution { |

1 | public class Solution { |

https://discuss.leetcode.com/topic/41785/simple-java-o-n-solution-using-two-pointers

Simple Java O(n) solution using two pointers

This uses the hint from the description about using ranges. Basically, the numbers in one range are equal to 1 plus all of the numbers in the ranges before it. If you write out the binary numbers, you can see that numbers 8-15 have the same pattern as 0-7 but with a 1 at the front.

My logic was to copy the previous values (starting at 0) until a power of 2 was hit (new range), at which point we just reset the t pointer back to 0 to begin the new range.

1 | public int[] countBits(int num) { |

**Question:**

Given a non negative integer number num. For every numbers i in the range 0 ≤ i ≤ num calculate the number of 1’s in their binary representation and return them as an array.

**Thinking:**

- We do not need check the input parameter, because the question has already mentioned that the number is non negative.
- How we do this? The first idea come up with is find the pattern or rules for the result. Therefore, we can get following pattern

**Index** : 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

**num** : 0 1 1 2 *1 2 2 3* *1 2 2 3* 2 3 3 4

Do you find the pattern?

Obviously, this is overlap sub problem, and we can come up the DP solution. For now, we need find the function to implement DP.

dp[0] = 0;

dp[1] = dp[0] + 1;

dp[2] = dp[0] + 1;

dp[3] = dp[1] +1;

dp[4] = dp[0] + 1;

dp[5] = dp[1] + 1;

dp[6] = dp[2] + 1;

dp[7] = dp[3] + 1;

dp[8] = dp[0] + 1;

…

This is the function we get, now we need find the other pattern for the function to get the general function. After we analyze the above function, we can get

dp[0] = 0;

dp[1] = dp[1-1] + 1;

dp[2] = dp[2-2] + 1;

dp[3] = dp[3-2] +1;

dp[4] = dp[4-4] + 1;

dp[5] = dp[5-4] + 1;

dp[6] = dp[6-4] + 1;

dp[7] = dp[7-4] + 1;

dp[8] = dp[8-8] + 1;

..

Obviously, we can find the pattern for above example, so now we get the general function

**dp[index] = dp[index - offset] + 1;**

**Coding:**

1 | public int[] countBits(int num) { |