腾讯笔试题

一山更比一山高，一海还比一海深。微软就够坑的了，全部多选，选错负分，少选还能得一半分；腾讯 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 的加好友功能可能存在的安全漏洞有哪些？

文章转载自:http://ilovers.sinaapp.com/article-type/%E7%AC%94%E8%AF%95%E9%9D%A2%E8%AF%95