Datalab总结

---

基础运算

将难度分为5个档次，仅供参考。
要求全程可以直接使用的数范围在0x00-0xFF之间

1.异或

要求：仅用～和&实现异或运算；
难度：1星
思路：直接采用数字逻辑中学到的就可以推导出计算公式：

代码表达如下：

/* 1
 * 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 a1, a2, re;
    a1 = ~(x & (~y));
    a2 = ~((~x) & y);
    re = ~(a1 & a2);
  return re;
  
//不使用中间变量：
int bitXor(int x, int y) {
  return  ~( (~(x & (~y))) & (~((~x) & y)));
}

2.判断是否为最大数

要求：x为最大数，返回1；否则返回0。
难度：3星
思路：（这一题没有想到特别好的思路，如果有好的想法欢迎分享）
最大数为0x7FFFFFFF，最开始发现最大数加1后的值与最大数异或可以得到全1，所以用此作为判断依据。

后来发现还有一个特例也会有相同结论：0xFFFFFFFF，所以还需要排除全1的这种情况。

可以发现（其实后来都是凑出来的orz），全1加上1后是全0，与最大数加上1得到1不同，所以以此作为切入点进行判断。

语言难以表达，上代码：

/* 2
 * judgeTMax - returns 1 if x is the maximum of two's 	 *complement number, and 0 otherwise 
 *   Legal ops: ! ~ & ^ | +
 *   Max ops: 10
 *   Rating: 1
 */
 //便于理解版：
int judgeTMax(int x) {
    int a1, a, b, c;
    a1 = !(x + 1) + 1;
    //如果x为最大数，a1就是1，下述判断方法与最初想的一样；
    //如果x为全1，a1是2，则不会干扰判断；
    //主要改善的点在与把x+1改为了x+a1
    //而a1是通过找到全1和最大数之间不同点入手构造的一个掩码。
    a = x + a1;
    b = ~(a ^ x);
    c = !b;
  return c;
}

//去掉中间变量，最终代码：
int judgeTMax(int x) {
  return !(~((x + (!(x + 1) + 1)) ^ x));
}

3.判断是否偶数位全1

要求：判断给定二进制补码的偶数位是不是全为1（从右向左数，从0开始计数的偶数位）
难度：3星
思路：
1.先构造出偶数位全为1，奇数位全为0的数0x55555555，构造方法为通过0x55，不断进行左移再加上原来的数。
2.进行判断时先将0x55555555和x进行与操作，使得x的奇数位全为0，偶数位保持不变，排除奇数位对判断的影响。
3.再将2中得到的数和0x55555555进行异或操作，如果x中存在偶数位不为1，则得到的结果中对应的位为1——不是全0；如果x满足条件，偶数位全1，则得到结果全0。进行！得到答案。

代码如下：

/* 3
 * allEvenBits_one - return 1 if all even-numbered bits in an integer are set to 1
 *   where bits are numbered from 0 (least significant) to 31 (most significant)
 *   Examples allEvenBits_one(0xFFFFFFFD) = 1, allEvenBits_one(0xA5555555) = 0
 *   Legal ops: ! ~ & ^ | + << >>
 *   Max ops: 12
 *   Rating: 2
 */
//便于理解版：
int allEvenBits_one(int x) {
    int a = 0x55,b,c,d,e,y;
    b = (a << 8);
    c = a + b;
    d = (c << 16);
    e = c + d;
    y = !((e & x)^e);
  return y;
}

//最终代码：
int allEvenBits_one(int x) {
    int a = ((0x55 << 8) + 0x55);
    mask = (a << 16) + a;
    return !((mask & x) ^ mask);
}

4.相反数运算

难度：1星
思路：求对应的相反数就是取反加1
代码入下：

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

5.判断给定的x是否满足条件0x30 <= x <= 0x39

难度：2星
思路：
观察0x30-0x39可以发现，0x30-0x37最后六位都是110xxx形式，后面三位数取任何值都落在该区间上；0x38和0x39则为11100x形式；
由于x取任何值都可以，故只需要对110和11100进行判断。
判断方法是移位然后异或。

代码如下：

