2013年阿里巴巴暑期实习生笔试题--2013年5月5日考试

一、单项选择题

1.下列说法错误的是：

A.SATA硬盘的速度大约为500Mbps/s

B.读取18XDVD光盘数据的速度为1Gbps

C.千兆以太网的数据读取速度为1Gpbs

D.读取DDR3内存数据的速度为100Gbps

分析：A和B相比，怎么光盘的速度比硬盘还快？B必错无疑啊。千兆以太网的速度是1000Mbps，也可以写成1Gbps。DDR3-1600的极限传输速度是12.8GBp/s

2.（）不能用于Linux中的进程通信

A.共享内存

B.命名管道

C.信号量

D.临界区

分析：Linux中的进程通信方式有：管道，消息队列，共享内存，套接字Socket。而信号量是在多线程环境下使用的一种设施，是可以用来保证两个或多个关键代码段不被并发调用，也应用于进程通信中。临界区指的是一个访问共用资源（例如：共用设备或是共用存储器）的程序片段，而这些共用资源又无法同时被多个线程访问的特性，不能用于进程通信。

3.设在内存中有P1,P2,P3三道程序，并按照P1,P2,P3的优先级次序运行，其中内部计算和IO操作时间由下表给出（CPU计算和IO资源都只能同时由一个程序占用）：

P1:计算60ms---》IO 80ms---》计算20ms

P2:计算120ms---》IO 40ms---》计算40ms

P3:计算40ms---》IO 80ms---》计算40ms

完成三道程序比单道运行节省的时间是（）

A.80ms

B.120ms

C.160ms

D.200ms

解析：画个图，分别计算单道运行和三道程序的时间。单道运行=520ms三道程序=360ms，所以后者比前者节省520-360=160ms。

4.两个等价线程并发的执行下列程序，a为全局变量，初始为0，假设printf、++、--操作都是原子性的，则输出不可能是（）

 

[cpp] view plaincopyprint?
  1. void foo() { 
  2.     if(a <= 0) { 
  3.         a++; 
  4.     } 
  5.     else{ 
  6.         a--; 
  7.     } 
  8.     printf("%d", a); 
  9. } 

A.01

B.10

C.12

D.22

解析：又是一题多线程同步判断计算结果的题目，阿里很喜欢考这种题目。。。注意printf、++、--操作都是原子性，有些题目没有说明就不是原子性的。

详见http://blog.csdn.net/kangroger/article/details/37606283。

5.给定fun函数如下，那么fun(10)的输出结果是（）

 

[cpp] view plaincopyprint?
  1. int fun(intx) 
  2. { 
  3.     return(x==1)? 1 : (x + fun(x-1)); 
  4. } 

A.0

B.10

C.55

D.3628800

6.在c++程序中，如果一个整型变量频繁使用，最好将他定义为（）

A.auto

B.extern

C.static

D.register

解析：auto、register用来修饰变量的,extern、static都变量函数都可以。
定义的变量默认是auto类型的
register 寄存器变量，老版的编译系统要手动设置，现在的新版的设定是：如果某个变量用的次数特多，就自动把他变成寄存器变量。寄存器变量运算速度快（因为是存放在CPU中运行的 ps：你应该知道CPU和内存的速度差别吧。如果这个搜索不知道建议看看操作系统原理这类的书，还有以后要接触的多线程也会提到CPU和内存的速度差别）
Static是静态变量，定义时必须初始化,很特殊的一个函数，永远占用内存空间。个人感觉是这四个函数里最有用的一个，说不大细，建议多看看资料。
extern int a; 外部声明, 通常该变量在其他文件中定义, 在这里声明表示引用该变量

static 修饰函数为静态函数,本文件中可以使用
extern 外部声明, 改函数在其他地方有被定义过

7.长为n的字符串中匹配长度为m的子串的复杂度为（）

A.O(N)

B.O(M+N)

C.O(N+logM)

D.O(M+logN)

解析：见另一份试卷。

8.判断一包含n个整数a[]中是否存在i、j、k满足a[i] + a[j] = a[k]的时间复杂度最小值是（）

