Bitwise Operation on 跟著 Desolve 學程式

從LeetCode學演算法 - 87 Bitwise Operation (6)

Tue, 11 Feb 2020 00:00:00 +0800

1342. Number of Steps to Reduce a Number to Zero (Easy)

Question

Given a non-negative integer num, return the number of steps to reduce it to zero. If the current number is even, you have to divide it by 2, otherwise, you have to subtract 1 from it.

Example 1

1
2
3
4
5
6
7
8
9


Input: num = 14
Output: 6
Explanation:
Step 1) 14 is even; divide by 2 and obtain 7.
Step 2) 7 is odd; subtract 1 and obtain 6.
Step 3) 6 is even; divide by 2 and obtain 3.
Step 4) 3 is odd; subtract 1 and obtain 2.
Step 5) 2 is even; divide by 2 and obtain 1.
Step 6) 1 is odd; subtract 1 and obtain 0.

Example 2

1
2
3
4
5
6
7


Input: num = 8
Output: 4
Explanation:
Step 1) 8 is even; divide by 2 and obtain 4.
Step 2) 4 is even; divide by 2 and obtain 2.
Step 3) 2 is even; divide by 2 and obtain 1.
Step 4) 1 is odd; subtract 1 and obtain 0.

Example 3

1
2


Input: num = 123
Output: 12

Constraints

0 <= num <= 10^6

分析/解題

給定一個數字num，回傳其化簡至0所用的步驟數。
化簡的方法為：
若num此刻為偶數，將其除以2；若num此刻為奇數，將其減去1。

這題如果按照題目的條件一步一步走的話，
以二進位制來看，
我們會發現當尾端的bit是1時，就必須減去1並除以2 ，
也就是向右位移一個bit(這整件事情耗費了2步 )；
若bit是0時，則只需要除以2即可。

所以一個很簡單且直觀的寫法，就是利用迴圈，
當num還大於0時，檢查尾數的bit(可以用num & 1取得尾數是0或1)，
你可以用三元運算子 ，或者直接**(num & 1) + 1** 亦可，
請注意由於**&運算子的優先序較低** ，務必將num和1用括號包起來！
一路做到最後一個1，最後num等於0時就完成了。
(因為最後一個1不用再位移了，所以我們加總起來的步數最後要減去1)

這裡提供另一個想法：
當我們沒有限制計算bitCount的函式及轉換二進位/字串時，
可以推想到：

所有1都必須被消成0 (每個bit ‘1’會耗費1步)
要除以幾次2，端看最高位的1離個位數有多遠
(轉成二進位的總長減去1等於總共要除以2的次數)

所以我們得到： 答案 = num的bit ‘1’數量 + num的長度 - 1

依此，寫成程式碼如下：

Java

Java的部分，我們可以利用bitCount和toBinaryString來達到要求。
(一步一步算的也有列出參考解，讀者可以自己試看看)

Python

Python的部分，由於bin()轉二進位時，前面會多出**’0b’** ，
所以計算長度時會多出2，後面的減1就會變成需要改成減3 ，
請再留意。其他跟Java大同小異。

面試實際可能會遇到的問題

「時間/空間複雜度？」
(O(logN)/O(1)，但因為num最高就是10^6而已，如果你要宣稱num是constant，因此時間複雜度當成O(1)，個人覺得也是合理的。)

相似及延伸

Special Thanks suggestions/corrections from viewers:

From Cheng Rui Xie :
位元運算有很多有趣的 function 可以呼叫：
回傳以二為底的次方項：__lg(num)
回傳數字二進位後1的個數：__builtin_popcount(num)
只要取兩個的和即可且運算的時間＝O(1)
(這個想法的O(1)也是將num當限定大小看待。)

(歡迎提供意見協助更正歐~)

從LeetCode學演算法，我們下次見囉，掰~

感謝大家對這系列文章的支持！這邊跟大家自我工商一下：