/* 5
 * judgeAsciiDigit - return 1 if 0x30 <= x <= 0x39 (ASCII codes for characters '0' to '9')
 *   Example: judgeAsciiDigit(0x35) = 1.
 *            judgeAsciiDigit(0x3a) = 0.
 *            judgeAsciiDigit(0x05) = 0.
 *   Legal ops: ! ~ & ^ | + << >>
 *   Max ops: 15
 *   Rating: 3
 */
 //便于理解版：
int judgeAsciiDigit(int x) {
    int zerotoseven = !((x>>3) ^ 0x06);
    int eightandnine = !((x>>1) ^ 0x1c);
    int re = zerotoseven | eightandnine;
    return re;
}

//最终代码：
int judgeAsciiDigit(int x) {
    return (!((x>>3) ^ 0x06)) | (!((x>>1) ^ 0x1c));
}

6.条件运算符

目的：通过位运算实现条件运算符
难度：3星
思路：
需要构造一个掩码全0或全1，通过和y，z做与运算进行选择。
所以构造这样一个mask：当x == 0 时，mask为全1，将z选择出来；当x非0时，mask全0，用～mask将y选择出来。

/* 6
 * contitionExpr - same as x ? y : z 
 *   Example: contitionExpr(2,4,5) = 4
 *   Legal ops: ! ~ & ^ | + << >>
 *   Max ops: 16
 *   Rating: 3
 */
 //便于理解版：
int contitionExpr(int x, int y, int z) {
    int mask;
    mask = ~(!x) + 1;//当x == 0 时，mask为全1；当x非0时，mask全0；
    int re = (y & ~mask) + (z & mask);//当x == 0 时，mask为全1，将z选择出来；当x非0时，mask全0，～mask将y选择出来。
    return re;
}

//最终代码：
int contitionExpr(int x, int y, int z) {
    return  (y & ~(~(!x) + 1)) + (z & (~(!x) + 1));
}

7.逻辑非运算

目的：通过位运算实现逻辑非运算
难度：2星
思路：逻辑非运算主要用与判别0和非0，所以考虑0 和非0 的不同点。
x为0时，x = -x = 0，符号位均为0
x不为0时，除了0x80000000外其余的数均满足 x不等于-x
考虑0x800000000的特殊情况，此时满足 -x = x 但符号位均为1

所以当 x = -x 且符号位均为0时返回1，其余时候返回0；关键是判断符号位，最后的判断有利用前面第六题条件运算符的结果

/* 7
 * logicalNot - implement the ! operator, using all of 
 *              the legal operators except !
 *   Examples: logicalNot(3) = 0, logicalNot(0) = 1
 *   Legal ops: ~ & ^ | + << >>
 *   Max ops: 12
 *   Rating: 3 
 */
 //便于理解版：
int logicalNot(int x) {
    int a1,a2;
    a1 = (x >> 31);
    a2 = ((~x + 1) >> 31);
    //只有当x == 0时，a1和a2都是0，其余情况至少存在一个全1
    int a3 = a1|a2;//只有当x == 0时，a3是全0，其余情况全1
    int re = (0x01 & ~a3) + (0x00 & a3);//利用条件运算符的表达式
  return re;
}

//最终代码：
int logicalNot(int x) {
    int mask = (x >> 31)|((~x + 1) >> 31);
  return (0x01 & ~mask) + (0x00 & mask);
}

8.计算最少可以表达出x的二进制位数

难度：5星
思路：有两个难点，一个是需要找到负数和正数的统一处理方法，另一个是需要找到求出具体位数的简便方法（不能用循环）。

对于第一个难点：所有的负数取反之后都是正数（不加1），这样得到的正数的最少位数与原本负数的位数相同（可以通过验证得到，但是严谨的证明不是很清楚），所以可以将此问题转化为求正数的最小二进制位数。

