奇虎360 2013校园招聘笔试题

转载自 http://blog.csdn.net/wanglongfei_hust/article/details/10041337

我的答案与解析：

1. D  2. C  3. B  4. A  5. D  6. C  7. A

8. C

我们可以把12个鸡蛋分成三堆，每堆4个。首先，我们命名那三堆分别叫A、B、C。

一、 如果A=B，表示坏的鸡蛋在C里面，我们命名C里面的四个鸡蛋分别为c1、c2、c3、c4。所以，如果想找到坏的鸡蛋，即先从C挑出两个（称其为c1、c2）出来秤。

1. 若c1=c2，即表示坏的鸡蛋在c3或c4中。

1）这时再挑出其中一个（假设为c3）与A或者B中的任意一个鸡蛋秤。

如果等重，即表示c4是坏鸡蛋；

若不等重，即表示c3是坏鸡蛋。

2. 若c1不等于c2，即表示这两个鸡蛋有一个是坏的。

2）这时挑c1与A或者B中的任意一个鸡蛋秤。

如果等重，即表示c2是坏鸡蛋；

如果不等重，即表示c1是坏鸡蛋。

二、 如果A不等于B，即表示坏鸡蛋在A或者B中。所以，我们可以先将A分成两堆，再进行秤。如果等重，表示坏鸡蛋在B中。如果不等重，表示坏鸡蛋在A中。如果要在3次成功找到坏鸡蛋，此时只有一次可以测量的机会了，且不知道坏鸡蛋的轻重，故怎么分是个重要的课题。

首先，将A、B分别标号为a1、a2、a3、a4，及b1、b2、b3、b4。

再来，假设A>B（B>A情况一样）。

1. 故若a1+a2+b1>a3+a4+b2，则有两种可能。

1）. a1+a2=a3+a4，而b1>b2，表示B含有坏鸡蛋且较轻，故b2是坏鸡蛋；

2）. a1+a2>a3+a4，而b1=b2，表示A中含有坏鸡蛋，且坏鸡蛋较重，故a1或a2中其中一个是坏鸡蛋。

因此要将a1和a2秤重，若等重，即表示b2是坏鸡蛋。若不等重，则较重者为坏鸡蛋。

2. 若a1+a2+b1=a3+a4+b2，即表示坏鸡蛋在B中且较轻。如此就只剩下b3和b4。再将b3和b4秤重，看哪个轻，即为坏鸡蛋。

总之，秤重3次，第一次秤重A和B，当A与B不相等时，第二次秤重a1+a2+b1与a3+a4+b2，当a1+a2+b1与a3+a4+b2不相等时，第三次秤重a1与a2.

9. B  10. A  11.C  12.A  13.C  14.B  15.D  18.D  21.B

22.D

堆都是动态分配内存的，没有静态分配内存的；栈有两种分配内存方式，动态和静态。

23.C  24.A  25.C

26.C

[cpp]  view plain copy

1. #include <iostream>  
2. using namespace std;  
3.   
4. int foo(int& nParam)  
5. {  
6.     nParam = 10;  
7.     return -1;  
8. }  
9.   
10. int main()  
11. {  
12.     int nTom = 0;  
13.     const unsigned int uJerry = 10;  
14.   
15.     nTom = foo(nTom);  
16.   
17.     while (nTom < uJerry)  
18.     {  
19.         nTom++;  
20.     }  
21.   
22.     if (nTom > uJerry)  
23.     {  
24.         nTom = 100;  
25.     }  
26.   
27.     if (nTom == uJerry)  
28.     {  
29.         nTom = 200;  
30.     }  
31.   
32.     cout<<nTom<<endl;   // 100  
33.     system("pause");  
34.     return 0;  
35. }  

27.A

[cpp]  view plain copy

1. #include <iostream>  
2. using namespace std;  
3.   
4. class Base  
5. {  
6. public:  
7.     Base()  
8.     {  
9.         printf("Base Ctor.");  
10.         foo();  
11.     }  
12.   
13.     ~Base()  
14.     {  
15.         printf("Base Dtor.");  
16.         foo();  
17.     }  
18.   
19.     virtual void foo()  
20.     {  
21.         printf("foo Base.");  
22.     }  
23. };  
24.   
25. class Derived : public Base  
26. {  
27. public:  
28.     Derived()  
29.     {  
30.         printf("Derived Ctor.");  
31.         foo();  
32.     }  
33.   
34.     ~Derived()  
35.     {  
36.         printf("Derived Dtor.");  
37.         foo();  
38.     }  
39.   
40.     virtual void foo()  
41.     {  
42.         printf("foo Derived.");  
43.     }  
44. };  
45.   
46. int main()  
47. {  
48.     Base *p = new Derived();  
49.   
50.     delete p;  
51.   
52.     printf("\n");  
53.     system("pause");  
54.     return 0;  
55. }  
56.   
57. // Base Ctor.foo Base.Derived Ctor.foo Derived.Base Dtor.foo Base.  

因为有delete操作，所以会调用析构函数；又因为析构函数不是虚函数，所以只调用基类的析构函数。

28.C  29.C

30.C

[cpp]  view plain copy

1. #include <iostream>  
2. using namespace std;  
3.   
4. unsigned short hash1(unsigned short key)  
5. {  
6.     return (key << 8 >> 8) % 256;  
7. }  
8.   
9. int main()  
10. {  
11.     unsigned short a = 16;  
12.     unsigned short b = 256;  
13.   
14.     cout<<hash1(a)<<endl;   // 16  
15.     cout<<hash1(b)<<endl;   // 0  
16.   
17.     system("pause");  
18.     return 0;  
19. }  

31.B

地址总线决定逻辑内存大小；

32.D

33.A

http://lakebroad.blogbus.com/logs/2218104.html

fork系统调用产生一个新的进程, 叫子进程, 是调用进程的一个复制品. 调用进程叫父进程, 子进程继承了父进程的几乎所有的属性:

. 实际UID,GID和有效UID,GID.
. 环境变量.
. 附加GID.
. 调用exec()时的关闭标志.
. UID设置模式比特位.
. GID设置模式比特位.
. 进程组号.
. 会话ID.
. 控制终端.
. 当前工作目录.
. 根目录.
. 文件创建掩码UMASK.
. 文件长度限制ULIMIT.
. 预定值, 如优先级和任何其他的进程预定参数, 根据种类不同决定是否可以继承.
. 还有一些其它属性.
但子进程也有与父进程不同的属性:
. 进程号, 子进程号不同与任何一个活动的进程组号.
. 父进程号.
. 子进程继承父进程的文件描述符或流时, 具有自己的一个拷贝并且与父进程和其它子进程共享该资源.
. 子进程的用户时间和系统时间被初始化为0.
. 子进程的超时时钟设置为0.
. 子进程不继承父进程的记录锁.
. pending signals 也不会被继承。 
linux下fork的实现是copy-on-write,也就是子进程与父进程初始时只有页表和task structure不同。

34.C  

当第一个fork返回父进程号的时候，后面那个fork会执行；当第一个fork返回子进程号的时候，后面那个fork不会执行。

35.没有正确答案，应该是6次缺页。  36.B  37.A  38.C  39.B  40.C  41.A  42.B  43.C  44.D  45.A