一山更比一山高，一海还比一海深。微软就够坑的了，全部多选，选错负分，少选还能得一半分；腾讯 60 分选择题(满分100分)，不选、少选、多选均是 0 分，O__O"…。me 们这些半瓶子表示鸭梨很大，有木有！
坐的很拥挤，监考不算严，但是不能自己带草稿纸，不能带走发的草稿纸，所以题目还么法带出来，不过只是理论上。下面基本按题目先后顺序给出题目的大致情况，非原题，O__O"…，记不住的选项就 ... 了吧。对了，20 个选择题，每道 3 分，总分 60 分；然后 7 个填空题， 10 个空，每空 4 分，40 分；满分 100 分。两道选做题，只选做一道，不计入总分。
先将就看下题目，围观一下，有些选项真的记不住了，有些慢慢补充，还有分析，me 表示有些鸭梨大。还是原来的思路，me 认为的正确答案标注为蓝色，me 选的答案，可能是错的，标注为红色。(题目处于更新中，所以，一段时间后可以刷新一下，O__O"…。)
- 32 位机上根据下面的代码，问哪些说法是正确的？
-
signed char a = 0xe0 ;
-
unsigned int b = a ;
-
unsigned char c = a ;
A. a>0 && c>0 为真 B. a == c 为真 C. b 的十六进制表示是：0xffffffe0 D. 上面都不对
分析：坑爹丫，有木有！10 个人 9 个这个恐怕都不敢确定！(敢肯定的要么是高手，要么就是错的！) B me 认为是错的，一个 uchar 和一个 schar 比较，真的就是一个字节在比较吗？C me 认为是对的，将一个 schar 赋值给一个 uint，要不要符号扩展呢？是绝对会还是可能会呢？细节到底是神马？O__O"…A 貌似比较确定，肯定是错的，肯定？
揭露真相：A 确实是错的，B 也是错的，C 是对的，所以 D 也是错的。理由？A 错是因为，a 是负数，c 是正数，即使跟 0 比较要转换到 int(后面暂不区分转换和类型提升，总之就是类型变了)，也是一负一正，所以 A 错。B 呢？是说一正一负不会相等，难道是因为这吗？难道不是吗？首先说 a 和 c 的二进制表示一模一样，都是 0xe0，那么比较就不相等？！是的，比较的时候全部转换为 int，所以呢，a 还是作为一个负数存在，c 作为一个正数存在，于是就不相等了，所以 B 错。C 肿么就对了？a 是一个 schar，赋值给 uint 的 b，前若干个字节不是补 0 吗？首先 schar 转换为 int，然后 int 转换成 uint，所以最初是符号扩展，然后一个 int 赋值给了 uint，C correct！me 曾经要写一篇关于c的类型以及指针的 blog，不过最后没有完成，不过还是可以参考一下的。 -
- 下面哪些选项能编译通过？
-
int i ;
-
char a [ 10 ] ;
-
string f ( ) ;
-
string g (string &str ) ;
A. if(!!i){f();} B. g(f()); C. a=a+1; D. g("abc");
分析：再次坑爹有木有！(其实 me 比较确信这道题，是坑别人的爹，O__O"…)A 绝对是正确的，C 绝对是错的，D 基本肯定是错的，那 B 呢？要么 error ，要嚒 warning！如果是 warning 但是没有 error ，这算神马情况呢？B 确实不应该选，至少语义上不该选！f() 返回一个临时量，然后传给 g 函数，而 g 的参数是非 const 引用，是不能引用临时量的！为嘛，如果 g 中修改了传进来的 string，那么会是怎么一回事呢？修改了一个临时量的值？那这意义何在呢？但是如果将 g 的原型修改为 string g(const string&); 就是可以的，为嘛可以？访问(只读)临时量就是正确的？那必须的，比如 u 可能想知道 a+b 的结果是多少，然后输出！a+b 的结果就是一个临时量。如果说修改 a+b 的结果，这是神马个逻辑？！
真相：C 错是因为 a 是一个地址常量，不可能再被赋值。D 为嘛错呢？"abc" 的类型可是 const char* 呢，是个常量指针呢！(可以用来初始化 string。)
-
- int a[10]; 问下面哪些不可以表示 a[1] 的地址？
A. a+sizeof(int) B. &a[0]+1 C. (int*)&a+1 D. (int*)((char*)&a+sizeof(int))
分析：奇葩丫！(其实并不奇葩！)腾讯的题目有时候出的的确有水平丫，虽然出的太有水平了 me 们的分就考不高了(%>_<%)。me 想哭丫，想来想去还是在 A 和 B 中选错了，%>_<%，当时还特意提醒自己来着的，O__O"…c++ 中的 sort 如何用来排序 a 数组呢？sort(a, a+N); 或是 sort(a, a+sizeof(a)/sizeof(a[0])); 当时懵了，实际上 a+1，就是 a[1] 的地址呢！a 的类型是 int[10]，a+1 和一个 int* 类型的 +1 效果一样，都表示偏移 1 个元素，所以 A (a+4)不能表示，表示的是 a[4] 的地址。(选错误的！) C 能表示是因为取了首地址作为一个 int* 然后 +1，就是偏移一个元素，所以不选。B 肿么说呢，me 一直以为 &a[0] 是一个普普通通的地址，+1 就是 +1个字节，实际上是 +1 个元素！D 也能表示？将 a 的首地址转换为一个 char* 指针，这个时候 +1 是偏移一个 char，也就是一个字节，实际上应该偏移 sizeof(int) 个字节才能到达 a[1]，所以 D 可以表示(不选)。不多说了。(如果是二维数组是不是会更懵呢，O__O"…)
- 问下面的数据都存放在哪些存储区？
-
int main ( )
-
{
-
char *p = "hello,world" ;
-
return 0 ;
-
}
A. ... B. ... C. 栈和常量区 D. 栈和堆
分析："hello,world" 是常量，赶脚应该就是 C 吧，应该大家感觉都一样。这里不涉及什么堆的事。
-
- 假设在一个 32 位 little endian 的机器上运行下面的程序，结果是多少？
-
#include <stdio.h>
-
int main ( )
-
{
-
long long a = 1, b = 2, c = 3 ;
-
printf ( "%d %d %d\n", a, b, c ) ;
-
return 0 ;
-
}
A. ... B. ... C. ... D. ...
分析：貌似问题没有想的那么简单。如果说运行结果，很简单，有人是 1 0 2；有人是 1 2 3。涉及到 little/big endian 和参数入栈的问题，me 表示现在有点无能为力，O__O"…。时过境迁有木有！如果说有标准答案的话，应该选择 1 0 2。(me 的童鞋和 me 在 vc++2012 上的结果都是 1 0 2，然而 me 的 g++4.8.0 竟然是 1 2 3。)现在就要说说 me “想当然”的结果。有人建议从汇编的角度来分析，me 不喜欢，me 认为一个实现的语言，可以透过表象是认识“本质”，me 想当然的时候，都会通过程序来验证“想当然”的正确，即使可能不是这样，也不会错的离谱。
洗澡的时候，me 在想，入栈是怎么样的？c 的 printf 又是如何处理的？以前已经见到过下面一些说法：c 的函数调用时从右到左求值，虽然不是绝对；printf 不检查第一个参数以后的参数类型，因为 c 语言是“弱检查”的语言，程序员认为第二个参数应该是 int，他就传个 int，他认为是 double，就传个 double，虽然格式符未必是 %d 和 %f。现在问题是，如果传一个 long long (8 个字节)进去，然后当做一个 int (4 个字节)，处理怎么样呢？看看一个程序的结果吧：
-
#include <stdio.h>
-
int main ( )
-
{
-
long long a = 0x1234567887654321 ;
-
printf ( "%x\n", a ) ; // 87654322
-
printf ( "%x %x\n", a ) ; // 87654321 12345678
-
-
return 0 ;
-
}
明眼一看，这是神马情况？！传进去 8 个字节 (long long) 的数据，可以当成两个 4 字节(unsigned int) 的数用！而且第一个 uint 是 8 个字节的低 4 个字节，后一个 uint 是高 4 个字节！其实 me 已经猜测了好几点：
- printf 的参数传递是从后往前传递，也就是 printf("%d %d %d", a, b, c); 是先传 c ，再传 b，其次 a，最后是格式化串 "%d %d %d"，这样有神马好处呢？！因为后面的参数是不确定的丫，如果先传格式化串，后面的参数不知道什么时候结束丫，有木有？！！如果从后向前传，最后一个传进去的就是格式化串。然后可以倒着看参数。
- 参数如果不检查类型的话，那就是原模原样传进去的，而不是截断传。若检查，它也没法判断确定类型丫！
- 关于 char 和 short，貌似类型要转换成 int，这不是 me 猜的，是以前一个地方看到的。(float 可能要转换成 double，这都意味着长度增加了有木有！)
还有一个问题是，字节顺序的问题，本来不打算在这里说的，因为 me 本来在第 21 题说了，不过换到这里说吧。介绍过之后，然后再来一个 demo，本题的结果就豁然开朗了。神马是字节顺序？一个 int 的变量 a，比如占 4 个字节，也就是 sizeof(int) == 4，me 们使用 &(取地址) 的时候取的是低地址呢，还是高地址呢？比如 int a = 0x12345678; 如果 &a 然后当做一个字节地址，比如 uchar* 看的话，输出 12 呢，还是 78 呢？下面来个程序瞧瞧：
-
#include<windows.h>
-
#include <stdio.h>
-
int main ( )
-
{
-
int a = 0x12345678 ;
-
char pch = * ( char * ) &a ;
-
printf ( "%x\n", pch ) ; // 78
-
-
a = htonl (a ) ;
-
pch = * ( char * ) &a ;
-
printf ( "%x\n", pch ) ; // 12
-
-
return 0 ;
-
}
上面第一个结果输入，就是上面问的问题，也就是输出低字节，maybe u 会问一定是 78 吗，可不可能是 12 ？可能！输出 78 的就叫做 little endian 字节顺序，输出 12 的就叫做 big endian 顺序。这样不好记，me 以前的记法：“低位低存，高位高存，就是 little endian；地位高存，高位低存，就是 big endian”。比如 0x12345678 低字节是 78 放在内存中的低地址上，12 放在高地址上就是 little endian；相反的就是 big endian。可以将内存看成是从左到右的地址增长的一条直线，下面有个图示：
int a = 0x12345678; ----------------------------------> 78 56 34 12 (little endian) 12 34 56 78 (big endian)
然后说，网络中在不同的计算机中传数据的时候，比如传一个 IPv4 的一个地址，32 位，192.168.1.111，话说，192 是放在一个低地址上呢，还是一个高地址上呢？总要统一吧，不然 me 是 little 传到一个 big 的电脑上，看到的 ip 可能就是 me 想表达的。好吧，标准的网络字节顺序，是并不流行的 big endian ！而 ntohl 就是将一个 32 位的主机整数转换成网络自己顺序的整数！如果转换前后数据是一样的，说明电脑就是 big endian；不一样，说明就是 little endian ！好吧，u 们应该看到了，me 的是 little endian !
现在可以解答本题了，看下下面的结果，应该就都明白了：
-
#include <stdio.h>
-
int main ( )
-
{
-
long long a = 1, b = 2, c = 3 ;
-
printf ( "%d %d %d %d %d %d %d\n", a, b, c ) ; // 1 0 2 0 3 0
-
return 0 ;
-
}
这里是给还不明白的人说的：printf 传进去 3 个 8字节的数据，如果表示应该是：0x 000000 00000001 + 00000000 0000002 + 00000000 00000003，u 认为这就是内存中的顺序码？内存中的数据布局如下：
--------------------------------------------------------------------------------------------> 01 00 00 00 00 00 00 00 02 00 00 00 00 00 00 00 03 00 00 00 00 00 00 00
上图中的，3 个 long long 数据，如果当成 6 个 int，结果不正是：1 0 2 0 3 0 吗？！
以上均是个人的猜测分析，有多少把握？实际一个编译器的实现是不是这样呢？至少 vc++ 是不是呢？用程序去验证自己的想法吧？！或是自己看汇编(me 表示没有看的想法)。还有就是，在 gcc 上，这样的思路是不对的，gcc 实现可能不是这样的！
深入猜测：上面有个隐含的东西，不清楚有木有注意到！从运行结果是 1 0 2 0 3 0 而不是 0 1 0 2 0 3 ，这能反映神马？已经是 little endian，这是明确的了，看看上面的图，如果果真是上面的图，是不是意味着，如果按参数的顺序来看，在栈中的位置是从低到高排列的呢？如果说后面的参数先入栈，是不是意味着，变量的分配栈的扩展方向是从高地址向低地址方向发展呢？如果一个函数中定义了两个连续的 int a,b; a 、 b 的地址关系，或是说大小是不是也是从高到低呢？看看程序吧：
-
#include <stdio.h>
-
-
void test ( int a, int b, int c ) ;
-
int main ( )
-
{
-
int x, y, z ;
-
printf ( "x:%p y:%p z:%p\n", &x, &y, &z ) ;
-
test ( 1, 2, 3 ) ;
-
return 0 ;
-
}
-
-
void test ( int a, int b, int c )
-
{
-
static int i = 0 ;
-
int x, y, z ;
-
-
printf ( "a:%p b:%p c:%p x:%p y:%p z:%p\n", &a, &b, &c, &x, &y, &z ) ;
-
++i ;
-
i < 3 ? test (i,i + 1,i + 2 ) : 0 ;
-
}
运行结果：
vs 2012: x:002BFBE8 y:002BFBDC z:002BFBD0 a:002BFAF4 b:002BFAF8 c:002BFAFC x:002BFAE0 y:002BFAD4 z:002BFAC8 a:002BF9EC b:002BF9F0 c:002BF9F4 x:002BF9D8 y:002BF9CC z:002BF9C0 a:002BF8E4 b:002BF8E8 c:002BF8EC x:002BF8D0 y:002BF8C4 z:002BF8B8 mingw-w64 gcc 4.8.0: x:000000000022FE5C y:000000000022FE58 z:000000000022FE54 a:000000000022FE30 b:000000000022FE38 c:000000000022FE40 x:000000000022FE1C y:000000000022FE18 z:000000000022FE14 a:000000000022FDD0 b:000000000022FDD8 c:000000000022FDE0 x:000000000022FDBC y:000000000022FDB8 z:000000000022FDB4 a:000000000022FD70 b:000000000022FD78 c:000000000022FD80 x:000000000022FD5C y:000000000022FD58 z:000000000022FD54
结果着实有点令人震惊！vs 上的地址是 32 位，而 gcc 的地址却是 64 位！这只是其一。其二，普通 int 变量 x、y、z 在 vs 中竟然间隔 12 个字节，而 gcc 只间隔 4 个字节，虽然 sizeof(int) == 4 这大家都一样！(在 gcc 上竟然提示 sizeof(int) 是 ull，unsigned long long 类型，vs 上没有任何提醒，甚至将 char ch=sizeof(int); 都没有任何提醒。sizeof(sizeof(int)) 是多少呢？vs 是 4，gcc 是 8 ！) 有点跑题了！第一行 a、b 和 c 的地址方向都是递增，和上面的猜测是相符的，如果按参数的逆序入栈的话，栈的发展方向是向低地址方向发展，而且 test 中的 x、y、z 都是如此！还有就是，第二行的 a、b 和 c 的地址都比前一行的低，也就是递归调用的栈帧发展也是在向低地址方向！现在问题是，如果是数组会怎么样呢？这个程序就不写勒，数组的首地址是 a，a+1 便是下一个元素的地址，也就是，数组中的元素是按地址增高的方向发展的！那这是不是有点奇怪呢？只能说以前的想法有问题呀！局按局部变量声明的顺序在栈中存储的话，是按地址向低的方向发展的，但是同一个数组的内部，a[0]、a[1]、a[2] 是按高地址方向发展的！
问题貌似还有一些，比如 vs 的相邻 int 是 12，为嘛呢？(数组中的 int 相差 sizeof(int) == 4这是已经确认过的。) 不过这不影响，参数传递的 int 还是 4 个！然而就是 gcc 中的 int 传递竟然是按 8 个字节进行的传递？是不是意味着，所有的整型传递都要扩展到 long long 呢？%d 实际是按 long long 输出呢？这样的话，gcc 的结果 1 2 3 貌似也顺利成章了丫！然后剩余另外一个比较大的问题，对齐问题！不过这里并不涉及。基本问题就以一个图+一个神奇的程序结束吧：
int x, a[10], y, z; ---------------------------------------> z y a[0] a[1] a[2] ... a[9] x (这只反映地址高低顺序，并不一定就是连续放置的，中间可能存在空隙；不过数组元素是连续的)
-
#include <stdio.h>
-
-
int main ( )
-
{
-
int i, a [ 11 ] ;
-
for (i = 0 ; i < 12 ; i ++ )
-
a [i ] = 0 ;
-
-
return 0 ;
-
}
上面这个简单的程序， 可以在 gcc 中运行一下，看看会发生神马神奇的效果！
-
- 下面哪些函数调用必须进入内核才能完成？
A. fopen B. exit C. memcpy D. strlen
分析：有些无能为力。A 是要打开文件的，貌似涉及很多内核操作；exit 是退出进程，结束进程，应该也要深入内核。memcpy ，me 一直犹豫用户区的数据拷贝要不要通过内核。strlen me 感觉关系不大。
- 内存管理中的 LRU 方法是用来管理神马的？
A. 虚拟内存的分配 B. 虚拟内存的释放 C. 物理内存的分配 D. 物理内存的释放
分析：貌似是用来管理物理块的，后面的填空题正好有说，O__O"…
- 关于DMA 的说法，哪些是错误的？
A. DMA，Direct Memory Acess 直接存储器访问，使得不同速度的硬件设备可以直接通信，不通过 CPU 干预；
B. DMA 访问的时候需要从 CPU 那里夺得总线控制权，然后...
C. DMA 速度快；
D. DMA 不需要中断控制，... - 死锁发生的必要条件？
A. 互斥条件 B. 请求和保持 C. 不可剥夺 D. 循环等待
分析：ABCD 就是死锁的四个必要条件，操作系统书上貌似说的很明确。
- 有两个线程，最初 n=0，一个线程执行 n++; n++; 另一个执行 n+=2; 问，最后可能的 n 值？
A. 1 B. 2 C. 3 D. 4
分析：D 顺序执行以下，就可以。B 的话，让后面一个执行到+2，但不要写结果，然后前一个执行完，然后写结果，为 2。C 3 的话，也好分析。A 不可能！肿么可能呢？肿么可能结果只为 1 呢？两个线程都会 +2，+1 何从谈起？先 +1，然后让后面的加法错了，然后结果写进去？前一个 ++n 都没执行的话，后一个又肿么会执行呢？总之不可能是 1 ！不可能！O__O"…(坚决不相信它可以。)
- 下面哪些说法正确？
A. 数组和链表都可以随机访问
B. 数组的插入和删除可以 O(1)
C. 哈希表么法范围检查
D. ...分析：总之 ABD 给人的感觉是显而易见的错丫，有木有，所以排除法还是能用的！至于 hash 结构，确实也不可以范围检查，因为 key 映射为 value，根据的是 hash 函数，而这个函数一般不满足原来的单调性，实际上就不应该满足！因为 hash 函数的设计是要 value 的映射尽可能滴随机、均匀！
- 基于比较的排序的时间复杂度下限是多少?
A. O(n) B. O(n^2) C. O(nlogn) D. ...
分析：貌似是数据结构上面的一个结论，基于比较的排序的时间复杂度不能比 O(nlogn) 低，而快速排序平均复杂度就是 O(nlogn)，而且常量系数更低一些。
- 下面图的拓扑排序可能是？
A...
分析：对于知道拓扑排序的，应该很容易作答(me 有时候在怀疑自己理解的是否正确？！)。
- 求 n 个数中的最大值和最小值，最少的比较次数是？
A. 4n/3 B. 2n-2 C. n-1 D. 3n/2
分析：虽然 me 不知道很高深的算法，但是 me 想丫，如果是 2 1 3 4 5 6 这样的序列，u 认为最少是多少次呢？me 感觉是 n-1 。但是，题目也许是另外一个意思，也就是对于普通的序列，求最大值和最小值，能将比较次数降到多少？(me 貌似见到过一些方法，但是忘了，O__O"…)
- 一棵二叉树的先序遍历是 f b a c d e g h，中序遍历是 a b d c e f g h，问后序遍历是神马？
A. ... B. ... C. ... D. ...
分析：构建二叉树，然后看看后序遍历是神马？a d e c b h g f，O__O"…，突然感觉一不小心 g f 和 f g 就写反了，me 应该没有吧？！
- 网卡、交换机、路由器和 UDP 分别工作网络的哪些层？
A. ...
B. ...
C. ...
D. ....分析：只根据 UDP 在传输层，me 就选出答案了：物理层、数据链路层、网络层和传输层。
- 子网掩码 25..255.255.224 可以将网络 x.x.x.x 分成多少个子网？
A. ... B. ... C. 8 D. 32
分析：224 = 128+64+32 = 1110 0000 B，me 一看，后面 5 个 0 ，就是 2^5 = 32 吧？shit ！子网数？不是主机数丫，有没有，O__O"…，主机数貌似还得 -2 丫，有没有，当时 me 还奇怪来着，O__O"… x.x.x.x 貌似是个 C 类地址？这样的话，应该是 2 ^ 3 = 8 ！
- TCP协议栈的定时器有哪些？
A. ... B. ... C. ... D. ...
分析：不会的路过。
- 高内聚和低耦合，下面哪个耦合度最高？
A. 通过函数参数传递...
B. 一个函数修改另外一个函数中的数据；
C. 通过全局变量...
D. 通过指示器...分析：哭丫，me 错了。这是软件工程上的玩意，me 一直认为 C 比 B 耦合度高呢，O__O"…。耦合度由低到高：A --> D --> C -->B
- 关于访问 http://ilovers-drupal.stor.sinaapp.com/public/field/image/000631.jpg ，下面哪些是后台绝对不会执行的？
A. 本地查查 DNS，是否有 sinaapp.com 的 ip；
B. 通过 cn. 查找 ip；
C. 通过 com. 查找 ip；
D. 浏览器发送 http get 请求；
D. 服务器回送 xxx.jpg；分析：蒙也是蒙 B，O__O"…
- 在一个 big endian 的 32 位的计算机上，b 的结果是？(该处 1 个空)
-
unsigned int a = 0x1234 ;
-
char b = * ( ( char * ) &a ) ;
分析：想不到又一个 big/little endian 的问题。这个结果，me 还比较确定写，就是 0。uint 是 4 个字节，0x1234 的完整表示是 0x 00 00 12 34，因为是 big endian，所以，所以 &(取地址) 的话，如果当字节看的话，取到了最左边 00 字节的地址，一定要转换成 char 看的话，值就是 0 。
-
- 一个有 800 个结点的完全二叉树，问有多少个叶子结点？(该处 1 个空)
分析：虽然 me 忘记是神马公式计算了，只感觉和 n/2 有关系。然后随便画了几个试试，就可以找出来 (n+1)/2 的规律来，所以 答案是： 400。
- 下面 get 是求一个二维数组元素的函数，请补全。( 1 个空)
-
#include <stdio.h>
-
#include <stdlib.h>
-
#define M 3
-
#define N 4
-
-
int get ( int *a, int i, int j )
-
{
-
int v ;
-
if (a == NULL || i < 0 || i >=M || j < 0 || j >=N ) exit ( 1 ) ; //
-
-
v = * (a +i *N +j ) ; // 这里有一个空
-
return v ;
-
}
-
int main ( )
-
{
-
int a [M ] [N ] = { { 1, 2, 3, 4 }, { 5, 6, 7, 8 }, { 9, 10, 11, 12 } } ;
-
int v ;
-
-
v = get (a, 2, 1 ) ;
-
printf ( "a[2][1] == %d\n", v ) ;
-
return 0 ;
-
}
分析：差点写错了，还好迷途知返了，O__O"…
-
- 补全插入排序：(有 2 个空)
-
#include <stdio.h>
-
#include <stdlib.h>
-
-
int insert_sort ( int *p, int count )
-
{
-
int i, j, tmp ;
-
if (p == NULL || count < 0 ) return 0 ; //
-
-
for (i = 1 ; i <count ; i ++ ) {
-
tmp = p [i ] ;
-
j = i - 1 ;
-
while (j >= 0 && p [j ] >tmp ) { // 此处判断条件一个空
-
p [j + 1 ] = p [j ] ;
-
--j ;
-
}
-
p [j + 1 ] = tmp ; // 此处一个空
-
}
-
return 1 ;
-
}
-
int main ( )
-
{
-
int i, a [ 10 ] = { 3, 2, 1, 7, 8, 10, 4, 5, 6, 9 } ;
-
-
insert_sort (a, 10 ) ;
-
for (i = 0 ; i < 10 ; i ++ )
-
printf ( "%d ", a [i ] ) ;
-
printf ( "\n" ) ;
-
-
return 0 ;
-
}
分析：me 感觉 me 的代码还是比较工整的，u 肿么看，...
-
- 使用 FIFO 管理页面请求，如果分配的物理块 M = 3 或是 4，请求顺序如下：4 3 2 1 4 3 5 4 5 3 1 2 5 1 5 1 5 5 4，问两种情况下页面失效的次数各是多少？( 2 个空)
分析：7 和 7，这是 me 的结果(貌似错了？O__O"…)。现在是确信，自己错了，答案是 10 和 11，me 没有加上来就没有命中的 3/4 次，虽然没有页面替换，但是确实属于页面失效的情况。每空 4 分，两个 8 分，me 还有神马好说的呢，O__O"…(大哭ing...)。
下面给出计算结果，如果没有命中，就打一个 x，然后写上页面的值，~~~~(>_<)~~~~
M = 3 (从上往下，从左往右看)：10 次 x4 x1 x5 x4 x3 x4 x1 x2 x3 x2 M = 4 (从上往下，从左往右看)：11 次 x4 x5 x1 x3 x4 x5 x2 x3 x4 x1 x2
- 一个网络图，问 Q 路由器到某个网络要进行跳转的下一个 ip 是多少？(有 1 个空)
分析：me 一下子就犹豫了，貌似赶脚也不是正确答案，就不多说了。
- 软件可靠性评估的两个指标是神马？( 2 个空)
分析：不会的路过。
- 选做 1：qq 用户有 30 亿，每日的登陆、登出的记录条数有 100 亿之多，让设计程序统计每天登陆人数；设计程序剔除因为掉线而重复登陆的情况；设计程序求出在线人数最高的时刻。
- 选做 2：问 qq 的加好友功能可能存在的安全漏洞有哪些？
771
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