对于第二个难点：通过类似二分法的方法解决。
下面只对其中第一步进行详细解释，剩下的可以类推：
1.用bit16 = !!(x >> 16) << 4来判断高16位是否有1。
2.因为!的优先级高于<<，所以先进行!!(x >> 16)。
3.由于都是对正数进行求解，所以在右移16位后，前16位全为0，后16位是原本的高16位。
4.如果高16位存在至少一位为1，则!(x>>16)为0则再进行一次!操作得到!!(x >> 16) = 1（0x00000001），否则!!(x >> 16) = 0x00000000
5.进行<<4的操作使得值变为0x00010000或者0x00000000，即16和0，目的是为了计数和下一步缩小判定范围。
6.如果高十六位为存在至少一位为1，则这个数至少有16位，接下来需要做的就是再进行进一步的定位来确定大于16位的部分还需要多少位，所以用x = x >> bit16;将x的低16位移走，将高16位移动到低16位的位置，对低16位（原本的高16位）进行判断
如果高16位中没有1，则继续对低16位进行判断，不用进行移位操作（bit16为全0）

以上就是第一步代码 bit16 = !!(x >> 16) << 4; x = x >> bit16; 的意思。

代码如下：

/* 8
 * leastBeats - return the minimum number of bits required to represent x in
 *             two's complement, remember the a bit of sign is needed.
 *  Examples: leastBeats(12) = 5 (most significant)
 *            leastBeats(298) = 10
 *            leastBeats(-5) = 4
 *            leastBeats(0)  = 1
 *            leastBeats(-1) = 1
 *            leastBeats(0x80000000) = 32
 *  Legal ops: ! ~ & ^ | + << >>
 *  Max ops: 90
 *  Rating: 4
 */
 //便于理解版：
int leastBeats(int x) {
    int sign,bit16,bit8,bit4,bit2,bit1,bit0,re;
    sign = x >> 31;//得到符号，如果符号位为0，sign全0，否则sign全1
    x = (x & ~sign) | ((~x) & sign);//将x统一变为对应（取反不加1）的正数
	//下面开始对x的位数进行判断计数
    bit16 = !!(x >> 16) << 4;//判断32位数中高16位是否有1。
    x = x >> bit16;
    bit8 = !!(x >> 8) << 3;//在低16位中判断高八位是否有1
    x = x >> bit8;
    bit4 = !!(x >> 4) << 2;//在低8位中判断高4位是否有1
    x = x >> bit4;
    bit2 = !!(x >> 2) << 1;//在低4位中判断高2位是否有1
    x = x >> bit2;
    bit1 = !!(x >> 1);//在低2位中判断高1位是否有1
    x = x >> bit1;
    bit0 = x; //判断最低位是否为1
    re = bit16 + bit8 + bit4 + bit2 + bit1 + bit0 + 1; // 正数需要符号位一位
  return re;
}

//最终代码也没啥变化（去掉了注释,bit0和re）
int leastBeats(int x) {
    int sign,bit16,bit8,bit4,bit2,bit1;
    sign = x >> 31;
    x = (x & ~sign) | ((~x) & sign);//将x统一变为正数来看
    bit16 = !!(x >> 16) << 4;//判断高16位是否有1
    x = x >> bit16;
    bit8 = !!(x >> 8) << 3;
    x = x >> bit8;
    bit4 = !!(x >> 4) << 2;
    x = x >> bit4;
    bit2 = !!(x >> 2) << 1;
    x = x >> bit2;
    bit1 = !!(x >> 1);
    x = x >> bit1;
  return bit16 + bit8 + bit4 + bit2 + bit1 + x + 1;
  }
  

9.判断1的总个数是否为奇数

难度：5星
思路：和有一个数字逻辑的表达也很相似，主要通过异或实现。
比如X = X1,X2,X3,X4是一个四位二进制数，则将X与X>>1异或之后得到的结果设为b1,b2,b3,b4,则的b4就存放的是X3和X4的奇偶性（奇数个1则b4 = 1），b2就存放的是X1和X2的奇偶性。奇数位无意义。

利用这个特性来求解，具体看代码：

/* 9
 * bitsOneOdd - return whether the number of 1 over all bits of an integer is odd or even
                if number is odd, return 1, else return 0
 * Examples: bitsOneOdd(1) = 1 0x01
 *           bitsOneOdd(2) = 1 0x10
 *           bitsOneOdd(3) = 0 0x11
 * Legal Ops: ! ~ & ^ << >>
 * MaxOps: 20
 * Rating: 4
 */
  //便于理解版：