A.O(n^2)        B. O(n^2*logn)       C. O(n^3)    D. O(nlogn)

 解析：见另一份试卷。

9.下列序排算法中最坏情况下的时间复杂度不是n(n-1)/2的是

A.快速排序     B.冒泡排序   C.直接插入排序   D.堆排序

解析：堆排序最坏情况下的时间复杂度是O(log2(n))

10.发射三次炮弹，射中目标的概率是0.95，请问发射一次能击中目标的概率是多少？

A0.63

B0.50

C.0.32

D.0.86

不解释。

二、不定向选择题

1.不记得

2.一个栈的入栈数列为：1、2、3、4、5、6；下列哪个是可能的出栈顺序。（选项不记得）

3.下列哪些代码可以使得a和b交换数值。（选项不记得）

 解析：

 

一.

 

temp=a;

 

a=b;

 

b=temp;

 

缺点:需要用temp中间量，空间性不好

 

 

 

二.加减法，另有乘除法，相似，就不另举了（+改为*，-改为/）

 

a=a+b

 

b=a-b

 

a=a-b

 

缺点：容易产生溢出

 

优化：以int a,b为例，将他们转为double型

 

 

 

三.异或法

 

a^=b; //异或

 

b^=a;

 

a^=b;

 

不能交换不同类型值

 

 

 

不知道还有没有其他有意思的方法？

 

 

 

其他思路：

 

四.堆栈法

 

push a

 

push b

 

pop a

 

pop b

 

缺点同一

 

4.A和B晚上无聊就开始数星星。每次只能数K个（20<=k<=30）A和B轮流数。最后谁把星星数完谁就获胜，那么当星星数量为多少时候A必胜？
　　A先数。
　　尝试直接给几个选项
　　A.2519  B.4096   C.3333   D.3021
　　选项记不住了，但是数字很大，2000~5000不等。

参考答案：BCD。除50余20到49的都可以。最后的让a数完或者留下1到19给b，b不能数，即a最后数完。

三、填空问答题

1.给你一个整型数组A[N]，完成一个小程序代码（20行之内），使得A[N]逆向，即原数组为1，2，3，4，逆向之后为4，3，2，1

 

