Gray Code

                            Solution in C :

int* grayCode(int n, int* len) {
    *len=1<<n;
    int *ret = malloc(sizeof(*ret)**len);
    ret[0]=0;
    int nn=1;
    while(n--){
        for (int i=0;i<nn;i++){
            ret[nn+i]=nn|ret[nn-i-1];
        }
        nn<<=1;
    }
    return ret;
}
                        

                        Solution in C++ :

class Solution {
public:
    vector<int> grayCode(int n) {
        
        int iteration = 1;
        int fac = 1;
        vector<int> result{0, 1};

        for( ; iteration < n ; iteration++ ){
            fac = fac*2;
            int l = result.size()-1;
            for( ; l>=0 ; l-- ){
                int val = result[l] + fac;
                result.push_back(val);
            }
        }

        return result;
    }
};
                    

                        Solution in Java :

class Solution {
    List<Integer> ans;
    HashSet<String> visited;
    public List<Integer> grayCode(int n) {
        visited = new HashSet();
        ans = new ArrayList();
        StringBuilder s = new StringBuilder();
        for(int i=0;i<n;i++)
          s.append('0');
        dfs(s,n);
        return ans;
    }
    void dfs(StringBuilder s,  int n)
    {
        if(visited.contains(s.toString()))
            return;
        visited.add(s.toString());
        ans.add(Integer.parseInt(s.toString(),2));
        for(int i=0;i<n;i++)
        {
           char or = s.charAt(i);
           char c = (or=='0')?'1': '0';
            s.setCharAt(i,c);
            if(!visited.contains(c))
                dfs(s,n);
            s.setCharAt(i,or);
        }
    }
}
                    

                        Solution in Python : 
                            
class Solution:
    def grayCode(self, n: int) -> List[int]:
        oldArr = [0,1]
        i = 1
        while i< n:
            Arr = list(oldArr)
            for j in range(len(oldArr)-1,-1,-1):
                Arr.append((2**i)+oldArr[j])
            oldArr = Arr
            i+=1
        return oldArr