/* 
 * bitXor - x^y using only ~ and & 
 *   Example: bitXor(4, 5) = 1
 *   Legal ops: ~ &
 *   Max ops: 14
 *   Rating: 1
 */
int bitXor(int x, int y) {
  int result = ~(~x&~y)&~(x&y)
  return result;
}

/* 
 * tmin - return minimum two's complement integer 
 *   Legal ops: ! ~ & ^ | + << >>
 *   Max ops: 4
 *   Rating: 1
 */
int tmin(void) {
  int result = 0x80<<24;
  return result;
}

/*
 * isTmax - returns 1 if x is the maximum, two's complement number,
 *     and 0 otherwise 
 *   Legal ops: ! ~ & ^ | +
 *   Max ops: 10
 *   Rating: 1
 */
int isTmax(int x) {
  int result = x + x + 1;
  result = ~result;
  result = result + !(x + 1) //排除-1特殊
  return !result;
}

/* 
 * allOddBits - return 1 if all odd-numbered bits in word set to 1
 *   where bits are numbered from 0 (least significant) to 31 (most significant)
 *   Examples allOddBits(0xFFFFFFFD) = 0, allOddBits(0xAAAAAAAA) = 1
 *   Legal ops: ! ~ & ^ | + << >>
 *   Max ops: 12
 *   Rating: 2
 */
int allOddBits(int x) {
    int mask = 0xAA + (0xAA<<8);
    mask = mask + (mask<<16); //32位10101010....
    result = (x&mask)^mask;
    return !result;
}

/* 
 * negate - return -x 
 *   Example: negate(1) = -1.
 *   Legal ops: ! ~ & ^ | + << >>
 *   Max ops: 5
 *   Rating: 2
 */
int negate(int x) {
  result = ~x + 1;
  return result;
}

/* 
 * isAsciiDigit - return 1 if 0x30 <= x <= 0x39 (ASCII codes for characters '0' to '9')
 *   Example: isAsciiDigit(0x35) = 1.
 *            isAsciiDigit(0x3a) = 0.
 *            isAsciiDigit(0x05) = 0.
 *   Legal ops: ! ~ & ^ | + << >>
 *   Max ops: 15
 *   Rating: 3
 */
int isAsciiDigit(int x) {
  int mini = 0x80<<24;
  int min = (~0x2F + x) & mini; //正确时，min是0000...
  int max = (~0x39 + x) & mini; //正确时，max是1000...
  int result = (min^max)>>31;
  result = ~result + 1;
  return result;
}

/* 
 * conditional - same as x ? y : z 
 *   Example: conditional(2,4,5) = 4
 *   Legal ops: ! ~ & ^ | + << >>
 *   Max ops: 16
 *   Rating: 3
 */
int conditional(int x, int y, int z) {
    x = !x;
    x = ~x + 1;
    int result = (~x&y)|(x&z)
    return result;
}

/* 
 * isLessOrEqual - if x <= y  then return 1, else return 0 
 *   Example: isLessOrEqual(4,5) = 1.
 *   Legal ops: ! ~ & ^ | + << >>
 *   Max ops: 24
 *   Rating: 3
 */
int isLessOrEqual(int x, int y) {
    int r1 = (x>>31) & ~(y>>31); //是否x是负数，y是正数
    r1 = !!r1;
    int r2 = !((x>>31)^(y>>31)); //是否x，y同号
    int r3 = (!(y + ~x + 1))>>31; //y-x的符号
    r3 = !!r3;
    int result = r1|(r2&r3);
    return result;
}

/* 
 * logicalNeg - implement the ! operator, using all of 
 *              the legal operators except !
 *   Examples: logicalNeg(3) = 0, logicalNeg(0) = 1
 *   Legal ops: ~ & ^ | + << >>
 *   Max ops: 12
 *   Rating: 4 
 */
int logicalNeg(int x) {
    int result = ((~x+1)>>31)^(x>>31);
    result = ~result + 1;    
    return result;
}

