Bit Manipulation

位操作   Bit Manipulation

leetcode 405. Convert a Number to Hexadecimal

Given an integer, write an algorithm to convert it to hexadecimal. For negative integer, two’s complement method is used.

Note:

1. All letters in hexadecimal (a-f) must be in lowercase.
2. The hexadecimal string must not contain extra leading 0s. If the number is zero, it is represented by a single zero character '0'; otherwise, the first character in the hexadecimal string will not be the zero character.
3. The given number is guaranteed to fit within the range of a 32-bit signed integer.
4. You must not use any method provided by the library which converts/formats the number to hex directly
5. Example 2:

6. Input:
   26
   
   Output:
   "1a"
   

   Example 2:

   Input:
   -1
   
   Output:
   "ffffffff"

代码的原作者: palindrome018 

const string HEX = "0123456789abcdef";
class Solution {
public:
    string toHex(int num) {
        if (num == 0) return "0";
        string result;
        int count = 0;
        while (num && count++ < 8) {
            result = HEX[(num & 0xf)] + result;
            num >>= 4;
        }
        return result;
    }
};

amazing code

78. Subsets

Given a set of distinct integers, nums, return all possible subsets.

Note: The solution set must not contain duplicate subsets.

For example,
If nums = [1,2,3], a solution is:

[
  [3],
  [1],
  [2],
  [1,2,3],
  [1,3],
  [2,3],
  [1,2],
  []
]

code:

class Solution {
public:
    vector<vector<int> > subsets(vector<int> &S) {
        sort (S.begin(), S.end());
        int elem_num = S.size();
        int subset_num = pow (2, elem_num);
        vector<vector<int> > subset_set (subset_num, vector<int>());
        for (int i = 0; i < elem_num; i++)
            for (int j = 0; j < subset_num; j++)
                if ((j >> i) & 1)
                    subset_set[j].push_back (S[i]);
        return subset_set;
    }
};

<div id="inner-editor"><br class="Apple-interchange-newline">@leet_nik said in [My solution using bit manipulation](/post/61260): > This is an amazing solution.Learnt a lot.Let me try to explain this to those who didn't get the logic. > > Number of subsets for {1 , 2 , 3 } = 2^3 . > why ? > case possible outcomes for the set of subsets > 1 -> Take or dont take = 2 > 2 -> Take or dont take = 2 > 3 -> Take or dont take = 2 > > therefore , total = 2*2*2 = 2^3 = { { } , {1} , {2} , {3} , {1,2} , {1,3} , {2,3} , {1,2,3} } > > Lets assign bits to each outcome -> First bit to 1 , Second bit to 2 and third bit to 3 > Take = 1 > Dont take = 0 > > 0) 0 0 0 -> Dont take 3 , Dont take 2 , Dont take 1 = { } > 1) 0 0 1 -> Dont take 3 , Dont take 2 , take 1 = {1 } > 2) 0 1 0 -> Dont take 3 , take 2 , Dont take 1 = { 2 } > 3) 0 1 1 -> Dont take 3 , take 2 , take 1 = { 1 , 2 } > 4) 1 0 0 -> take 3 , Dont take 2 , Dont take 1 = { 3 } > 5) 1 0 1 -> take 3 , Dont take 2 , take 1 = { 1 , 3 } > 6) 1 1 0 -> take 3 , take 2 , Dont take 1 = { 2 , 3 } > 7) 1 1 1 -> take 3 , take 2 , take 1 = { 1 , 2 , 3 } > > In the above logic ,Insert S[i] only if (j>>i)&1 ==true { j E { 0,1,2,3,4,5,6,7 } i = ith element in the input array } > > element 1 is inserted only into those places where 1st bit of j is 1 > if( j >> 0 &1 ) ==> for above above eg. this is true for sl.no.( j )= 1 , 3 , 5 , 7 > > element 2 is inserted only into those places where 2nd bit of j is 1 > if( j >> 1 &1 ) == for above above eg. this is true for sl.no.( j ) = 2 , 3 , 6 , 7 > > element 3 is inserted only into those places where 3rd bit of j is 1 > if( j >> 2 & 1 ) == for above above eg. this is true for sl.no.( j ) = 4 , 5 , 6 , 7 > > Time complexity : O(n*2^n) , for every input element loop traverses the whole solution set length i.e. 2^n > > <br></div>

HIDE PREVIEW

@leet_nik said in My solution using bit manipulation:

 This is an amazing solution.Learnt a lot.Let me try to explain this to those who didn't get the logic.

 Number of subsets for {1 , 2 , 3 } = 2^3 .
 why ? 
case    possible outcomes for the set of subsets
  1   ->          Take or dont take = 2 
  2   ->          Take or dont take = 2  
  3   ->          Take or dont take = 2 

therefore , total = 2*2*2 = 2^3 = { { } , {1} , {2} , {3} , {1,2} , {1,3} , {2,3} , {1,2,3} }

Lets assign bits to each outcome  -> First bit to 1 , Second bit to 2 and third bit to 3
Take = 1
Dont take = 0
 
0) 0 0 0  -> Dont take 3 , Dont take 2 , Dont take 1 = { } 
1) 0 0 1  -> Dont take 3 , Dont take 2 ,   take 1       =  {1 } 
2) 0 1 0  -> Dont take 3 ,    take 2       , Dont take 1 = { 2 } 
3) 0 1 1  -> Dont take 3 ,    take 2       ,      take 1    = { 1 , 2 } 
4) 1 0 0  ->    take 3      , Dont take 2  , Dont take 1 = { 3 } 
5) 1 0 1  ->    take 3      , Dont take 2  ,     take 1     = { 1 , 3 } 
6) 1 1 0  ->    take 3      ,    take 2       , Dont take 1 = { 2 , 3 } 
7) 1 1 1  ->    take 3     ,      take 2     ,      take 1     = { 1 , 2 , 3 } 

In the above logic ,Insert S[i] only if (j>>i)&1 ==true   { j E { 0,1,2,3,4,5,6,7 }   i = ith element in the input array }

element 1 is inserted only into those places where 1st bit of j is 1 
   if( j >> 0 &1 )  ==> for above above eg. this is true for sl.no.( j )= 1 , 3 , 5 , 7 

element 2 is inserted only into those places where 2nd bit of j is 1 
   if( j >> 1 &1 )  == for above above eg. this is true for sl.no.( j ) = 2 , 3 , 6 , 7

element 3 is inserted only into those places where 3rd bit of j is 1 
   if( j >> 2 & 1 )  == for above above eg. this is true for sl.no.( j ) = 4 , 5 , 6 , 7 

Time complexity : O(n*2^n) , for every input element loop traverses the whole solution set length i.e. 2^n