int bitsOneOdd(int x){
    int a1,a2,a3,a4,a5,re;
    a1 = x ^ ( x >> 1 );
    //a1的偶数位存放着x中每两位的奇偶性
    a2 = a1 ^ ( a1 >> 2);
    //偶数位与偶数位相异或，a2中每四位中最低位得到a1中相邻偶数位的奇偶性
    a3 = a2 ^ ( a2 >> 4);
    //同理类推，a2中每四位中最低位与相邻的高四位中最低位相异或，a3中每8位中最低位得到a2中相邻每四位中最低位的奇偶性
    a4 = a3 ^ ( a3 >> 8);
    a5 = a4 ^ ( a4 >> 16);//最终最低位得到了x的奇偶性
    re = 0x01 & a5;//将其余位置0，取出最后一位作为结果，
  return re;
}

//最终代码去掉了re：
int bitsOneOdd(int x){
    int a1,a2,a3,a4,a5;
    a1 = x ^ ( x >> 1 );
    a2 = a1 ^ ( a1 >> 2);
    a3 = a2 ^ ( a2 >> 4);
    a4 = a3 ^ ( a3 >> 8);
    a5 = a4 ^ ( a4 >> 16);
  return 0x01 & a5;
}

---

整数运算

1.加法溢出判断

难度：2星
思路：负溢出就是两个负数相加变为0或者正数，正溢出就是两个正数相加变为负数。

具体代码如下：

/* 10
* plusFlow - return whether the sum of two integer x and y overflows(two's complement number)
* if overflow or underflow, return 1
* Examples: plusFlow(0xffffffff, 0x8000000)=1, plusFlow(1, 1)=0
* Legal Ops: + - ^ && || ! < > ==
* Maxops: 15
* Rating: 1
*/
int plusFlow(int x, int y){
    int sum = x + y;
    int neg_over = (x < 0 && y < 0) && (sum > 0 || sum == 0);
    int pos_over = (x > 0 && y > 0 && sum < 0);
    return neg_over ||  pos_over ;
}

2.减法溢出判断

难度：4星（其实感觉看起来不难，但当时做的时候好像不太行orz

具体代码如下：

/* 11
 * minusFlow - return whether the subtraction of two integer x and y overflows(two's complement number)
 * if overflow or underflow, return 1
 * Examples: minusFlow(0xffffffff, 0x80000000)=1, minusFlow(1, 2)=0
 * Legal Ops: + - ^ && || ! < > ==
 * Maxops: 15
 * Rating: 2
 */
int minusFlow(int x, int y){
    int sum = x - y;
    int over1 = (!(x < 0)) && y < 0 && ( sum < 0);
    int over2 = x < 0 && y > 0 && sum > 0;
    return over1 || over2;
}

3.乘法溢出判断

难度：5星（有最多10个符号限制）
思路：
已知满足x && mu/x == y （mu 是 x*y）就是不溢出，但是有一个特例就是0xffffffff, 0x80000000相乘时，是溢出的，但是判断会出错好像是会core dumped，直接报错（也是整数除法溢出的唯一一个情况）
所以需要用除法之外的其他判定条件来排除这种情况，也就是需要说清楚在这种情况下是溢出的；
这也导致不能从不溢出出发，而需要从什么情况会溢出出发来写代码。

/* 12
 * multiplyFlow - return whether the multiplication of two integer x and y overflows(two's complement number)
 * if overflow or underflow, return 1
 * Examples: multiplyFlow(0xffffffff, 0x80000000)=1, multiplyFlow(1, 2)=0
 * Legal Ops: * / ^ && || ! < > ==
 * Maxops: 10
 * Rating: 3
 */
//最开始版本，会出现报错floating point exception (core dumped)
int multiplyFlow(int x, int y){
    int mu = x*y;
    int re = (x && y && (mu/x != y ||  mu/y != x));
    return re;
}
 //改进版
