一些有意思的面试题

转自 http://blog.csdn.net/wangyuling1234567890/article/details/38565239

1、写一个高效C语言程序，计算一个无符号整数中1的个数。

[cpp]  view plain copy

1. for(count=0; x ; count++) x &= x-1;  
2. 同理，计算0的位数：  
3. for(count=32; x ; count--) x &= x-1;  

2、给定字符串S1和S2，写程序判断S2是否能由S1旋转而来，要求只能调用一次strstr系统函数。

[cpp]  view plain copy

1. void main()  
2. {  
3.     char *str1 = "wang";  
4.     char *str2 = "angw";  
5.   
6.     char *tmp = (char*)malloc(2*strlen(str1) + 1);  
7.     sprintf(tmp, "%s%s", str1, str1);  
8.   
9.     if (strstr(tmp, str2))  
10.         cout<<"yes"<<endl;  
11.   
12.     getchar();  
13. }  

3、IF条件中填入什么东西，能能让下面的程序打印出HelloWorld？

[cpp]  view plain copy

1. if(<condition>)            
2.     printf ("Hello");  
3. else  
4.     printf("World");  

[cpp]  view plain copy

1. if (!printf("Hello"))  
2.     printf("Hello");  
3. else  
4.     printf("World");  

4、只修改或添加一个字符，使下面的程序打印出20个*号。（至少有3种解法）

[cpp]  view plain copy

1. int main()  
2. {  
3.     int i, n = 20;  
4.     for (i = 0; i < n; i--)  
5.         printf("*");  
6.     return 0;  
7. }  

[cpp]  view plain copy

1. 解法1：  
2. intmain()  
3. {  
4.     inti,n=20;  
5.     for(i=0;i<n;n--)  
6.         printf("*");  
7.     return0;  
8. }  
9.   
10. 解法2：  
11. intmain()  
12. {  
13.     inti,n=20;  
14.     for(i=0;i<n;i++)  
15.         printf("*");  
16.     return0;  
17. }  

5、写一个算法，反转字符串中的单词顺序。

例如：Hi Welcome to cricode 反转成 cricode to Welcome Hi

[cpp]  view plain copy

1. void main()  
2. {  
3.     string str("Hi Welcome to cricode");  
4.     stack<char> cstack;  
5.     stack<char> tmp;  
6.     int index = 0;  
7.   
8.     for (index = 0; index < str.size(); index++)  
9.     {  
10.         cstack.push(str[index]);  
11.     }  
12.   
13.     index = 0;  
14.     while(!cstack.empty())  
15.     {  
16.         if (' ' == cstack.top())  //实验代码，未对标点符号做判断  
17.         {  
18.             while(!tmp.empty())  
19.             {  
20.                 str[index++] = tmp.top();  
21.                 tmp.pop();  
22.             }  
23.             str[index++] = ' ';  
24.             cstack.pop();  
25.         }  
26.         else  
27.         {  
28.             tmp.push(cstack.top());  
29.             cstack.pop();  
30.         }  
31.     }  
32.   
33.     while(!tmp.empty())  
34.     {  
35.         str[index++] = tmp.top();  
36.         tmp.pop();  
37.     }  
38.   
39.     cout<<str<<endl;  
40.     getchar();  
41. }  

6、100层楼，给你两个球，球的特性如下：如果你从这栋楼的某一小于X的楼层扔下这个球，球不会碎，如果你从大于等于X的楼层扔下，则球必定会碎。假设你能重复使用没有摔碎的球，请给定一个算法，用最少的扔球次数找出边界楼层X.

[cpp]  view plain copy

1. 如果是两个玻璃球，最少次数m确定楼高为N的哪一层开始能使这个玻璃球摔碎这个问题，等价于求最小的m，使得 1+2+...+m >= N 。  
2. 假设N正好等于1+2+...+m，那么我觉得最优的策略就是第一个玻璃球扔在第m层，如果碎了，显然需要剩下的m-1层从底往上一一尝试，最坏情况就是m；  
3. 假设m处没有碎，问题等价于楼高N'=1+2+...+(m-1)的地方同样的问题需要的次数m'+1 （1就是第一次在m层的尝试），  
4. 根据我们的递归，容易得到N'对应需要的次数正好是m-1次，因此总次数也是m。  
5.   
6. 我们的二分应该倾向于不管失败还是成功，两种情况的总检测次数相等。因此这应该是最优的算法。  
7.   
8. 当然，当N不能表示成1+2+...+m使，我们只能找最小的m作为需要测试的次数。  
9. 至于100层楼，显然m=14，我们的第一次扔球应该分别在第14, 如果没碎继续在14+13=27，再没有碎则扔在第27＋12＝39层，以此类推。  

