腾讯实习生招聘笔试题目.docx

腾讯实习生招聘笔试题目.docx

《腾讯实习生招聘笔试题目.docx》由会员分享，可在线阅读，更多相关《腾讯实习生招聘笔试题目.docx（18页珍藏版）》请在冰豆网上搜索。

腾讯实习生招聘笔试题目

下面是我在参加2013年腾讯实习生招聘的笔试题目，当然啦，我个人不可能是完全的记住所有题目，部分是摘自网络的。

同时，下面也有一些题目我不会的，希望大家一起商量解决给以答案，谢谢。

选择题

32位机上根据下面的代码，问哪些说法是正确的？

（）

signedchara=0xe0;

unsignedintb=a;

unsignedcharc=a;

A.a>0&&c>0为真

B.a==c为真

C.b的十六进制表示是：

0xffffffe0

D.上面都不对

答案：

C

考点：

有符号数和无符号数之间的转换

解析：

∙将0xe0转换成二进制是11100000，因为0xe0的最高位是1，所以作为有符号数的时候就是负数，作为无符号数的时候就是正数，因此A选项是错的，同时B也是错误的。

∙负数的高位用1补齐，正数的高位用0补齐，所以b（0xe0）的二进制表示形式是11111111111111111111111111100000，十六进制的表示形式是0xffffffe0。

下面哪些选项能编译通过？

inti;

chara[10];

stringf（）;

stringg（string&str）;

A.if（!

!

i）{f（）;}

B.g（f（））;

C.a=a+1;

D.g（"abc"）;

答案：

A

考点：

C++的细节掌握。

解析：

∙A是肯定对的，因为他有一个默认值。

∙B选项是错误的。

因为f（）返回的是一个临时量，然后传给g函数，而g的参数不是const引用，是不能引用临时量的。

∙C选项是错误的。

因为a是一个地址常量，不可能再被赋值。

∙D选项是错误的。

因为"abc"的类型可是constchar*呢，是个常量指针（可以用来初始化string）。

（对这题我有点疑问，因为我不是学C++的，所以希望读者看到可以帮我解答一下，谢谢）

inta[10];问下面哪些不可以表示a[1]的地址？

A.a+sizeof（int）

B.&a[0]+1

C.（int*）&a+1

D.（int*）（（char*）&a+sizeof（int））

答案：

A

考点：

C++数组的指针表示形式的掌握

解析：

∙A.a+sizeof（int） 选项不正确，假设在32位机器上，sizeof（int）的值为4，而a+sizeof（int） 相当于指针运算a+4，也就是a[4]

∙B.&a[0]+1选项正确，因为 &a[0]的意思是取的数组首元素地址，而数组首元素地址加1（a+1），根据指针运算就是a[1]的地址

∙C.（int*）&a+1选项正确，因为数组地址被强制类型转换为int*，然后加1，这样和B表示的一个意思

∙D.（int*）（（char*）&a+sizeof（int））选项正确，因为数据地址先被转换为char*，然后加4，根据指针运算公式，向前移动4*sizeof（char），之后被转换为int*，显然是a[1]的地址

问下面的数据都存放在哪些存储区？

intmain（）

{

char*p="hello,world";

return0;

}

A.堆和静态数据区

B.栈和静态数据区

C.栈和常量区

D.栈和堆

答案：

C

解析：

其实，在做这一题的时候，我是当成Java来做的，呵呵

∙根据C语言中的特性和定义p是一个局部变量，而C语言中局部变量存在于栈中，"hellowrold"是一个字符串字面常量，因此存储于程序的只读存储区中，p在这里其实只是指向了"hellowrold"在只读存储区中的地址而已

4）下面哪些说法正确？

（）

A.数组和链表都可以随机访问

B.数组的插入和删除可以O

（1）

C.哈希表没有办法做范围检查

D.以上说法都不正确

答案：

B

解析：

∙A选项是错误的，因为数组可以直接通过下标得到存储的值因此支持随机；而访问链表是链式存储结构时无法支持随机访问，要访问一个指定位置的元素必须从头开始做指针移动

∙B选项是正确的，因为数组的插入如果位置在最后面的话可以为O

（1），删除的时候，直接通过下标指定要删除哪个即可，所以也可以为O

（1）

∙C选项是错误的，因为哈希表支持直接通过关键码得到值其实数组就是一种哈希表下标就是关键码通过下标直接得到值因此哈希表肯定需要做范围检查也有办法做范围检查的

∙D选项是错误的，这个不用解释啦，哈哈^_^

基于比较的排序的时间复杂度下限是多少?