/* howManyBits - return the minimum number of bits required to represent x in
 *             two's complement
 *  Examples: howManyBits(12) = 5
 *            howManyBits(298) = 10
 *            howManyBits(-5) = 4
 *            howManyBits(0)  = 1
 *            howManyBits(-1) = 1
 *            howManyBits(0x80000000) = 32
 *  Legal ops: ! ~ & ^ | + << >>
 *  Max ops: 90
 *  Rating: 4
 */
int howManyBits(int x) {
    x = x^(x>>31); //得到负数补码，正数不变
    int A,B,C,D,E,F;
    A = !!(x>>16)<<4; //看最高16位有无1，如果有，A为16；
    x = x>>A; //如果上面成立，则消掉后面16位（后面的数字不讨论，折半讨论有1的区域）
    B = !!(x>>8)<<3; //看原数据最高8位有无1，有则B为8；
    x = x>>B; //成立则消掉后面8位（相当于总地消掉原数据后面24位）
    C = !!(x>>4)<<2; //同理,直到遍历到1的准确位置，之后把记的数字加起来，就是需要表示的最小数量
    x = x>>C;
    D = !!(x>>2)<<1;
    x = x>>D;
    E = !!(x>>1);
    x = x>>E;
    F = x;
    int result = A + B + C + D + E + F + 1; //+1表示符号位
    return result;
}

/* 
 * floatScale2 - Return bit-level equivalent of expression 2*f for
 *   floating point argument f.
 *   Both the argument and result are passed as unsigned int's, but
 *   they are to be interpreted as the bit-level representation of
 *   single-precision floating point values.
 *   When argument is NaN, return argument
 *   Legal ops: Any integer/unsigned operations incl. ||, &&. also if, while
 *   Max ops: 30
 *   Rating: 4
 */
unsigned floatScale2(unsigned uf) {
  int exp = (uf&0x7F800000)>>23; //求指数
  if(exp==0) //无穷小和0的情况，返回乘2的值
  return uf<<1|(!!(uf>>31));
  if(exp==255) //无穷大和NaN的情况，返回原值（它们乘2等于本身）
  return uf;
  exp = exp + 1;
  if(exp==255) //剩下的情况则是如果指数+1为255，那就返回原符号无穷大，否则返回指数加1后的原符号数
  return 0x7F800000|(!!(uf>>31));
  else
  result = (exp<<23)|(uf&0x807FFFFF);
  return result;
}

/* 
 * floatFloat2Int - Return bit-level equivalent of expression (int) f
 *   for floating point argument f.
 *   Argument is passed as unsigned int, but
 *   it is to be interpreted as the bit-level representation of a
 *   single-precision floating point value.
 *   Anything out of range (including NaN and infinity) should return
 *   0x80000000u.
 *   Legal ops: Any integer/unsigned operations incl. ||, &&. also if, while
 *   Max ops: 30
 *   Rating: 4
 */
int floatFloat2Int(unsigned uf) {
  int exp = (uf&0x7F800000)>>23;
  int frac = (uf&0x007FFFFF)|0x00800000; //或上0x00800000是为了加上省掉的1
  if((exp<127)||(!uf))  return 0; //特殊情况
  if(exp>158) return 0x80000000u;  //指数大于31+127
  if(exp>150) frac <<= (exp-150); //把小数转换成整数
  else frac >>= (150-exp);
  if(!((frac>>31)^(uf>>31))) return frac; //符号相同
  else if(frac>>31) return 0x80000000u; //原符号为正溢出
  else return ~frac+1; //原负数情况
}

/* 
 * floatPower2 - Return bit-level equivalent of the expression 2.0^x
 *   (2.0 raised to the power x) for any 32-bit integer x.
 *
 *   The unsigned value that is returned should have the identical bit
 *   representation as the single-precision floating-point number 2.0^x.
 *   If the result is too small to be represented as a denorm, return
 *   0. If too large, return +INF.
 * 
 *   Legal ops: Any integer/unsigned operations incl. ||, &&. Also if, while 
 *   Max ops: 30 
 *   Rating: 4
 */
unsigned floatPower2(int x) {
    int exp = x + 127;
    if(exp<=0) return 0;
    if(exp>=255) return 0xFF<<23;
    return exp<<23;
}