2013年阿里巴巴暑期实习招聘笔试题目及部分答案——5月5日

来源：互联网发布：办公绘图软件编辑：程序博客网时间：2024/05/21 17:08

关于阿里笔试题的说明：阿里的笔试题在网上有很多，百度文库就有很多，里面大多是拍的照片，可以直接去搜搜。

一、单项选择题

1.下列说法不正确的是：

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

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

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

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

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

A.共享内存

B.命名管道

C.信号量

D.临界区

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

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

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

A.01

B.10

C.12

D.22

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

1
2
3
int fun(int x) {
    return (x==1) ? 1 : (x + fun(x-1));
}

A.0

B.10

C.55

D.3628800

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

A.auto

B.extern

C.static

D.register

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

A.O(N)

B.O(M+N)

C.O(N+LOGM)

D.O(M+LOGN)

我想到的是KMP算法。

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

A.O(n) B.O(n^2) C.O(nlog(n)) D.O(n^2log(n))

暂时想到一个o(nlog(n))的算法，

9.三次射击能中一次的概率是0.95，请问一次射击能中的概率是多少？
A.0.63

B.0.5

C.**

D.0.85

10.下列序排算法中最坏复杂度不是n(n-1)/2的是_

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

二、不定向选择题

1.以下哪些进程状态转换是正确的()

A.就绪到运行 B.运行到就绪 C.运行到阻塞 D.阻塞到运行 E.阻塞到就绪

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

一道非常老的题目了，没啥好说的，很简单

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

常见的有(a=a+b,b=a-b,a=a-b; a=a^b,b=a^b,a=a^b)

4.A和B晚上无聊就开始数星星。每次只能数K个（20<=k<=30）A和B轮流数。最后谁把星星数完谁就获胜，那么当星星数量为多少时候A必胜？（选项不记得）

跟那种两堆东西，谁先拿光的情形是差不多的

三、填空问答题

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

void revense(int * a,int n) {for(int i=0 ; i<n/2 ; i++)swap(a[i],a[n-i-1]);}

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

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

P(每天迟到的概率)=0.2*0.5*1+0.8*0.5*0.9+0.2*0.5*0.8+0.2*0.5*0.0=0.1+0.36+0.08=0.54(全概率公式)

E(60天里上班迟到的期望)=60*0.54=32.4

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

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

评论中有人说这就是寻找图中出度为0的点的问题，思路是一样的，如果i认识j，就说明j有可能是明星，i肯定不是明星，转换为大小比较的问题方便那些对图不太熟悉的人理解。

解答：这个问题等价于找未知序列数中的最小数，我们将reg这个函数等价为以下过程：，如果i认识j，记作i大于等于j,同样j不一定大于等于i,满足要求，i不认识j记作i<j，对明星k,他不认识所有人，则k是其中最小的数，且满足其余的人都认识他，也就是其余的人都大于等于k.这样问题就被转换了。就拿N=5来说，首先有数组S[5]={A,B,C,D,E}这5个变量，里边存放着随机数，求是否存在唯一最小数，如果存在位置在S中的哪里。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
int finds(S,N)
{
    int flag=0;//用于判定是否有明星，即当前最小数另外出现几次
    int temp=0;//存放最小数在S中的位置
    for(i=1;i<N;i++)
   ｛
      if(!reg(S[i],S[temp])//如果temp标号的数小于i标号的数
     ｛
         temp=i;
         flag=0;//更换怀疑对象（最小数）时，标记清零
      ｝
      elseif(reg(S[temp]，S[i])//如果temp里存放的确实是唯一最小数是不会跑进这里来的
      {
           flag++;
`     }
    ｝
    if(flag>0) return -1;//表示没有明星,例如所有的数都相等
    return temp;//返回明星在S中的位置
}

四、综合题

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

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

题目：http://www.lydsy.com/JudgeOnline/problem.php?id=1045

有n个小朋友坐成一圈，每人有ai个糖果。每人只能给左右两人传递糖果。每人每次传递一个糖果代价为1，求使所有人获得均等糖果的最小代价。
分析：

假设n个仓库的初始储货量分别为a[1],a[2],...,a[n]
    计算平均储货量 averge = （a[1]+a[2]+...+a[n])/n
        首先，从仓库1向仓库n运送k；
        然后，从1到n-1，依次向下运送某一特定值，使得每一个仓库的余量都为average，剩下的问题就是求总代价的最小值了。
第0步（从仓库1向仓库n运送k）:代价为 |k|
第1步（确保仓库1的余量为average）：代价为|a[1]-average-k|
第2步（确保仓库2的余量为average）：代价为|a[2]+a[1]-average-k-average|=|a[1]+a[2]-2*average-k|
...
第n-1步：代价为|a[1]+a[2]+...+a[n-1]-(n-1)*average-k|
此时，仓库n剩下的货物量：(a[n]+k)+a[1]+a[2]+...+a[n-1]-(n-1)*average-k=(a[1]+a[2]+...+a[n])-(n-1)*average=average刚好也满足
     总的代价为：|k|+|a[1]-average-k|+|a[1]+a[2]-2*average-k|+...+|a[1]+a[2]+...+a[n-1]-(n-1)*average-k|
不妨令s[i] = a[1]+a[2]+...+a[i]-i*average
则，总代价可表示为：|k|+|s[1]-k|+|s[2]-k|+...+|s[n-1]-k|
      这个式子可以看成在水平数轴上寻找一个点k，使得点k到点0,s[1],s[2],s[3],...,s[n-1]的距离之和最小，显然k应该取这n个数的中位数。至此问题解决。

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