（）

A.O（n）

B.O（n^2）

C.O（nlogn）

D.O

（1）

答案:

C

解析：

其实大家记住这个结论就好，在当前计算机科学界对于基于比较的排序最快只是O（n*logn），例如快速排序，堆排序，归并排序

有两个线程，最初n=0，一个线程执行n++;n++;另一个执行n+=2;问，最后可能的n值？

（）

A.1

B.2

C.3

D.4

答案：

BCD

解析：

大家要知道C语言中的++和+=并不是原子操作，而是通过多条微程序组成的，因此++和+=在执行过程中可能被中断的

∙第一种可能情况：

现在假设两个线程没有并行顺序执行的那么结果显然是4。

∙第二种可能情况：

再假设现在第一个n++已经执行完了 但是结果还没有写回内存这个时候n+=2已经全部执行完2写进了内存结束然后回到n++的写回操作这个时候内存就从2被改回1了，后面再来一次n++ 结果就为2。

∙第三种可能情况：

第n+=2先读取n的值到寄存器即0入寄存器这个时候被中断  第一个n++开始执行并直到结束内存被改成了1，然后n+=2继续执行结束后内存变为2 第二个n++再执行结果就是3了

∙我个人看了网上的这个解析后也觉得，肯定不可能为1了。

下面哪些函数调用必须进入内核才能完成？

（）

A.fopen

B.exit

C.memcpy

D.strlen

答案：

 AB

解析:

∙fopen是打开文件的函数,文件也可以看成是一个设备,打开一个设备将导致给设备所属的驱动程序发送一个IRP,而与真实硬件相关的驱动程序都运行于内核

∙exit函数是结束进程的函数,结束进程需要访问PCB（进程控制块）和TCB（线程控制块）等等一些数据结构,而这些数据都存在于内核中

∙memcpy 和 strlen 我们可以直接不调用任意函数写出来这种函数肯定不会实现在内核的

∙关于memcpy函数，详情可以查看XX百科的解释（地址是：

死锁发生的必要条件？

（）

A.互斥条件

B.请求和保持

C.不可剥夺

D.循环等待

答案:

ABCD

考点：

操作系统，刚刚学，好兴奋这题当时做的，一秒钟都不用瞬间选择了【偷笑】

解析：

互斥条件，请求和保持，不可剥夺 ，循环等待，这些都可能导致发生死锁，所以以后大家在做多线程程序时一定要注意了。

内存管理中的LRU方法是用来管理什么的？

（）

A.虚拟内存的分配

B.虚拟内存的释放

C.物理内存的分配

D.物理内存的释放

答案：

AD

考点:

操作系统

解析：

今天下午认真看了下课本，温故了下知识，关于这题，得出以下几个解释，详细的我就不说啦，大家自己看书，我大概说下基本的。

1.页面调入：

是给页面调入内存中，给它分配物理内存

2.页面置换，就是将内存中的页面置换出来，放到虚拟内存中，让物理内存空闲出来，让给需要使用的页面。

3.LRU：

全称是：

LeastRecentlyUsed（最近最久未使用）置换算法，所以这个算法涉及到了虚拟内存的分配和物理内存的释放。

所以答案是AD。

求N个数中的最大值和最小值，最小比较次数是多少？

A4n/3

B2n-2

Cn-1

D3n/2

答案：

D

解析：

在一本书上看过，利用分治思想,评论中有@LPopo提供的不用分治法实现的代码，在九楼。

在此表示感谢。

一棵二叉树的先序遍历是fbacdegh，中序遍历是abdcefgh，问后序遍历是什么

答案：

adecbhgf

解析：

根据先序遍历和中序遍历，我们可以构建一颗二叉树：

在32位littleendian机器上运行该程序，得到结果是什么？

#include

intmain（）

{

longlonga=1,b=2,c=3;

printf（"%d%d%d\n",a,b,c）;

return0;

}

A.123

B102

C......

D321

答案：

B

解析：

因为longlong是8个字节的，%d是4个字节的，溢出覆盖了后面，然后又是小端规则的。

【传入参数，由右往左，栈空间内存从高往低，little endian, 栈空间如下:

内存高位->

00000000       00000011

00000000      [00000010]（c）

[00000000]（b） [00000001]（a）

<-内存低位

因此printf会按照4bytes取参数.】来自

关于访问，下面哪些是后台绝对不会执行的？

A.本地查查DNS，是否有的ip；

B.通过cn.查找ip；

C.通过com.查找ip；

D.浏览器发送httpget请求；