筆者開設的系列同名線上課程：
「從Leetcode學演算法｜基礎篇」已經上線啦！ 在這堂課中，你將學會利用十種演算法/資料結構來優化解題過程，
並實際完整練習20題 精選考古題，
進而逐漸提升到不需提示也可以突破白板題，取得工作門票！
Medium優惠(最後一波早鳥優惠了，不確定調回原價是什麼時候)： ** https://hiskio.com/courses/319?promo_code=VE9Q5VE**

從LeetCode學演算法 - 68 Bitwise Operation (5)

Mon, 11 Nov 2019 00:00:00 +0800

0201. Bitwise AND of Numbers Range (Medium)

Question

Given a range [m, n] where 0 <= m <= n <= 2147483647, return the bitwise AND of all numbers in this range, inclusive.

Example 1

1
2


Input: [5,7]
Output: 4

Example 2

1
2


Input: [0,1]
Output: 0

分析/解題

給定一個範圍m, n，且0≤m≤n≤2147483647(也就是2³¹-1)，
回傳這個範圍內(inclusive，即含n)的所有數字的bitwise AND的結果。

首先這題要先理解inclusive表示頭跟尾都要 ，
例如[5, 7]，其範圍內的所有數字就是5, 6, 7。
再者如前面提到過的bitwise operation的部份，
這邊做的是對每個bit一一對應做AND的操作。

我們先來看一下範例1，將其化成二進位：

1
2
3
4


5 : 101
6 : 110
7 : 111
AND : 100 => Output: 4

注意到由於AND操作要求兩個bit都是1結果才是1 ，
所以中間一旦出現任意一個0的話，當個bit的AND結果最終必然是0 。
由於

已經知道m≤n了，假設m跟n前面存在一組位元長得一模一樣，
例如：

1
2


m: 100100101000 (2344)
n: 100100111111 (2367)

可以明顯看出從m到n的部份，1001001 的位元是完全不變的，
AND出來這部分顯然也會保留 ，因為每個數字的這部份都一樣。

那麼後面呢？
由於m ≤ n，
所以在後面不相同的狀況下，開始不相同的m的第一個bit顯然會是0 ，
n的第一個bit顯然會是1 ，那麼從m一路到n的bit變化，
就必然有從011…1到100…0 的情況，
所以後面的所有bit皆至少有出現過一次0 ，
這會使得後面的區塊經過AND完以後肯定是0 。

所以整個問題就可以化簡成：
找到m和n的最前面相同的bit，再將後面補上0即為答案 。

要找這個很簡單，每次檢查m, n是否相等，若否，
則各自向右移動一個bit，最終到** m, n相等時，
只要乘上對應的位移倍數，即為解答。
讀者可以自行選用將factor視為位移位數** 或必須相乘的倍數 ，
兩者速度基本相似。

除此之外還有另一個思路，既然我們只是想要n的前面那區bits，
那就一次從n剝離一個bit
( n &= n-1 , 先前的題目有提到可以用來一次去除最低位的bit)，
直到n≤m為止。這時候留下來的n即為答案，因為低位的全被剝離了。

依此，寫成程式碼。
(三者速度差異不大，但最後一種看起來最簡單，讀者可以自行斟酌選擇)

Java

Python

面試實際可能會遇到的問題

「時間/空間複雜度？」
(O(n的長度)/O(1)，
因為要做到哪一步端看什麼時候找到m和n前面相同的位置)

相似及延伸

Special Thanks suggestions/corrections from viewers:
(歡迎提供意見協助更正歐~)

從LeetCode學演算法，我們下次見囉，掰~

從LeetCode學演算法 - 67 Bitwise Operation (4)

Tue, 05 Nov 2019 00:00:00 +0800

0191. Number of 1 Bits (Easy)

Question

Write a function that takes an unsigned integer and return the number of ‘1’ bits it has (also known as the Hamming weight).

Example 1

1
2
3


Input: 00000000000000000000000000001011
Output: 3
Explanation: The input binary string 00000000000000000000000000001011 has a total of three '1' bits.

