LeetCode – Gray Code (Java)

 

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.

For example, given n = 2, return [0,1,3,2]. Its gray code sequence is:

00 - 0
01 - 1
11 - 3
10 - 2

Java Solution

public List<Integer> grayCode(int n) {
    if(n==0){
        List<Integer> result = new ArrayList<Integer>();
        result.add(0);
        return result;
    }
 
    List<Integer> result = grayCode(n-1);
    int numToAdd = 1<<(n-1);
 
    for(int i=result.size()-1; i>=0; i--){ //iterate from last to first
        result.add(numToAdd+result.get(i));
    }
 
    return result;
}

Related posts:

  1. LeetCode – Combinations (Java)
  2. LeetCode – Group Shifted Strings (Java)
  3. LeetCode – Generate Parentheses (Java)
  4. LeetCode – Binary Watch (Java)
Category >> Algorithms  
If you want someone to read your code, please put the code inside <pre><code> and </code></pre> tags. For example: 
<pre><code> 
String foo = "bar";
</code></pre>
  • Marina

    Complexity O(2^n) where n is number of digits in gray code

    public int[] gray(int num) {
    if (num == 0) {
    throw new IllegalArgumentException();
    }
    if (num == 1) {
    return new int[]{0, 1};
    }

    int[] result = new int [(int) Math.pow(2, num)];
    result[0] = 0;
    result[1] = 1;

    for (int i = 1; i < num; i++) {
    int k = (int)Math.pow(2, i);
    for (int j = 0; j < k; j++) {
    result[j+ k] = result[k-j-1] + k;
    }
    }
    return result;
    }

  • Swapnil Kumar

    public class Solution {
    public List grayCode(int n) {
    List result = new ArrayList();
    result.add(0);
    for(int j = 1; j <=n ; j++){
    int numToAdd = 1 <=0 ; i–){
    result.add(result.get(i)+numToAdd);
    }
    }
    return result;
    }
    }

  • Anwesha Bhattacharya


    public List grayCode(int n) {
    HashMap map = new HashMap();
    ArrayList code = new ArrayList();
    map.put(0, 0);
    code.add(0);
    search(n, (int)Math.pow(2, n) - 1, 0, map, code);
    return code;
    }

    public static void search(int n, int remain, int N, HashMap map, ArrayList code) {
    if (remain == 0) return;
    int originalN = N;
    for (int i = 0 ; i < n ; i++) {
    if ((N & (1 << i)) == (1 << i))
    N = N - (1 << i);
    else
    N = N + (1 << i);

    if (!map.containsKey(N)) {
    map.put(N, N);
    code.add(N);
    remain--;
    search(n, remain, N, map, code);
    break;
    }
    N = originalN;
    }
    }

  • Anwesha Bhattacharya

    Some code

  • William Kuo

    My answer, run in O(n log n)

  • William Kuo

    public List grayCode(int n) {
    HashMap map = new HashMap();
    ArrayList code = new ArrayList();
    map.put(0, 0);
    code.add(0);
    search(n, (int)Math.pow(2, n) – 1, 0, map, code);
    return code;
    }

    public static void search(int n, int remain, int N, HashMap map, ArrayList code) {
    if (remain == 0) return;
    int originalN = N;
    for (int i = 0 ; i < n ; i++) {
    if ((N & (1 << i)) == (1 << i))
    N = N – (1 << i);
    else
    N = N + (1 << i);

    if (!map.containsKey(N)) {
    map.put(N, N);
    code.add(N);
    remain–;
    search(n, remain, N, map, code);
    break;
    }
    N = originalN;
    }
    }

  • Harshad Sathe

    What is the time complexity of this algorithm?