E.服务器回送xxx.jpg；

答案：

。

。

。

不会，我当时蒙的，好像选的是E。

。

。

解析：

不会，自然解析不了。

。

。

高内聚和低耦合，下面哪个耦合度最高？

A.通过函数参数传递...

B.一个函数修改另外一个函数中的数据；

C.通过全局变量...

D.通过指示器...

答案：

网上说答案是C,我也不是很清楚。

。

解析：

∙内聚就是一个模块内各个元素彼此结合的紧密程度，高内聚就是一个模块内各个元素彼此结合的紧密程度高。

所谓高内聚是指一个软件模块是由相关性很强的代码组成，只负责一项任务，也就是常说的单一责任原则。

∙耦合：

一个软件结构内不同模块之间互连程度的度量（耦合性也叫块间联系。

指软件系统结构中各模块间相互联系紧密程度的一种度量。

模块之间联系越紧密，其耦合性就越强，模块的独立性则越差，模块间耦合的高低取决于模块间接口的复杂性，调用的方式以及传递的信息。

）对于低耦合，粗浅的理解是：

一个完整的系统，模块与模块之间，尽可能的使其独立存在。

也就是说，让每个模块，尽可能的独立完成某个特定的子功能。

模块与模块之间的接口，尽量的少而简单。

如果某两个模块间的关系比较复杂的话，最好首先考虑进一步的模块划分。

这样有利于修改和组合.

TCP协议栈的定时器有哪些（）

A....

B....

C....

D....

答案：

忘记选项了，网上也找不到，大家知道有考这个知识点就好啦。

。

。

解析：

XX了一下，TCP协议栈的定时器有延时定时器，重传定时器，坚持定时器，保活定时器

网卡，交换机，路由器和UDP分别工作网络的哪些层？

答案：

依次是：

物理层，链路层，传输层

填空题

在一个bigendian的32位的计算机上，b的结果是______

unsignedinta=0x1234;

charb=*（（char*）&a）;

答案：

0

解析：

unsignedint是4个字节，0x1234的完整表示是0x00001234，因为是bigendian，所以，所以&（取地址）的话，如果当字节看的话，取到了最左边00字节的地址，一定要转换成char看的话，值就是0。

一个有800个结点的完全二叉树，问有_____个叶子结点？

答案：

400

解析：

画图举例子很容易就可以推导出规律，通过这个公式即可计算得400

下面get是求一个二维数组元素的函数，请补全.

#include

#include

#defineM3

#defineN4

intget（int*a,inti,intj）

{

_______//此处一个空

}

intmain（）

{

inta[M][N]={{1,2,3,4},{5,6,7,8},{9,10,11,12}};

intv;

v=get（a,2,1）;

printf（"a[2][1]==%d\n",v）;

return0;

}

答案：

return*（a+i*N+j）;

解析：

大家注意原型中的指针是int* a，所以必须用二维数组在内存中是一维排布这个知识点来做，直接 return *（a+i*N+j）;而不是return*（*（a+i）+j）;

补全插入排序：

#include

#include

intinsert_sort（int*p,intcount）

{

inti,j,tmp;

if（p==NULL||count<0）return0;//

for（i=1;i

tmp=p[i;

j=i-1;

while（__________）{//此处一个空

p[j+1]=p[j];

--j;

}

___________;//此处一个空

}

return1;

}

intmain（）

{

inti,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"）;

return0;

}

答案：