Example 2

1
2
3


Input: 00000000000000000000000010000000
Output: 1
Explanation: The input binary string 00000000000000000000000010000000 has a total of one '1' bit.

Example 3

1
2
3


Input: 11111111111111111111111111111101
Output: 31
Explanation: The input binary string 11111111111111111111111111111101 has a total of thirty one '1' bits.

Note:

Note that in some languages such as Java, there is no unsigned integer type. In this case, the input will be given as signed integer type and should not affect your implementation, as the internal binary representation of the integer is the same whether it is signed or unsigned.
In Java, the compiler represents the signed integers using 2’s complement notation. Therefore, in Example 3 above the input represents the signed integer -3.

分析/解題

給定一個unsigned integer(正整數或0)，試回傳其位元為1的個數。

這題其實比上一題還要再簡單一點XD
假設我們將數字稱為n，要計算其位元為1的個數的方式一般有兩個：

看當前的位數是否為1 來決定是否遞增記錄累積的cnt(count)，
再將n向右位移1位，直到做完全部32個位元。
將n每次和n-1相AND，可以去掉最低次的位元。
舉例來說：
n=11100 => 11100 & 11011 = 11000
(減1時最低位的1會被借位，導致該位變成0，
其後的位數變成1，從而在相AND時全都會變成0)
n=10011 => 10011 & 10010 = 10010
(最低位的1一開始就在最右邊，顯然減完最右邊變成0，
同樣會符合去掉最低次的位元的特性)

Java

Python的部份，也可以轉成二進位以後再用count去數'1’。
(不需要考慮前面的0b因為沒差XD)

Python

面試實際可能會遇到的問題

「時間/空間複雜度？」
(O(1)/O(1)，因最多32次迴圈就結束了XD)

相似及延伸

Special Thanks suggestions/corrections from viewers: 這題其實一樣可以有更精妙的解法，但同樣不建議在面試時使用。
(除非你要面試的就是非常在乎效能加速的公司)請參見JDK所使用的Integer.bitCount() 函式原始碼講解：
https://juejin.im/post/5c3969b76fb9a049a5712060

(歡迎提供意見協助更正歐~)

從LeetCode學演算法，我們下次見囉，掰~

從LeetCode學演算法 - 66 Bitwise Operation (3)

Sat, 02 Nov 2019 00:00:00 +0800

0190. Reverse Bits (Easy)

Question

Reverse bits of a given 32 bits unsigned integer.

Example 1

1
2
3


Input: 00000010100101000001111010011100
Output: 00111001011110000010100101000000
Explanation: The input binary string 00000010100101000001111010011100 represents the unsigned integer 43261596, so return 964176192 which its binary representation is 00111001011110000010100101000000.

Example 2

1
2
3


Input: 11111111111111111111111111111101
Output: 10111111111111111111111111111111
Explanation: The input binary string 11111111111111111111111111111101 represents the unsigned integer 4294967293, so return 3221225471 which its binary representation is 10111111111111111111111111111111.

Note:

Note that in some languages such as Java, there is no unsigned integer type. In this case, both input and output will be given as signed integer type and should not affect your implementation, as the internal binary representation of the integer is the same whether it is signed or unsigned.
In Java, the compiler represents the signed integers using 2’s complement notation. Therefore, in Example 2 above the input represents the signed integer -3 and the output represents the signed integer -1073741825.

分析/解題

題目要求將一個32bit長度的integer進行反轉。
(也就是將二進位制的各個bit 0變成1，1變成0)

先前我們談過二進位的問題，以及一些位元運算 。
如果這題有要求處理正負號的問題的話，就會稍微複雜一點，
因為如題目提示的說明，Java中的有號的integer會使用**二補數
(2’s complement)**來表示，這件事情隱含了如果將bit位移時，
需要考慮是»或»>的問題。
負數使用»時最高位會補1，而»>時最高位會補0 ，
由於最高位用來記錄正負號，這會影響到實際得到的結果。

