前天讲到要刚CSAPP,这一刚就是两天半.CSAPP果然够爽,自带完整的说明文档,评判程序,辅助程序.样例直接百万组走起,管饱!
datalab讲的是整数和浮点数怎么用二进制表示的,考验的是用基本只用位运算来实现一些看似稀松平常的操作.实际体会就是看题五秒钟,脱发两小时.当然做出来的成就感也是爆棚的.
求异或
根据离散数学等值演算写出公式
//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) {
return ~(~x&~y)&~(x&y);
}
求补码可表示的最小数
有且仅有最高位为1的数就是了
/*
* tmin - return minimum two's complement integer
* Legal ops: ! ~ & ^ | + << >>
* Max ops: 4
* Rating: 1
*/
int tmin(void) {
return (1<<31);
}
求补码可表示的最大数
这题开始需要一个技巧:!!x可以把非零数变成1,把0变成0
tmax=0x7FFFFFFF
tmax+1=0x10000000
(tmax+1)+(tmax+1)=0x00000000
C语言形式写作: x=tmin()-1
变形得 x+1=tmin()
a ^ b仅在每一位都相同时为假,则可取反用!(a ^ b)表示仅在每一位都相同时为1
最后额外排除0xFFFFFFFF
//2
/*
* 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) {
return !((x+1)+(x+1))&!!(x+1);
}
判断所有偶数位是否均为1
令y=1010...1010(二进制),即y==0xAAAAAAAA
运用<<和+来让0XAA重复四次得到该值
当且仅当x的任意偶数位都为1时返回1
即x存在偶数位为0时返回0
即结果为!(~x&0XAAAAAAAA)
/*
* 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 y=0xAA;
y=(y<<8)+y;
y=(y<<16)+y;
return !(~x&y);
}
求-x
根据公式直接写
/*
* negate - return -x
* Example: negate(1) = -1.
* Legal ops: ! ~ & ^ | + << >>
* Max ops: 5
* Rating: 2
*/
int negate(int x) {
return (~x+1);
}
判断是否为'0'~'9'
!(a^b)在当且仅当a与b任意一位都相同时为1,可以代替==
查表得规律:
00...011100X表示38~39
00...0110XXX表示30~37
故借助于<<分别判断之
//3
/*
* 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) {
return !((x>>1)^0x1C) | !((x>>3)^0x6);
}
实现x?y:z
假设存在操作@,
x=1时有x@y=y
x=0时有x@y=0
联想到&的性质可知
x=111...111(二进制)时x&y=y
x=000...000(二进制)时x&y=0
而111...111(二进制)=0XFFFFFFFF=-1
再根据前面求负数的题,~a+1=-a
/*
* 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) {
return ((~!!x+1)&y)|(~!x+1&z);
}
判断小于等于
直接求y-x在异号的时候会溢出
(x>>31)^(y>>31)判断xy符号位是否不同
sub=y-x=y+~x+1求差值
若同号,y-x<0时返回1
若异号,x<0时返回1
/*
* 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 sx=x>>31;
int sy=y>>31;
int diff=sx^sy;
int sub=(y+~x+1)>>31;
return ((!diff&!sub)|(diff&sx))&1;
/*
另一种方法:分x>=0?,y>=0?四种情况讨论
int xb=x>>31;
int xa=~xb;
int yb=y>>31;
int ya=~yb;
return (xa&((ya&!((y+~x+1)>>31))))|(xb&((ya&1)|(yb&!!((~y+x)>>31))));
*/
}
另一种思路:分x>=0?,y>=0?四种情况讨论
int isLessOrEqual(int x, int y) {
int xb=x>>31;
int xa=~xb;
int yb=y>>31;
int ya=~yb;
return (xa&((ya&!((y+~x+1)>>31))))|(xb&((ya&1)|(yb&!!((~y+x)>>31))));
}
实现!运算符
关键知识点:当且仅当x==0时,x与-x符号位相同,并且值为0
故判断~(-x|x)的符号位即可
//4
/*
* 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) {
return (~((~x+1)|x)>>31)&1;
}
另一种思路:我管这叫二分折叠
int logicalNeg(int x) {
int a=(x>>16)|x;
int b=(a>>8)|a;
int c=(b>>4)|b;
int d=(c>>2)|c;
int e=(d>>1)|d;
return (~e)&1;
}
判断位数
看Max ops知难度.
预处理:
把负数转换成它的~,使得正负数可用同一套操作
每个数都有一个符号位,所以计数器初始值为1
之后二分法:
判断高十六位是否为0,是的话把计数器加16,然后截取高十六位作为新的x;
否则节取低十六位作为新的x
判断高八位是否为0,是的话把计数器加8,然后截取高八位作为新的x;
否则节取低八位作为新的x
......
这个不断判断的过程可以借用前面x?y:z的代码,最后做一点点化简,防止超90ops
/* 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) {
int ret=0;
int h16,h8,h4,h2,h1;
int sign=(x>>31)&1;
x=((~!!sign+1)&(~x))|(~!sign+1&x);
ret=1;
h16=(x>>16);
ret+=((~!!h16+1)&16);
x=h16|(~!h16+1&((x<<16)>>16));
h8=x>>8;
ret+=((~!!h8+1)&8);
x=h8|(~!h8+1&((x<<8)>>8));
h4=x>>4;
ret+=((~!!h4+1)&4);
x=h4|(~!h4+1&((x<<4)>>4));
h2=x>>2;
ret+=((~!!h2+1)&2);
x=h2|(~!h2+1&((x<<2)>>2));
h1=x>>1;
ret+=((~!!h1+1)&1);
ret+=!!x;
return ret;
进一步化简后:
int howManyBits(int x) {
int b16,b8,b4,b2,b1;
int ret=0;
int sign=(x>>31);
x=(~sign&x)|(sign&~x);
ret=1+!!x;
b16=!!(x>>16)<<4;
x=x>>b16;
b8=!!(x>>8)<<3;
x=x>>b8;
b4=!!(x>>4)<<2;
x=x>>b4;
b2=!!(x>>2)<<1;
x=x>>b2;
b1=!!(x>>1);
return b16+b8+b4+b2+b1+ret;
}
求浮点数f*2
if-else解封了还有啥难得?分类讨论,一个坑点在于无符号数右移的时候是无符号右移
//float
/*
* 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) {
unsigned e=(uf<<1)>>24;
if(e==0xFF) return uf;
else if(e==0) return (uf<<1)+(uf&0x80000000);
else return uf+(1<<23);
}
float转int
注意了<<和>>都不能超过自身的范围,也不能用负数,否则可能发生不可预期的错误
/*
* 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) {
unsigned f=((uf<<11)>>11)+(1<<23);
unsigned e=(uf<<1)>>24;
int sign=(uf>>31)&1?-1:1;
int shift=e-127-23;
if(e==0xFF) return 0x80000000;
else if(e==0) return 0;
else{
if(shift<-23) return 0;
else if(shift>10) return 0x80000000;
else if(shift<0) return (f>>(-shift))*sign;
else return (f<<shift)*sign;
}
}
求2.0^x
这题我竟然超时了.原因是我是在移动硬盘上装得linux,而评判程序恰好时运行在本地的,这样子速度就慢了一截,结果就超时了.
/*
* 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) {
if(x<=-127) return 0;
if(x>=128) return 0x7f800000;
return (127+x)<<23;
}