7、A、B两座城市相距1000Km，我们有3000个香蕉要从A城市运往B城市，已知一头大象一次最多能运1000个香蕉，而且大象每次走1Km要吃掉一个香蕉，如果香蕉被吃完了，大象就不能再继续往前走。请问，你最终最多能运多少香蕉到B城市？

[cpp]  view plain copy

1. 1000米设置一个回头点，是不可行的。1000米设置两个回头点A，B，也就是将1000米分成3段。设每段长度为从起点到A点X1，A点到B点X2，B点到终点X3,  
2. X1+X2+X3=1000  
3. 在A点需要来回5次才能将3000的香蕉运到A点。那么A点有3000-5*X1的香蕉,  
4. 通过推理，3000-5*X1小于等于2000,  
5. 这样到B点 3000-5*X1-3*X2，这个值小于等于1000,  
6. 终点剩下3000-5*X1-3*X2-X3，根据上面的判断，如果都取等于的话:  
7. X1=200；X2=334  
8. 最终剩下532。  
9.   
10. 注：其实X2取333，这时候剩余533个，注意这种情况下需要丢弃一根香蕉。  

8、给你6跟等长的筷子，要求组成四个等边三角形，不允许折断或者弯曲筷子。

正四面体即可。

9、交换两个整形变量的值，不使用第三个变量

[cpp]  view plain copy

1. 解法1：  
2. 把两个整形数放到数轴上，如图（吐槽一下，博客中不能画图，真不方便，可以考虑增加简单画图的功能）：   
3. <span style="color:#000099;">-----<span style="color:#FF0000;">|</span>-------------<span style="color:#FF0000;">|</span>------></span>  
4.      a <span style="color:#FF0000;"><-- b-a --></span> b  
5.   
6. 于是有  
7. a=b-a  //a为a、b之间距离  
8. b=b-a  //b减去a、b之间距离，等于之前a的值  
9. a=b+a  //现在的b加上a、b之间距离，等于之前b的值  
10.   
11. 解法2：  
12. 根据异或运算符性质，a=a^b^b：  
13. a=a^b  //a' = a^b, b' = b  
14. b=b^a  //b' = a , a' = a^b  
15. a=b^a  //b' = a, a' = b  
16.   
17. 解法3：  
18. 指针运算，原理同1  

10、不使用比较运算符求两个数中较大者

还是数轴原理

#define max(a, b)  ( ( (a) + (b) + abs((a) - (b)) ) / 2 )

11、洗牌算法

解法1

a、定义一个54整数数组poker[54]，分别赋值1~54

b、生成两个随机数：m=rand()%54 + 1， n=rand()%54 + 1

c、交换pocker[m]与pocker[n]的值

d、重复b、c动作N次，N值越大越平均，但需要考虑效率。

解法2

使用集合，如vector或list

[cpp]  view plain copy

1. vector pocker;  //未洗牌的一幅扑克，顺序为1~54  
2. vector orderd;  //已洗牌的扑克集合，初始为空  
3.   
4. while(pocker.size())  
5. {  
6.     p = rand() % pocker.size();  
7.     orderd.push_back(pocker[p]);  
8.     pocker.erase(pocker.begin() + p);  
9. }  

12、有一根27厘米的细木杆，在第3厘米、7厘米、11厘米、17厘米、23厘米这五个位置上各有一只蚂蚁。木杆很细，不能同时通过两只蚂蚁。开始时，蚂蚁头朝向任意（左或右），它们只会朝前或掉头，不会后退。当任意两只蚂蚁碰头是，两只蚂蚁会同时调头朝反向走。假设蚂蚁每秒走1厘米，编写程序，求所有蚂蚁都离开木杆的最短时间和最长时间。(来自《编程之美》)

解法1

蛮力解法（brute force），枚举各蚂蚁的初始朝向，模拟每个蚂蚁的运动规律来解决。

解法2

考虑，虽然两只蚂蚁碰头后都掉头往相反的方向，但是，可以看作是是两只蚂蚁相遇后，擦肩而过了（看到这里的时候可能很多人就有一种恍然大悟的感觉了吧）。也就是说可以认为蚂蚁的运动独立的，是否有碰头并不是问题的中重点。
这样虽然每个蚂蚁的运动轨迹都与原来的不一样了。但是所有的蚂蚁离开木杆的最短的时间和最长时间是不变的。只需要分别计算每个蚂蚁离开木杆的时间，即可求出所有蚂蚁离开木杆的时间了。
这样，程序只需要遍历所有的蚂蚁，把每个蚂蚁走出木杆的最长时间(蚂蚁朝离自己较远的一端走去)，最短时间(蚂蚁朝离自己较近的一端走去)分别求出来，就算出最大值，这两个最大值就是所有蚂蚁离开木杆的最长时间和最短时间。