但我們這邊單純只是要將整個32 bit順序反過來的話就沒有太大問題XD

我們先從簡單一點的開始，
比如有一個數字n是1001100(也就是十進制的76)，
假設我們要將這7個bit反轉，應該要得到0011001，這個過程怎麼來的呢？

先將我們的答案叫做r(result)，一開始為0，我們先這樣表示：

1
2


r:
n: 1001100

接下來我們要找下一個對應的bit的話，
n必須要取最右邊的bit才行，記錄完以後，
為了讓下一次的n的最右邊依然是我們要的bit，
可以將n進行一次向右位移，即可對到最右邊。
另外，r為了要記錄下一個位元，每次要向左位移一格，空出最右邊來。

重複相同的操作，直到n等於0或全部位元操作完畢即可。

1
2


r: -> 0 -> 00 -> 001 -> 0011 -> 00110 -> 0011001
n:1001100 -> 100110 -> 10011 -> 1001 -> 100 -> 10 -> 1 -> 0

觀察上面的規律，我們可以歸納出對32位元的操作：
1. 令res為0
2. 執行32次以下的迴圈：
2–1. res向左位移1位
2–2. 將n的最右邊的bit加到res上
2–3. 將n向右位移1位
3. 最終res即為答案

依此，可以寫成如下的程式碼：
Java的部分，我們使用«=和»=進行各自位移後再回存。
而對應到2-2的部分，除了如第8行的寫法，
將n和1進行AND運算 來確認最右邊的位元 以外，
也可以用AND完以後跟res進行OR 的方法。
此外，由於最開始res是0，
所以先將其往左位移一次是不會對答案造成影響的。

Java

Python的部分提供一個看到比較特別的寫法：
使用format將n進行轉換，
當中0:032b的第一個0可以不用寫 (因為format中也只有一個數字)，
第二個0代表多出來的部份必須進行補0 (補完反轉才不會有問題)，
轉成32位的bit後，將其從尾往頭擺順序，
再用int轉換回integer(指定前面那段是二進制)即可。

Python

面試實際可能會遇到的問題

「時間/空間複雜度？」
(O(N)/O(N)，因為必然經過每個位元)

「如果檢查n是否為0做為結束條件，執行速度是否會較快？」
(不一定，要看n反轉後的最接近高位的0有多接近，
否則每次多檢查一次未必比較快)

相似及延伸

Special Thanks suggestions/corrections from viewers:
From ** 程式人雜誌 — 公益出版** ** - Novus Chou**:
「現實中比較講究的位元操作，會盡可能一次處理多位元，
而且最好不動用迴圈。

以 8 bit 為例

12345678
=> 21 436587 (奇偶交換)
=> 4321 8765 (兩兩一組交換)
=> 87654321 (前後半交換)

類似 C 風格的寫法大概長這樣，
最後一輪利用整數自然截位所以不用 mask（當然這點要看語言特性）。

x = (((x & 0xAA) » 1) | ((x & 0x55) « 1));
x = (((x & 0xCC) » 2) | ((x & 0x33) « 2));
x = (x » 4) | (x « 4);

更快的作法就是半查表，也就是把問題分解到某階段改用查的。 」
(註：利用連續的bit mask進行處理，可達到交換的目的，
這個方法對於在意效能 來說，
由於if/while/for 等需要判斷 或有分歧狀況 的程式碼，
皆須花費相對於位元運算而言較多的時間，
能夠單純利用位元運算達成互換會是在實際狀況較棒的解法。)

(但，其實沒特別用過的話，面試時其實頗難回想出這種解法就是了XD)
有興趣的話可以參考這兩篇：

另外，Java中內建的bitCount 函式(計算某個數的二進位制含有1的數量)，
也運用了類似的手法達到目的。
參見： https://www.jishuwen.com/d/2HPI/zh-tw

(歡迎提供意見協助更正歐~)

從LeetCode學演算法，我們下次見囉，掰~

1

如果你／妳覺得這篇文章不錯，請給我5個Like。(點開SHOW EMBED!)

