C language to determine whether a number is the power of 2 or the power of the 4-square _c language

Quickly determine whether a number is a power of 2, if so, and determine how many times the square!
when the power of 2 is written in binary form, it is easy to find a feature: The binary is only a 1, and 1 followed by n 0, so the problem can be converted to determine whether 1 followed by n 0 on it.

If you subtract this number by 1, you will find that the only 1 will become 0, and the original n 0 will be 1, so that the original number and the number after subtracting 1 will be zero.

The quickest way:

   (number & number-1) = = 0

Reason: Because 2 of the n-th conversion is binary to 10 ... 0 such a form (excluding 0). With the digits on their own-1, this gets the result of 0. For example. The binary of 8 is the binary of 1000;8-1=7,7 is 111. The result of the two phase is 0. The calculations are as follows:

     1000
   & 0111
    -------
    0000

The code that uses the recursive implementation is as follows:

#include "stdio.h" 
#include "stdlib.h" 
 
int log2 (int value)  //recursion to determine how many times a number is 2 
  (value = = 1) return 
    0; 
  else return 
    1+log2 (value>>1); 
} 
 
int main (void) 
{ 
  int num; 
  printf ("Please enter an integer:"); 
  scanf ("%d", &num); 
  if (num& (num-1))//use and operation to determine whether a number is a power of 2, 
    printf ("%d is not a power of 2!") \ n ", num); 
  else 
    printf ("%d is 2%d times!") \ n ", num,log2 (num)); 
  System ("pause"); 
  return 0; 
} 

The code that uses the non-recursive implementation is as follows:

#include "stdio.h" 
#include "stdlib.h" 
 
int log2 (int value)  //non-recursive judgment of how many times a number is 2 of the square 
{ 
  int x=0; 
  while (value>1) 
  { 
    value>>=1; 
    x + +; 
  } 
  return x; 
} 
 
int main (void) 
{ 
  int num; 
  printf ("Please enter an integer:"); 
  scanf ("%d", &num); 
  if (num& (num-1))   //use and operation to determine whether a number is a power of 2, 
    printf ("%d is not a power of 2!") \ n ", num); 
  else 
    printf ("%d is 2%d times!") \ n ", num,log2 (num)); 
  System ("pause"); 
  return 0; 
} 

Extension: Find the number of 1 in binary of N.
A very ingenious use of a property,n=n& (n-1) can remove the property of the rightmost 1 in the binary of N, and the loop is removed until all 1 is removed, which reduces the complexity of the problem to only the number of 1. The code is as follows:

int Func3 (int data) 
{  ////data& (Data-1) removes the rightmost 1 each time, removes how many 1, or contains several 1 
  int count = 0; 
  while (data) 
  { 
    data = data & (data-1); 
    count++; 
  } 
  return count; 
} 

Extended question two:

How many bits are different in the binary of A and B. This problem can be divided into two steps, (1) different from A and B or get C, i.e. C=a^b, (2) to calculate how many 1 in the C binary.

Quickly determine whether a number is a power of 4, if so, and determine how many times the square!
after the power of 4 is written in binary form, it's easy to find a feature: binary only has a 1 (1 in odd position), and 1 followed by an even number of 0, so the problem can be converted to determine whether 1 followed by an even number of 0 on it.

4 of the integer power of the binary numbers are (4) 100, (16) 10000, (64) 1000000 ...

In addition, the power of the 4 square 4^n can also be written as 2^ (2*n), which can also be written as a power of 2, of course, to meet the power of 2 of the conditions, that is, Num & num-1==0.

Idea: First use conditional num & num-1==0 to judge whether the power of 2, if not satisfied, is not. If satisfied, in the condition of Num & 0x55555555 to judge, if true, then this integer is 4 power side, otherwise not.

The code that uses the recursive implementation is as follows:

#include "stdio.h" 
#include "stdlib.h" 
 
bool fn (unsigned int x)   //Determine if x is a power exponent of 4 
{ 
 if (x & (X-1)) c6/>//to determine whether X is 2 power square return 
   false; 
 return x & 0x55555555;   To determine whether 1 is in odd places 
} 
 
int log4 (int value)   ///recursive to determine how many times a number is 4 of the second party 
{ 
  if (value = = 1) return 
    0; 
  else 
  { 
    value>>=1;    Shift to right return 
    1+log4 (value>>1);    Shift to right 
  } 
 
int main (void) 
{ 
  int num; 
  printf ("Please enter an integer:"); 
  scanf ("%d", &num); 
  if (FN (num))   //use and operation to determine whether a number is 2 power to 
    printf ("%d is 4%d Times Square!") \ n ", Num,log4 (num)); 
  else 
    printf ("%d is not a power party of 4!") \ n ", num); 
  System ("pause"); 
  return 0; 
} 

The code that uses the non-recursive implementation is as follows:

#include "stdio.h" 
#include "stdlib.h" 
 
bool fn (unsigned int x)   //Determine if x is a power exponent of 4 
{ 
 if (x & (X-1)) c6/>//to determine whether X is 2 power square return 
   false; 
 return x & 0x55555555;   To determine whether 1 is in odd positions 
} 
 
int log4 (int value)  //Non-recursive judge how many times a number is 4 of the second party   
{ 
  int x=0; 
  while (value>1) 
  { 
    value>>=1;   Shift Right 
    value>>=1; 
    x + +; 
  } 
  return x; 
}  
 
int main (void) 
{ 
  int num; 
  printf ("Please enter an integer:"); 
  scanf ("%d", &num); 
  if (FN (num))   //use and operation to determine whether a number is 2 power to 
    printf ("%d is 4%d Times Square!") \ n ", Num,log4 (num)); 
  else 
    printf ("%d is not a power party of 4!") \ n ", num); 
  System ("pause"); 
  return 0; 
}