阿里巴巴集团2013年实习生招聘笔试题目及解答

完整答案分析：http://blog.csdn.net/yunzhongguwu005/article/details/11901575

这里的【分析】是我给出的，第8个选择题应该选B，完整答案分析有误。

一、   单选

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

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

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

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

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

【分析】： 18xDVD速度为不可能这么高。SATA是串口硬盘，目前能达到600M/s；DDR3的频率常见的有1066HZ，1066*8M大概每秒1G。

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、++、--操作都是原子性的，则输出不可能是哪个（）

void foo() {

    if(a <= 0) {

        a++;

    }

    else {

        a--;

    }

    printf("%d", a);

}

A.01

B.10

C.12

D.22

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

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)

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))

【分析】：应该选B，分析见本博客【算法导论学习-005】整数集合S中是否存在两个数等于给定的一个整数

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

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

10.三次射击能中至少一次的概率是0.95，请问一次射击能中的概率是多少？

A.0.32

B.0.5

C.0.63

D.0.85

二、不定项选择题

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

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

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

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

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

参考：http://blog.sina.com.cn/s/blog_68f6d5370101gt5g.html

【分析】：这是一个博弈的问题，我们可以从胜利条件出发，A必胜，那么最后一次是A数，并且剩下星星的个数20<=k<=30 ，那么如何保证呢？最后50颗由B先数，B数m颗，然后A数剩下的50-m颗。好了，那么第一次A数的话必须保证，第一次A数完之后，剩下的个数是50的倍数。所以案就明了了,星星的数量应满足：

50k+20 <= N <=50K+30,k是整数

三、填空问答题

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

【分析】：用异或操作符进行交换，不需要临时变量。注意判断两者不相等再异或。

2.自选调度方面的问题，题目很长，就是给你三个线程，分别采用先来先分配的策略和最短执行之间的调度策略，然后计算每个线程从提交到执行完成的时间。

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

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

参考：http://segmentfault.com/q/1010000000198718

【分析】：分成两组：2个node， n-2个node ;

1）2个node需要连接1次，使得2个node拥有2个节点信息；

2）n-2个node至少需要n-3次连接，使得最后连接的2个node拥有这n-2个node的信息；

3）第一组的2个node与第n-2组的最后两个node（即获得该组全部信息的2个nodes）分别连接；于是4个节点得到全部信息，连接了2次。这里是为什么节约了一次连接的关键。

4）剩下的n-4个node都没有获得全部信息，每个node至少需要一次连接。因此至少需要n-4次连接。用拥有全部信息的其中一个node与剩下的n-4个node连接。则只需要n-4次。

总次数：1+(n-3)+2+(n-4)= 2n-4.

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

四、综合题

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

参考1：http://www.cnblogs.com/lazycoding/archive/2013/06/02/3113989.html

参考2：http://blog.csdn.net/gremount/article/details/22982299

【分析】：明显是个单循环链表，储货量变成一致即要求每个节点的货运量等于所有仓库的货运总量的平均值。

算法思路：

1）遍历单循环链表一次，求出总的货运量节点个数，求出平均货运量，同时得到最大的储货量仓库。

2） 再次遍历单循环链表，以最大的货量仓库为头结点开始，如果该节点货运量＞平均货运量，则将多余的货运量运到它的后继，本节点货运量等于平均货运量；如果该节点货运量≤平均货运量，这不进行操作。由于每次移动一个仓库距离，成本等于每一次移动的货运量。

3） 进行两圈的操作之后，一定能保证每个仓库的货运量等于平均值。

注意：头结点选择最大储货量仓库与否对最终结果没有影响，只是有可能减少了遍历次数而已。

Java 数组模拟单循环链表，模拟5个结点：

/**
 * 创建时间：2014年8月27日下午4:31:41
 * 项目名称：Test
 * @author CaoYanfeng 北京大学
 * @sinceJDK 1.6.0_21
 * 类说明：  仓库问题模拟，
 * 由于不涉及删除操作，可以用数组来模拟单链表
 */
publicclassWarehouseTest {
    private static final int N=5;
    /**
     * @paramargs
     */
    public static voidmain(String[] args) {
        // TODOAuto-generated method stub
        int[] wareHose=new int[N];
        initWareHose(wareHose);
        int cost=getCost(wareHose);
        System.out.println(cost);
 
    }
    /*获取成本，最终结果是6，同时设置了头尾相接的判断，数组两次遍历以内一定能结束*/
    public static intgetCost(int[] wareHose) {
        int cost=0;
        int length=wareHose.length;
        int average=getAverage(wareHose);
        for (int i = 0;i < length; i++) {
            if (wareHose[i]>average) {
                int diff=wareHose[i]-average;
                wareHose[i]-=diff;
                /*到末尾元素时返回第一个元素,同时置i为-1,下一次循环让其回到0*/
                if (i==wareHose.length-1) {
                    wareHose[0]+=diff;
                    i=-1;
                }else {
                    wareHose[i+1]+=diff;
                }
                cost+=diff;
            }
        }
        return cost;
    }
    public static intgetAverage(int[]  wareHose) {
        int sum=0;
        for (int i = 0;i < wareHose.length;i++) {
            sum+=wareHose[i];
        }
        return sum/wareHose.length;
    }
    /*初始化储货量为4、1、2、3、0,均值为整数，方便模拟*/
    public static voidinitWareHose(int[]wareHose) {
            wareHose[0]=4;
            wareHose[1]=1;
            wareHose[2]=2;
            wareHose[3]=3;
            wareHose[4]=0;
    }
}