從LeetCode學演算法 - 15 Bitwise Operation (2)

Thu, 18 Jul 2019 00:00:00 +0800

0136. Single Number (Easy)

Question

Given a non-empty array of integers, every element appears twice except for one. Find that single one.

Note:

Your algorithm should have a linear runtime complexity. Could you implement it without using extra memory?

Example 1

1
2


Input: [2,2,1]
Output: 1

Example 2

1
2


Input: [4,1,2,1,2]
Output: 4

分析/解題

給定一個非空的整數陣列，當中每個元素都出現兩次，只有一個出現一次而已，題目要求找出那個單獨的數字。

在進一步往BST之前，先來一個簡單但一般不會想到的問題。
這題如果我們以暴力法來解的話，假設不用任何額外的資料結構，我們可以每拿一個數字就對整個陣列做比較，直到找到沒有重複的數字為止。但這樣除了時間複雜度會是O(N)以外(對單一數字，所以每個數字都做完就是O(N^2))，最後會發現有可能會有拿到先前拿過一次的數字，所以顯然是不太行的。

那輔以資料結構呢？
比較常用的方法是使用HashMap(Python則用dict)，為每個數字計數，計數完以後就掃過整個對應，看誰只有被數到一次，就是我們要的答案了。
這個方法要先走訪過一遍陣列，再走訪一遍HashMap或dict，時間/空間複雜度均為O(N)，但還是稍嫌慢了一些。

那有沒有更厲害的解法呢？有！
要了解這個解法怎麼操作，首先我們需要複習一下Bitwise Operation。
當中的XOR的內容是：將兩個數的每個位元兩兩相對，一個0一個1的時候，結果會是1，否則結果會是0 。
這可以讓數字運算得到一些神奇的特性，第一個特性是：

1

a XOR a = 0

我們拿11=1011(二進位)來試試看：

1
2
3


11 = 1011
11 = 1011
11 XOR 11 = 0000 = 0

因為每一位數都相同，XOR後每一位就都會是0。
第二個特性是：

1

0 XOR a = a, a XOR 0 = a

因為一邊都是0，所以那個位數是0或1，端看原先a的位元。
再來其他一些重要的特性是：

1
2


a XOR b = b XOR a (交換律)
(因每個位元的結果端看該位元總共有奇數或偶數個1，和順序無關)

1
2
3


(a XOR b) XOR c = a XOR (b XOR c) = a XOR (c XOR b) = a XOR c XOR b
(不論哪邊先做，結果都是看有奇數個1->結果是1，偶數個1->結果是0)
(最前面的部分是標準的結合律)

推而廣之，我們可以得到XOR具有交換律 和結合律 。將它的運算的數字左右調換，或者哪個先做，哪個後做，均不影響結果。

回到問題來，假設我們目標的答案是r，那麼將陣列中所有的數字XOR起來，會發生什麼事情呢？我們根據前面的已知，將陣列自己調換一下，應該可以變成：
r XOR a XOR a XOR b XOR b XOR c XOR c ……的形式。
(因為怎麼換都不應該影響結果)

於是，陣列全部XOR的結果會等於r XOR 0 XOR 0 XOR…… = r
(其它的兩兩XOR後會變0)
也就是說，將每個數都進行XOR後，結果會留存下那個唯一單獨的數字。
寫成程式碼如下，宣告變數為0後從index 0開始，或直接將陣列的第一個數指派給它並從index 1開始，實測上沒有特別感受到時間差異，讀者依照自己的喜好和習慣嘗試即可。

Java的部分用了語法蜜糖 ，
int e:nums代表自nums陣列按順序每次拿一個數並交給e。

Java

Python

面試實際可能會遇到的問題

「時間/空間複雜度？」
(由於只要整個陣列掃過一次就結束了且無須額外的陣列空間，
時間複雜度為O(N)，空間複雜度則為O(1))

從LeetCode學演算法，我們下次見囉，掰~