[cpp] view plaincopyprint?
  1. void revense(int * a,int n) { 
  2.     int begin = 0, end = n-1; 
  3.     int tmp; 
  4.     while(begin < end) 
  5.     { 
  6.         tmp = a[begin]; 
  7.         a[begin] = a[end]; 
  8.         a[end] = tmp; 
  9.         ++begin; 
  10.         --end; 
  11.     } 

 

2.自选调度方面的问题，题目很长，就是给你三个线程，分别采用先来先分配的策略和最短执行之间的调度策略，然后计算每个线程从提交到执行完成的时间。题目实在太长，还有几个表格。考察的是操作系统里面作业调度算法先进先出和最短作业优先。

关于作业调度算法：http://www.cnblogs.com/zhj5chengfeng/p/3644809.html；OS中常用的调度算法：http://blog.chinaunix.net/uid-25132162-id-361291.html

3.有个苦逼的上班族，他每天忘记定闹钟的概率为0.2，上班堵车的概率为0.5，如果他既没定闹钟上班又堵车那他迟到的概率为1.0，如果他定了闹钟但是上班堵车那他迟到的概率为0.8，如果他没定闹钟但是上班不堵车他迟到的概率为0.9，如果他既定了闹钟上班又不堵车那他迟到的概率为0.0，那么求出他在60天里上班迟到的期望。

解析：

定闹钟概率0.8  未定闹钟概率0.2    堵车概率0.5   不堵车概率0.5
迟到概率     定闹钟    未定闹钟   
堵车             0.9            1
不堵车          0               0.8
定闹钟迟到次数期望=0.8*（0.5*0.9+0.5*0）=0.8*0.5*0.9=0.36
不定闹钟迟到次数期望=0.2*（0.5*1+0.5*0.8）=0.18
所以迟到次数期望=0.36+0.18=0.54
60天迟到次数期望=60*0.54=32.4

4.战报交流：战场上不同的位置有N个战士（n>4），每个战士知道当前的一些战况，现在需要这n个战士通过通话交流，互相传达自己知道的战况信息，每次通话，可以让通话的双方知道对方的所有情报，设计算法，使用最少的通话次数，是的战场上的n个士兵知道所有的战况信息，不需要写程序代码，得出最少的通话次数。

详见：http://www.cnblogs.com/xpowerlord/p/3649112.html

5.有N个人，其中一个明星和n-1个群众，群众都认识明星，明星不认识任何群众，群众和群众之间的认识关系不知道，现在如果你是机器人R2T2，你每次问一个人是否认识另外一个人的代价为O(1)，试设计一种算法找出明星，并给出时间复杂度（没有复杂度不得分）。

答案： 遍历 1~n 这n个人； 首先取出 1号 和 2号， 如果 1 认识 2， 那么把 1 去掉； 如果1不认识2，就可以把2去掉了。 每次比较都去掉一个，如此循环；n-1次之后只有一个人了 时间复杂度： O（n-1）

 

四、综合题

有一个淘宝商户，在某城市有n个仓库，每个仓库的储货量不同，现在要通过货物运输，将每次仓库的储货量变成一致的，n个仓库之间的运输线路围城一个圈，即1->2->3->4->...->n->1->...，货物只能通过连接的仓库运输，设计最小的运送成本（运货量*路程）达到淘宝商户的要求，并写出代码。

解答：这个题目类似的题目有：

题目：http://www.lydsy.com/JudgeOnline/problem.php?id=1045
有n个小朋友坐成一圈，每人有ai个糖果。每人只能给左右两人传递糖果。每人每次传
递一个糖果代价为1，求使所有人获得均等糖果的最小代价。
分析：
假设a1分给an的糖果数为k，则可以得到以下的信息：
  a1              a2                       　a3　　　　　　　　   an-1 　　　　　　　　　　　　 an
当前数目：a1-k           a2　　　　　　　　 a3　　　　　　　　   an-1 　　　　　　　　　　　　 an+k
所需代价：|a1-k-ave| |a1+a2-k-2*ave| |a1+a2+a3-k-3*ave||a1+..+a(n-1)-k-(n-1)*ave|   |k|
以sum[i]表示从a1加到ai减掉i*ave的和值，这以上可以化简为
总代价 = |s1-k|+|s2-k|+...+|s(n-1)-k|+|k|
不难看出：当k为s1...s(n-1)中的中位数的时候，所需的代价最小

代码转载于网络：

 

[cpp] view plaincopyprint?
  1. #include <cstring> 
  2. #include <iostream> 
  3. #include <algorithm> 
  4. using namespace std; 
  5.  
  6. const int X = 1000005; 
  7. typedef longlong ll; 
  8. ll sum[X],a[X]; 
  9. ll n; 
  10. ll Abs(ll x){ 
  11.     return max(x,-x); 
  12. } 
  13. int main(){ 
  14.     //freopen("sum.in","r",stdin); 
  15.     while(cin>>n){ 
  16.         ll x; 
  17.         ll tot = 0; 
  18.         for(inti=1;i<=n;i++){ 
  19.             scanf("%lld",&a[i]); 
  20.             tot += a[i]; 
  21.         } 
  22.         ll ave = tot/n; 
  23.         for(inti=1;i<n;i++) 
  24.             sum[i] = a[i]+sum[i-1]-ave; 
  25.         sort(sum+1,sum+n); 
  26.         ll mid = sum[n/2]; 
  27.         ll ans = Abs(mid); 
  28.         for(inti=1;i<n;i++) 
  29.             ans += Abs(sum[i]-mid); 
  30.         cout<<ans<<endl; 
  31.     } 
  32.     return0; 
  33. } 

但从上面的讲解看的话，还是很难理解。详见http://m.blog.csdn.net/blog/dengwei4321/8900231帮助理解。

posted @ 2015-04-24 10:19  hzhtracy  阅读(274)  评论(0)  编辑  收藏  举报