2013年微软校园招聘笔试题

总共20道选择题  1个小时15分钟

1.       数据库

基于某个条件选出一个订单列表，考的是最基本的数据库语言select * from * where *

2.       不能用于进程间通信的是

A.      Named event

B.      Named pipe

C.      Critical section

D.      Shared memory

答案C

http://blog.csdn.net/wonderwander6642/article/details/8008241

3. shallow copying （浅拷贝）的特征

英文太烂不知道shallow copying怎么翻译不敢选

4.       Functional programming(函数式编程)的特点

完全不了解functional programing

见http://www.ruanyifeng.com/blog/2012/04/functional_programming.html

考了”没有副作用”，“不修改状态”，“引用透明”引用透明的概念类似于可重入

Lisp语言《黑客与画家》很赞的一本书

5.       以下算法用到贪婪算法的是

A.      Dijkstra

B.      Prim

C.      Kruskali

D.Floyd- Warshall

E.       KMP string match

ABC

6.       1,2,3,…1000 一共出现了多少个0

A.      189

B.      191

C.      193

D.      195

算出来是192个可是没有这个答案估计题目出错了应该是从0~1000

7.       T(x)=1 (x<=1), T(n)=25*T(n/5)+n^2 求T(n)的时间复杂度

A.      O(n*log(n))

B.      O(log(n))

C.      O(n^2*log(n))

D.      O(n^3*log(n))

T(n)=25*(25*T(n/25)+(n/5)^2)+n^2=25^2*T(n/(5^2))+2*n^2=25^(log(n)/log5)+(log(n)/log5)*n^2=O(n^2*log(n))

8.       下列属于设计模式中 ”creational” pattern 的是？

A.      Facade

B.      Singleton

C.      Bridge

D.      Composite

没有看过设计模式答案是B 见http://en.wikipedia.org/wiki/Design_Patterns#Creational

Facade composite bridge 都属于Structural

9.       建立一个TCP连接的过程？

三次握手http://baike.baidu.com/view/1003841.htm

答案中好像没有SYN，SYN+ACK，ACK我选的是SYN，SYN+ACK，SYN+ACK

莫非是题目看错了

10.   二叉树的pre-order traversal为abcdefg，则它的in-order traversal可能是？

A.abcdefg

B.gfedcba

C.efgdcba（不特别确定，类似）

D.bceadfg

E.bcdaefg

ABCE

以前序遍历abc为例，只有三个节点，中序遍历可能是cba, bca, bac, abc, acb

11.   15个球放在4个袋子中，每个袋子至少有一个球且每个袋子中球的数目不同，总共有多少种放法？

A.      4

B.      5

C.      6

D.      7

E.       None of above

a)       1 2 3 9

b)       1 2 4 8

c)       1 2 5 7

d)       1 3 4 7

e)       1 3 5 6

f)        2 3 4 6

共6种

不知道除了枚举有没有别的更好的办法

12.   给了4个函数，可以看出其中第一个为选择排序，第二个为冒泡排序第三个感觉代码本身就有些问题第四个为快速排序

问哪一个排序能将数组a={(3,4),(6,5),(2,7),(3,1),(1,2) }变为{(1,2), ,(2,7), (3,1),( 3,4),(6,5)}

只比较第一个元素。

Stuct A{

Int key1;

Int key2;

};

比较函数为 int cmp(A x, A y) {return x.key1-y.key1;)

选择排序, 此题代码是选择的最小出列。选出最小的与前面的交换，其条件是cmp<0, 显然第一趟(3,4)与(1,2)交换后到了(3,1)的后面然后是(6,5)与(2,7)交换，其条件是cmp<0,所以(6,5)与(3,1 )交换，最后的输出结果满足题目要求

冒泡排序 其条件是cmp<0,显然(3,4)不可能会与(3,1)交换，因此不符合题目要求

快速排序时不稳定排序，不能保证谁在谁前面，快排的条件是cmp<=0且其哨兵都是选择序列中的第一个作为哨兵，结合本题所给的数组a，结果是与题目相符

13.   继承，虚函数

下面程序输出结果

#include <iostream>

using namespace std;

class Base

{

public:

    char Value() {  return 'A';}

    virtual char VirtualValue() {return 'X';}

};

class Derived:public Base

{

public:

    char Value(){return'U';}

};

class VirtualDerived:virtualpublic Base

{

public:

    char Value() {  return 'Z';}

    char VirtualValue() {return 'V';}

};

void main()

{

Base *p1=new Derived();

Base *p2=new VirtualDerived();

cout<<p1->Value()<<" "<<

    p1->VirtualValue()<<" "<<

    p2->Value()<<" "<<

    p2->VirtualValue()<<endl;

}

#include <iostream>

using namespace std;

class Base

{

public:

    char Value() { return 'A';}

    virtual char VirtualValue() { return 'X';}

};

class Derived:public Base

{

public:

    char Value(){return'U';}

};

class VirtualDerived:virtualpublic Base

{

public:

    char Value() { return 'Z';}

    char VirtualValue() { return 'V';}

};

void main()

{

Base *p1=new Derived();

Base *p2=new VirtualDerived();

cout<<p1->Value()<<" "<<

    p1->VirtualValue()<<" "<<

    p2->Value()<<" "<<

    p2->VirtualValue()<<endl;

}

AXAV

14.   两个线程 thread1: x=1;r1=y; thread2:y=1;r2=x; x和y初始值为0，两者皆为全局变量，程序运行过后r1和r2的值可能是

A.      r1=1,r2=1

B.      r1=1,r2=0

C.      r1=0,r2=1

D.      r1=0,r2=0

ABC

15.   A，B，C，D都为32位整型，基于以下给定的C，D能否得出A，B

A.      C=A+B,D=A-B

B.      C=A+2*B,D=A+B

C.      C=A+B,D=B

D.    C=A-B,D=(A+B)>>1

E.     C=A*B,D=A/B

BC

答案C该题主要是考虑越界问题

对于A选项假设A>0,B>0;C可能越界使得C=A+B-2^32举个反例：A=B=2^31-1 C=-2,D=0;

A=B=-1,C=-2,D=0

对于C选项不管C是否越界总能得到A=C-D, B=D

对于B选项我们可以考虑Q=A+B, C=Q+B ,D=Q跟C的那个一样，就能求出Q与B Q=A+B，B又已知A可求

D选项：A=B=-1 A=B=2^31-1

E选项：A=B=2^15, A=B=2^31

16.   BNF

很简单的一个题目

17.   http协议

18. 不属于栈的基本操作

A.pop,

B.push,

C.if empty,

D.sort

D

19.一颗完全二叉树有n个节点，求深度

A.lg(n)/lg2,

B.1+lg(n)/lg2,

B