註：感謝zhoumax的提醒修正一些敘述和筆誤。

從LeetCode學演算法 - 11 Bitwise Operation (1)

Thu, 11 Jul 2019 00:00:00 +0800

0089. Gray Code (Medium)

Question

The gray code is a binary numeral system where two successive values differ in only one bit.

Given a non-negative 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.

Example 1

1
2
3
4
5
6
7


Input: 2
Output: [0,1,3,2]
Explanation:
00 - 0
01 - 1
11 - 3
10 - 2

1
2


For a given n, a gray code sequence may not be uniquely defined.
For example, [0,2,3,1] is also a valid gray code sequence.

Example 2

1
2
3
4
5


Input: 0
Output: [0]
Explanation: We define the gray code sequence to begin with 0.
 A gray code sequence of n has size = 2n, which for n = 0 the size is 20 = 1.
 Therefore, for n = 0 the gray code sequence is [0].

分析/解題

格雷碼是一個二進位表示的編碼系統，當中每個連續(相鄰)的二個值之間的表示方式只會相差一個位元(bit)。題目給定n個bits，試求出其表達的格雷碼序列。(格雷碼序列一定是從0開始)

在這邊簡單講解一下Bitwise Operation。
(註:本題雖然不會用到太多，
但熟悉這些操作對於一些題目和實際應用上很有幫助，
故在此先行列出給讀者學習。)

先前的文章中已經提到了，電腦對於二進位制的東西操作起來是較為得心應手的，當然我們可以不用像電腦這麼熟悉，但只要會用就可以了XD
二進位之間的一些操作運算，就像是邏輯學上的運算一樣，
有AND/OR/NOT/XOR，以及位移運算(bit shifts)等，這些速度在相同狀況下是由CPU進行支援的，運算速度往往會比一般的四則運算還快。

AND(且):
邏輯上的AND，代表著前後皆為真的狀況結果才為真，否則為假 ，
也就是兩者皆成立才行。在位元運算中，1被視為真，0被視為假。
(所以在如C/C++中你可能會看到使用IF 1或IF 0的開關)
延伸到多個bit的狀況，就是將前後兩者每個bit兩兩相對，
當兩者為1時，運算完的那個新的bit為1，否則為0。
如 110 AND 100的結果會是100(只有最左邊的bit是兩個1)
Java和Python中的AND運算符號均為"&" 。
(請留意，如果判斷兩個運算結果的是否為真 的邏輯運算，
Java是"&&"，Python則是"and" ，
以位元為基準的運算和求真偽的邏輯運算是不同的，記得不要搞混了！)

OR(或):
前後兩者只要其一為真結果即為真，
也就是只有兩者皆不成立時，結果才會是假 。
所以在位元運算中，
兩兩相對，除了兩個bit都是0的運算結果是0外，其餘都會是1 。
如 110 OR 100的結果會是110(只有最右邊的bit是兩個0)
Java和Python中的OR運算符號均為"|" 。
(如果是邏輯運算的話，Java是"||"，Python則是"or" )

NOT(非):
邏輯上的NOT，代表將該真/假狀況轉為原先的相反 ，
真的變假的，假的變真的 。
在位元運算中，對每個bit操作，
只要原先是1的均變為0，為先為0的則變為1 。
如NOT 110的結果會是001。
Java和Python中NOT運算符號均為"~" 。
(如果是邏輯運算的話，Java是"!"，Python則是"not" )

XOR(互斥或，Exclusive OR):
邏輯上的XOR，代表前後兩個狀況剛好有一個成立時為真 ，
即前真後假/前假後真，其餘皆為假。
位元運算的部分，兩兩相對檢查，當發現是一個1一個0的時候，
結果為1，否則均為0。
如1100 XOR 1010的結果會是0110。
Java和Python中的XOR運算符號均為"^" 。