int multiplyFlow(int x, int y){
    int mu = x*y;
    int re = (x < 0 && y < 0 && mu < 0) || (x && !(mu/x == y));// ||的先后顺序不能变，否则也会core dumped
    //因为是利用前面先排除了会dumped的情况，再进行除法
    return re;
}

//最终版：（后来减少一个符号）
int multiplyFlow(int x, int y){
    int mu = x*y;
    return ((x ^ y) > 0 && mu < 0) || (x && !(mu/x == y));
}

---

浮点数运算

1.计算2*f

难度：4星
思路：其实就是浮点数的运算，对各种情况分类处理然后进行合并就好。需要考虑到规格化数，非规格化数，0，NaN，Inf。
因为最开始对浮点数运算不够理解，参考了别的文章才写出来第一个，后来进行合并化简又参考了知乎专栏的文章

代码很清楚了，注释也挺详细，直接上代码：

/* 13
 * twoTimesFloat - 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: 3
 */
//最初版本：
unsigned twoTimesFloat(unsigned uf) {
   int S = uf & (1 << 31);//符号位
   int E = (uf >> 23) & 0xff;//阶码
   int mask = (1 << 23) - 1;//23个1
   int M = mask & uf;//尾数
   
   if((!E & (M == 0)) || (E == 0xff)) //0,NaN,无穷大的情况下返回自身
        return uf;
   if(!E) //非规格化数
   {
       M = (M << 1) & mask;
       if(1 & (M >> 22))//尾数最高位为1
           E += 1;
   }
   else//规格化数
   {
   		//判断阶码是否溢出
       if(E - 0xff == 0) //加1后阶码溢出，返回无穷大
       {
          M = 0;
          E = 0;
       }
       else
           E += 1;
   }
   E <<= 23;
   return S|E|M;
}

//改进/最终版：
unsigned twoTimesFloat(unsigned uf) {
    int E = (uf >> 23) & 0xFF;
    if (E == 0xFF)//NaN或Inf
      return uf;

    if (E == 0)//非规格化数或0
      return (uf << 1) | (uf & (1 << 31));
    
    return uf + (1 << 23); //正常计算，阶码+1，如果阶码溢出，返回Nan
}

2.将float转化为int

难度：4星
思路：主要分三种情况，超出范围的返回题目指定特殊值，不能表示的小数返回0，其余正常进行运算返回

具体看代码和注释：

/* 14
 * float2Int - 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 float2Int(unsigned uf) {
    int mask, EV, frac, i;
    mask = 1 << 31;//指定的特殊值，也有掩码作用，最后一步用于取符号
    EV = ((uf >> 23) & 0xFF) - 127;//计算出EV 阶（指数）

	//两种特殊情况
    if (EV > 31) //超出int表示范围，因为还有隐藏的1，所以是31不是32
      return mask;//返回指定的特殊值
    if (EV < 0)//小数无法用int表示，舍为0
      return 0;

    frac = (uf & 0x007fffff) | 0x00800000; //取出尾数，并且包括隐含的1
    i = (EV > 23) ? (frac << (EV - 23)) : (frac >> (23 - EV)); //求出int可以表示的整数值，即将阶的部分通过移位计算出来
    return (uf & mask) ? -i : i; //根据符号决定正负
}

3.求2.0的x次方

难度：3星
思路：按照阶的大小分类讨论，float中规格化数阶码最小为1（阶最小为-126），阶码最大为254，（阶最大为127）；
所以阶小于等于0时返回0；阶大于等于255时，返回INF
其余情况为正常阶码，可以正常表示

具体代码如下：

/* 15
 * twoPowerInt - 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 twoPowerInt(int x) {
    int E = x + 127;
    if (E <= 0)//为0 或者难以表示的非规格化数，返回0
        return 0;
    if (E >= 0xFF)//过大无法表示或者为INF和NaN，都返回+INF
        return (((1 << 10) - 1 ) << 23 ) - (1 << 31);
    return E << 23;//正常阶码，正常表示
}

---

参考文章

指路本次lab和笔记参考过觉得很不错的文章：
参考文章1
参考文章2

如果本文不错记得点个赞哦！谢谢阅读！