阿里巴巴笔试题-2011
2013-05-05 12:34
176 查看
1、有一个虚拟存储系统，若进程在内存中占3页（开始时内存为空），若采用先进先出（FIFO）页面淘汰算法，当执行如下访问页号序列后1，2，3，4，5,1，2，5，1，2，3，4，5，会发生多少缺页？
A、7 B、8 C、9 D、10
2、设有一个顺序栈S，元素s1、s2、s3、s4、s5、s6依次进栈，如果6个元素的出栈顺序为s2、s3、s4、s6、s5、s1，则顺序栈的容量至少应为多少？
A、2 B、3 C、4 D、5
3、下列关于文件索引结构的叙述中，哪一个是错误的？
A、采用索引结构，逻辑上连续的文件存放在连续的物理块中
B、系统为每个文件建立一张索引表
C、索引结构的优点是访问速度快，文件长度可以动态变化
D、索引结构的缺点是存储开销大
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】
5、某页式存储管理系统中，地址寄存器长度为24位，其中页号占14位，则主存的分块大小是（）字节。
A、10 B、2^10 C、2^14 D、2^24
6、在一个长为33厘米的光滑凹轨上，在第3厘米、第6厘米、第19厘米、第22厘米、第26厘米处各有一个钢珠，凹轨很细，不能同时通过两个钢珠，开始时，钢珠运动方向是任意的。两个钢珠相撞后，以相同速度反向运动。假设所有钢珠初始速度为每秒运动1厘米，那么所有钢珠离开凹轨的最长可能时间是（）
A、30 B、26 C、38 D、33
7、std::vector::iterator重载了下面哪些运算符？
A、++ B、>> C、*（前置） D、==
8、下列运算符，在C++语言中不能重载的是（）
A、* B、？： C、：： D、delete
9、在排序方法中，元素比较次数与元素的初始排列无关的是（）
A、Shell 排序 B、归并排序 C、直接插入排序 D、选择排序
A、C肯定不选的，归并排序的在merge中是跟序列有关，如果有序，比较次数最少n/2，最糟是元素错落n-1。而选择排序比较次数与关键字的初始状态无关，总的比较次数N=(n-1)+(n-2)+...+1=n*(n-1)/2。所以 应该是选择排序！
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、与编译器相关
10、给出以下定义，下列哪些操作是合法的？
const char *p1 = "hello";
char* const p2 = "world";
A、p1++ B、p1[2]='w'; C、p2[2]='l'; D、p2++
11、假设在n进制下，下面的等式成立，n值是（） 567*456=150216
A、9 B、10 C、12 D、18
假设是X进制，则567=7+6*X+5*X^2，456=6+5*X+4*X^2，所以564*456=（7+6*X+5*X^2）*（6+5*X+4*X^2）而150216=6+X+2*X^2+5*x^4+X^5，由于567*456=150216，则6+X+2*X^2+5*x^4+X^5=（7+6*X+5*X^2）*（6+5*X+4*X^2），最后解出来X=18
12、关于struct和class，下列说法正确的是（）
A、struct的成员默认是public，class的成员默认是private
B、struct不能继承，class可以继承
C、struct可以有无参构造函数
D、struct的成员变量只能是public
若不明确指定，来自class的继承按照private继承处理，来自struct的继承按照public继承处理；都可使用public/private/protected修饰符，都可以有无参构造函数
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)
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、以上选项都不正确
15、一个栈的输入序列为123.....n，若输出序列的第一个元素是n，输出第i（1<=i<=n）个元素是（）
A、不确定
B、n-i+1
C、i
D、n-i
16、下列代码编译时会产生错误的是（）
[cpp] view
plaincopy
#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
plaincopy
#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、非以上选项
18、下面描述中，错误的是（）
A、基类定义的public成员在公有继承的派生类中可见，也能在类外被访问
B、基类定义的public和protected成员在私有继承的派生类中可见，在类外可以被访问
C、基类定义的public和protected成员在保护继承的派生类中不可见
D、基类定义的protected成员在protected继承的派生类中可见，也能在类外被访问
19、当很频繁地对序列中部进行插入和删除操作时，应该选择使用的容器是（）
A、vector B、list C、deque D、stack
20、判断一个单向链表中是否存在环的最佳方法是（）
A、两重遍历 B、快慢指针 C、路径记录 D、哈希表辅助
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表示
22、下面代码的输出是多少？
[cpp] view
plaincopy
class A
{
public:
A() { cout<<"A"<<endl; }
~A() { cout<<"~A"<<endl; }
};
class B:public A
{
public:
B(A &a):_a(a)
{
cout<<"B"<<endl;
}
~B()
{
cout<<"~B"<<endl;
}
private:
A _a;
};
int main(void)
{
A a; //很简单，定义a的时候调用了一次构造函数
B b(a); //这里b里面的_a是通过成员初始化列表构造起来的
//而且是通过copy constructor构造的是b的成员对象_a的，这里是编译器默认的，因此在构造好_a前，先调用基类构造函数
//然后才是构造自身,顺序就是A()->_a->B()（局部）
//因此这里有两个A,一个B
//在return之前进行析构
/************************************************************************/
/*析构是按照定义对象的反顺序来的，而且同一个对象按照构造的反顺序来的，因此这里先
析构b然后才是a，那么b的构造顺序是上面的A()->_a->B()（局部），反过来，就是B()（局部）->_a->A()
因此得到的就是~B->~A->~A
在b之后就是析构a
最后结果就是
~B->~A->~A->~A*/
return 0;
}
23、一个骰子，6面，1个面是 1， 2个面是2， 3个面是3， 问平均掷多少次能使1、2、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
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)。
原文地址：点击打开链接
A、7 B、8 C、9 D、10
2、设有一个顺序栈S，元素s1、s2、s3、s4、s5、s6依次进栈，如果6个元素的出栈顺序为s2、s3、s4、s6、s5、s1，则顺序栈的容量至少应为多少？
A、2 B、3 C、4 D、5
3、下列关于文件索引结构的叙述中，哪一个是错误的？
A、采用索引结构，逻辑上连续的文件存放在连续的物理块中
B、系统为每个文件建立一张索引表
C、索引结构的优点是访问速度快，文件长度可以动态变化
D、索引结构的缺点是存储开销大
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】
5、某页式存储管理系统中，地址寄存器长度为24位，其中页号占14位，则主存的分块大小是（）字节。
A、10 B、2^10 C、2^14 D、2^24
6、在一个长为33厘米的光滑凹轨上，在第3厘米、第6厘米、第19厘米、第22厘米、第26厘米处各有一个钢珠，凹轨很细，不能同时通过两个钢珠，开始时，钢珠运动方向是任意的。两个钢珠相撞后，以相同速度反向运动。假设所有钢珠初始速度为每秒运动1厘米，那么所有钢珠离开凹轨的最长可能时间是（）
A、30 B、26 C、38 D、33
7、std::vector::iterator重载了下面哪些运算符？
A、++ B、>> C、*（前置） D、==
8、下列运算符，在C++语言中不能重载的是（）
A、* B、？： C、：： D、delete
9、在排序方法中，元素比较次数与元素的初始排列无关的是（）
A、Shell 排序 B、归并排序 C、直接插入排序 D、选择排序
A、C肯定不选的，归并排序的在merge中是跟序列有关，如果有序，比较次数最少n/2，最糟是元素错落n-1。而选择排序比较次数与关键字的初始状态无关，总的比较次数N=(n-1)+(n-2)+...+1=n*(n-1)/2。所以 应该是选择排序！
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、与编译器相关
10、给出以下定义，下列哪些操作是合法的？
const char *p1 = "hello";
char* const p2 = "world";
A、p1++ B、p1[2]='w'; C、p2[2]='l'; D、p2++
11、假设在n进制下，下面的等式成立，n值是（） 567*456=150216
A、9 B、10 C、12 D、18
假设是X进制，则567=7+6*X+5*X^2，456=6+5*X+4*X^2，所以564*456=（7+6*X+5*X^2）*（6+5*X+4*X^2）而150216=6+X+2*X^2+5*x^4+X^5，由于567*456=150216，则6+X+2*X^2+5*x^4+X^5=（7+6*X+5*X^2）*（6+5*X+4*X^2），最后解出来X=18
12、关于struct和class，下列说法正确的是（）
A、struct的成员默认是public，class的成员默认是private
B、struct不能继承，class可以继承
C、struct可以有无参构造函数
D、struct的成员变量只能是public
若不明确指定，来自class的继承按照private继承处理，来自struct的继承按照public继承处理；都可使用public/private/protected修饰符，都可以有无参构造函数
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)
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、以上选项都不正确
15、一个栈的输入序列为123.....n，若输出序列的第一个元素是n，输出第i（1<=i<=n）个元素是（）
A、不确定
B、n-i+1
C、i
D、n-i
16、下列代码编译时会产生错误的是（）
[cpp] view
plaincopy
#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
plaincopy
#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、非以上选项
18、下面描述中，错误的是（）
A、基类定义的public成员在公有继承的派生类中可见，也能在类外被访问
B、基类定义的public和protected成员在私有继承的派生类中可见，在类外可以被访问
C、基类定义的public和protected成员在保护继承的派生类中不可见
D、基类定义的protected成员在protected继承的派生类中可见，也能在类外被访问
19、当很频繁地对序列中部进行插入和删除操作时，应该选择使用的容器是（）
A、vector B、list C、deque D、stack
20、判断一个单向链表中是否存在环的最佳方法是（）
A、两重遍历 B、快慢指针 C、路径记录 D、哈希表辅助
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表示
22、下面代码的输出是多少？
[cpp] view
plaincopy
class A
{
public:
A() { cout<<"A"<<endl; }
~A() { cout<<"~A"<<endl; }
};
class B:public A
{
public:
B(A &a):_a(a)
{
cout<<"B"<<endl;
}
~B()
{
cout<<"~B"<<endl;
}
private:
A _a;
};
int main(void)
{
A a; //很简单，定义a的时候调用了一次构造函数
B b(a); //这里b里面的_a是通过成员初始化列表构造起来的
//而且是通过copy constructor构造的是b的成员对象_a的，这里是编译器默认的，因此在构造好_a前，先调用基类构造函数
//然后才是构造自身,顺序就是A()->_a->B()（局部）
//因此这里有两个A,一个B
//在return之前进行析构
/************************************************************************/
/*析构是按照定义对象的反顺序来的，而且同一个对象按照构造的反顺序来的，因此这里先
析构b然后才是a，那么b的构造顺序是上面的A()->_a->B()（局部），反过来，就是B()（局部）->_a->A()
因此得到的就是~B->~A->~A
在b之后就是析构a
最后结果就是
~B->~A->~A->~A*/
return 0;
}
23、一个骰子，6面，1个面是 1， 2个面是2， 3个面是3， 问平均掷多少次能使1、2、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
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)。
原文地址：点击打开链接
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- 阿里巴巴2011笔试题+答案解析
- 阿里巴巴2011笔试题+答案解析
- 阿里巴巴2011几道笔试题
- 阿里巴巴2011笔试题+答案解析
- 阿里巴巴2011数据分析师实习生笔试题
- 2011阿里巴巴实习生笔试题目
- 阿里巴巴2011笔试题+答案解析
- 阿里巴巴2011前端工程师笔试卷
- 阿里巴巴2011笔试题+答案解析
- 阿里巴巴2011笔试题
- 2011阿里巴巴实习生笔试题目
- 2014.3.29 阿里巴巴 实习校招 笔试 题目及部分参考答案
- 2016阿里巴巴测试开发实习笔试题
- 2013年阿里巴巴一道笔试题（大文件处理）
- 2012年阿里巴巴c++笔试
- 阿里巴巴笔试题
- 阿里巴巴笔试题 （2011年度）
- 2013年阿里巴巴暑期实习生笔试题--2013年5月5日考试
- 阿里巴巴2013笔试最后一题解答
- 2013年阿里巴巴实习生招聘笔试题目及解答