位移運算:
將一個數的所有bit的東西往左或往右移動指定的位元數，
超出儲存空間的部分捨棄，被位移走的原處則補0。
Java和Python中使用"«“和”»“分別代表向左位移及向右位移。
例如:
2 « 1 的結果會是4，因為2的二進位是"10”，
這個操作代表2向左位移1個bit，空白的部分補零，
所以會得到"100"也就是十進位制的4。

9 » 2的結果會是2，因為9的二進位是"1001"，
這個操作代表向右位移2個bit，所以"01"的部分移出儲存範圍了被捨棄掉，
會得到"10"，也就是十進位的2。

直觀上我們可以將位移N個bit視作乘以或除以2的N次方，
但要注意範圍是否正確，以及是否要處理正負號 的部分。

上面介紹了位元運算以後，讓我們回到題目。
在通訊傳輸的過程中，有可能因為受到雜訊干擾等狀況，
使得當中的位元反轉(0變成1，1變成0)。倘若我們按照正常的表達方式，
例如7=0111, 8=1000，對於某些臨界狀況而言，小範圍的變動值會需要大幅度的修改bit，同時當某個高位數的bit出錯的狀況，值就有可能受到大幅度的改變，這顯然是比較糟糕的。

所以格雷碼的設計就是希望能夠讓更動小數值的時候，只更動較少的bit數量即可，且當有其中的bit受到干擾而出錯時，數值的影響範圍也較小。

那怎麼計算呢？
我們從1個bit開始推導看看：
由於要求要從0開始，
故我們應該是拿0代表0，1代表1，這樣就完成了1個bit的格雷碼。
2個bit的話，由於用10來表示會一次更動2個bit(01->10)，
所以我們只能拿11來表示2，而10則表示3。

當然，也可以用00, 10, 11, 01來進行表示，但這種方式相對較複雜，
我們直接去考慮前面的方式的邏輯就好。

再來我們可以思考，在不要動到前面的數的狀況下，
下面我們要怎麼表達3個bit的狀況呢？
已經知道：

我們想要剛好用3個bit表示07，
那唯有讓47的部分的最左邊的bit均為1才行。
(因為前面的2個bit組合已經被用過了)
同時我們又想要符合相鄰只動一個bit 的原則，
所以4的表示方式就只剩下110了!

同時，我們也知道前面03符合這個只動一個bit的表達方式，
那麼後面填入57的方式，就可以按照上下鏡向 的狀況填入，
自然會符合格雷碼的要求。也就是除了最左邊是1以外，
4對應到3，5就對應到2，6對應到1，7對應到0即可。

同樣的道理，變成4個bit時，將後面的8個數的最左邊的bit填入1，
其它的部分鏡向填入即可。

歸納一下這題的解法：

先放入0(最開始的部分，也是n=0時的解答)
定義一個變數adder，用來表示這輪要加上去的bit所代表的值
(初始值是2的0次方=1)
每次將答案的尾端加上一個新的值，
這個新的值是鏡向對應到的值加上adder。
(鏡向對應的方式，可以從尾端開始往回算，或者用adder-1-index來計算)
計算完畢一輪以後，將adder變為2倍，作為下一輪要額外加上去的值。
一路操作直到完成n輪為止，最後將結果回傳。

Java

Python

讀者可以看到兩個解法中一個使用+adder，另一個使用|add，
結果上是一樣的，因為加上去的那個bit一定是跟0相加，
故可以用OR運算會加快一點速度。(讀者可以修改成+來比較看看速度)
*2和«=1的部分，同樣可以等價於位移一個bit，
但速度上應該不會有特別差異才對。

面試實際可能會遇到的問題

「時間複雜度？」
(O(2的n次方)，因為n個bit可以表示2的n次方個數)

「(Python)能不能不要用append來解？」
(可以用extend，
每次將res的部分反轉接上後，再進行add的加總)

「為什麼你要用"_"？」
(因為第一個迴圈事實上只是處理執行n次這件事情，
我們並不需要用到其數值，在習慣上會盡量用底線來命名，
避免去用到有意義的命名方式。)

從LeetCode學演算法，我們下次見囉，掰~