笔试题摘录

4、【0、2、1、4、3、9、5、8、6、7】是以数组形式存储的最小堆，删除堆顶元素0后的结果是（）
A、【2、1、4、3、9、5、8、6、7】
B、【1、2、5、4、3、9、8、6、7】
C、【2、3、1、4、7、9、5、8、6】
D、【1、2、5、4、3、9、7、8、6】

阿里的一道题，最小堆删除。要将0一直迭代的和最后一个元素交换。

 

8、下列运算符，在C++语言中不能重载的是（）
A、*                        B、？：                    C、：：                           D、delete

c++不能重载的运算符：？：     ：：   .*   sizeof

 

10、给定如下代码： int x[4]={0}; int y[4]={1}; 数组x和y的值为（）
A、{0，0，0，0}，{1，1，1，1}
B、{0，0，0，0}，{1，0，0，0}
C、{0，不确定}，{1，不确定}
D、与编译器相关

 

13、定义一个函数指针，指向的函数有两个int形参并且返回一个函数指针，返回的指针指向一个有一个int形参且返回int的函数？
A、int (*(*F)(int, int))(int)
B、int (*F)(int, int)
C、int (*(*F)(int, int))
D、*(*F)(int, int)(int)

对这道题的理解：首先定义返回指针，如：int (*f)(int),然后将f替换为(*F)(int,int);即可。

int fun(int a){
    return a;
}
int (*(*f)(int,int))(int);
int (*fun2(int a,int b))(int){
    int c=a+b;
    cout<<"c:"<<c<<endl;
    return fun;
}
int main()
{
    f=fun2;
    int (*pf)(int)=f(2,3);
    cout<<pf(55)<<endl;

}

 

14、声明一个指向含有10个元素的数组的指针，其中每个元素是一个函数指针，该函数的返回值是int，参数是int*，正确的是（）
A、（int *p[10]）（int*）;
B、int [10]*p（int *）;
C、int (*(*p)[10])(int *);
D、int ((int *)[10])*p;
E、以上选项都不正确

注意是指向10个元素的数组指针: (*p)[10]，函数的返回值是int，参数是int*：int (*f)(int*);将前面的替换掉后面的f就好了.

对这个题的一个理解：

int f1(int* p){
    return *p;
}
int f2(int* p){
    return *p;
}

int main()
{
   int (*(*f)[2])(int *);//定义了一个指针。
  int (*ff[2])(int*)={f1,f2};//定义了一个指向两个函数的数组并且初始化
  int a=3;
  f=&ff;
   cout<< (*f)[0](&a)<<endl;

}

 

 

16、下列代码编译时会产生错误的是（）

[cpp] view plain copy print ?

1. #include <iostream>   
2. using namespace std;  
3. struct Foo  
4. {  
5.     Foo() {  }  
6.     Foo(int) {  }  
7.     void fun()   {  }  
8. };  
9. int main(void)  
10. {  
11.     Foo a(10);    //语句1   
12.     a.fun();      //语句2   
13.     Foo b();      //语句3   
14.     b.fun();      //语句4   
15.     return 0;  
16. }  

#include <iostream>
using namespace std;
struct Foo
{
	Foo() {  }
	Foo(int) {  }
	void fun()   {  }
};
int main(void)
{
	Foo a(10);    //语句1
	a.fun();      //语句2
	Foo b();      //语句3
	b.fun();      //语句4
	return 0;
}

A、语句1             B、语句2           C、语句3             D、语句4        

 

 

17、在32位机器上，下列代码中

[cpp] view plain copy print ?

1. #pragma pack(2)   
2. class A  
3. {  
4.     int i;  
5.     union U  
6.     {  
7.         char buff[13];  
8.         int i;  
9.     }u;  
10.     void foo() {    }  
11.     typedef char* (*f)(void*);  
12.     enum{red, green, blue} color;  
13. }a;  

#pragma pack(2)
class A
{
	int i;
	union U
	{
		char buff[13];
		int i;
	}u;
	void foo() {    }
	typedef char* (*f)(void*);
	enum{red, green, blue} color;
}a;

sizeof(a)的值是（）

A、20       B、21       C、22        D、24           E、非以上选项

//比较好的一个题

 

21、给你1、2、3 这三个数字 可以使用C的各种运算符 你能表示的最大的整数是（）

A、2*3*sizeof(1)             B、3<<(2<<sizeof(1))                    C、sizeof(3)<<(sizeof(2)<<(sizeof(1)))                    D、(unsigned long)(2-3)*1

-1的二进制形式就是全1表示