第一个空：

 j>=0&&p[j>tmp 第二个空：

p[j+1] =tmp;

解析：

看看数据结构的课本就有啦，呵呵

使用FIFO管理页面请求，如果分配的物理块M=3或是4，请求顺序如下：

43244354531515154，问两种情况下页面失效的次数各是________和__________？

答案：

首先感谢@ LPopo的解答，答案是9和6，

考点：

操作系统

解析：

M=3时：

一开始是空的，所以4,3,2都页面失效。

失效三次，然后4,4,3都有效，5失效一次，4先进来的所以先出去，变为3,2,5，然后4又失效一次，3出去，变为2,5,4，以此类推。

就是先进来的先出去。

最后加起来一共9次。

M=4的也一样。

只是能多存一个页。

软件可靠性评估的两个指标是___________和_____________？

 答案：

不会。

。

。

参考网站：

CodingLife的专栏：

lyj103862095的专栏：

XX文库：

32位机上根据下面的代码，问哪些说法是正确的？

signedchara=0xe0;

unsignedintb=a;

unsignedcharc=a;

A.a>0&&c>0为真B.a==c为真C.b的十六进制表示是：

0xffffffe0D.上面都不对

分析：

坑爹丫，有木有！

10个人9个这个恐怕都不敢确定！

（敢肯定的要么是高手，要么就是错的！

）Bme认为是错的，一个uchar和一个schar比较，真的就是一个字节在比较吗？

Cme认为是对的，将一个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，Ccorrect！

me曾经要写一篇关于c的类型以及指针的blog，不过最后没有完成，不过还是可以参考一下的。

下面哪些选项能编译通过？

inti;

chara[10;

stringf（）;

stringg（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的原型修改为stringg（conststring&）;就是可以的，为么可以？

访问（只读）临时量就是正确的？

那必须的，比如u可能想知道a+b的结果是多少，然后输出！

a+b的结果就是一个临时量。

如果说修改a+b的结果，这是神马个逻辑？

！

真相：

C错是以为a是一个地址常量，不可能再被赋值。

D为嘛错呢？

"abc"的类型可是constchar*呢，是个常量指针呢！

（可以用来初始化string。

）

inta[10];问下面哪些不可以表示a[1]的地址？

A.a+sizeof（int）B.&a[0]+1C.（int*）&a+1D.（int*）（（char*）&a+sizeof（int））

分析：

奇葩丫！

（其实并不奇葩！

）腾讯的题目有时候出的的确有水平丫，虽然出的太有水平了分就考不高了。

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不能表示。

（选错误的！

）C能表示是因为取了首地址作为一个int*然后+1，就是偏移一个元素，所以不选。

B肿么说呢，me一直一位&a[0]是一个普普通通的地址，+1就是+1个字节，实际上是+1个元素！

D也能表示？

将a的首地址转换为一个char*指针，这个时候+1是偏移一个char，也就是一个字节，实际上应该偏移sizeof（int）个字节才能到达a[1]，所以D可以表示（不选）。

不多说了。

（如果是二维数组是不是会更懵呢，O__O"…）a可以看做一个constint*,a++是不行的，不能自增。

’+’重载

问下面的数据都存放在哪些存储区？

intmain（）

{

char*p="hello,world";

return0;

}

A....B....C.栈和常量区D.栈和堆

分析：

"hello,world"是常量，赶脚应该就是C吧，应该大家感觉都一样。

这里不涉及什么堆的事。

假设在一个32位littleendian的机器上运行下面的程序，结果是多少？

#include

intmain（）

{

longlonga=1,b=2,c=3;

printf（"%d%d%d\n",a,b,c）;

return0;

}

A....B....C....D....

分析：

貌似问题没有想的那么简单。

如果说运行结果，很简单，有人是102；有人是123。

涉及到little/bigendian和参数入栈的问题，me表示现在有点无能为力，O__O"…

下面哪些函数调用必须进入内核才能完成？

A.fopenB.exitC.memcpyD.strlen

分析：

有些无能为力。

A是要打开文件的，貌似设计很多内核操作丫；exit是退出进程，结束进程，应该也要深入内核。

memcpy，me一直犹豫用户区的数据拷贝要不要通过内核。

strlenme感觉关系不大。

内存管理中的LRU方法是用来管理神马的？

A.虚拟内存的分配B.虚拟内存的释放C.物理内存的分配D.物理内存的释放

分析：

貌似是用来关系物理块的，后面的填空题正好有说，O__O"…（扫描LRU链表释放最近最少使用的内存）

关于DMA的说法，哪些是错误的？

A.DMA，DirectMemoryAcess直接存储器访问，使得不同的速度的硬件设备可以直接通信，不通过CPU干预；

B.DMA访问的时候需要从CPU那里夺得总线控制权，然后...

C.DMA速度快；

D.DMA不需要中断控制，CPU管理不要它；

允许不同速度的硬件装置来沟通，而不需要依于 CPU 的大量 中断 负载在实现DMA传输时，是由DMA控制器直接掌管总线，因此，存在着一个总线控制权转移问题。

即DMA传输前，CPU要把总线控制权交给DMA控制器，而在结束DMA传输后，DMA控制器应立即把总线控制权再交回给CPU。

由此可见，DMA传输方式无需CPU直接控制传输，也没有中断处理方式那样保留现场和恢复现场的过程，通过硬件为RAM与I/O设备开辟一条直接传送数据的通路，使CPU的效率大为提高。

死锁发生的必要条件？

A.互斥条件B.请求和保持C.不可剥夺D.循环等待

分析：

ABCD就是死锁的四个必要条件，操作系统书上貌似说的很明确。

有两个线程，最初n=0，一个线程执行n++;n