2. class A  
3. {  
4. public:  
5.     A()  {    cout<<"A"<<endl;    }  
6.     ~A() {    cout<<"~A"<<endl;   }  
7. };  
8.   
9. class B:public A  
10. {  
11. public:  
12.     B(A &a):_a(a)  
13.     {  
14.         cout<<"B"<<endl;  
15.     }  
16.     ~B()  
17.     {  
18.         cout<<"~B"<<endl;  
19.     }  
20. private:  
21.     A _a;  
22. };  
23.   
24. int main(void)  
25. {  
26.     A a;       //很简单，定义a的时候调用了一次构造函数  
27.     B b(a);    
28. }

结果：

AAB ~B ~A ~A ~A

 

23、一个骰子，6面，1个面是 1， 2个面是2， 3个面是3， 问平均掷多少次能使1、2、3都至少出现一次！

 

题目：一个骰子，6面，1个面是 1， 2个面是2， 3个面是3，问平均掷多少次能使1、2、3都至少出现一次。

解：（没学过《组合数学》的请略过）

设P（N=n）表示第n次（n>2）抛出后1，2，3都出现的概率，问题要求n的期望E(N=n).掷1的概率p=1/6,掷2的概率q=1/3,掷3的概率r=1/2.

写程序求解

#include <iostream>

[cpp] view plain copy print ?

1. using namespace std;  
2. float f(float x)  
3. {  
4.    return (1/(1-x)/(1-x)-1-2*x);  
5. }  
6.   
7. int main()  
8. {  
9.    float p=1.0/6,q=1.0/3,r=1.0/2,e;  
10.    e=r*(f(p+q)-f(p)-f(q))+p*(f(q+r)-f(q)-f(r))+q*(f(p+r)-f(p)-f(r));  
11.    cout<<e<<endl;  
12.    return 0;  
13. }  

using namespace std;
float f(float x)
{
   return (1/(1-x)/(1-x)-1-2*x);
}

int main()
{
   float p=1.0/6,q=1.0/3,r=1.0/2,e;
   e=r*(f(p+q)-f(p)-f(q))+p*(f(q+r)-f(q)-f(r))+q*(f(p+r)-f(p)-f(r));
   cout<<e<<endl;
   return 0;
}

在Visual Studio下的运行结果为：7.3

24、一个有趣的抛硬币问题
假设有一个硬币，抛出字（背面）和花（正面）的概率都是0.5，而且每次抛硬币与前次结果无关。现在做一个游戏，连续地抛这个硬币，直到连续出现两次字为止，问平均要抛多少次才能结束游戏？注意，一旦连续抛出两个“字”向上游戏就结束了，不用继续抛。
上面这个题目我第一次见到是在pongba的TopLanguage的一次讨论上，提出问题的人为Shuo Chen，当时我给出了一个解法，自认为已经相当简单了，先来考虑一下抛硬币的过程：首先先抛一枚硬币，如果是花，那么需要重头开始；如果是字，那么再抛一枚硬币，新抛的这枚如果也是字，则游戏结束，如果是花，那么又需要重头开始。根据这个过程，设抛硬币的期望次数为T，可以得到关系：
　　T = 1 + 0.5T + 0.5( 1 + 0.5 * 0 + 0.5T)
解方程可得到 T = 6。
或者根据公式，需要连续抛出n个字的一般情形，结果相当简洁：Tn = 2^(n+1) - 2，其中Tn为首次出现连续的n个字的期望投掷数。
参考链接    http://www.cnblogs.com/atyuwen/archive/2010/09/12/coin.html

CA点击打开链接

25、问题描述：
12个高矮不同的人，排成两排，每排必须是从矮到高排列，而且第二排比对应的第一排的人高，问排列方式有多少种?
这个笔试题，很YD，因为把某个递归关系隐藏得很深。

问题分析:
我们先把这12个人从低到高排列，然后，选择6个人排在第一排，那么剩下的6个肯定是在第二排。
用0表示对应的人在第一排，用1表示对应的人在第二排，那么含有6个0，6个1的序列，就对应一种方案。
比如000000111111就对应着
第一排:0 1 2 3 4 5
第二排:6 7 8 9 10 11
010101010101就对应着
第一排:0 2 4 6 8 10
第二排:1 3 5 7 9 11
问题转换为，这样的满足条件的01序列有多少个。
观察1的出现，我们考虑这一个出现能不能放在第二排，显然，在这个1之前出现的那些0，1对应的人
要么是在这个1左边，要么是在这个1前面。而肯定要有一个0的，在这个1前面，统计在这个1之前的0和1的个数。
也就是要求，0的个数大于1的个数。
OK，问题已经解决.
如果把0看成入栈操作，1看成出栈操作，就是说给定6个元素，合法的入栈出栈序列有多少个。
这就是catalan数，这里只是用于栈，等价地描述还有，二叉树的枚举，多边形分成三角形的个数，圆括弧插入公式中的方法数，其通项是c(2n, n)/(n+1)。