13年阿里实习生招聘

 一、单项选择题

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

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

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

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

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

我自己做题时候的思路是：本人有08年的Y430一台，当时给硬盘测速时，记得是60MB/s，也即480Mbps/s，选项A大差不差；印象中，光盘的速度再快，也只有几十M/s，硬盘尚不能达到1Gbps，更何况光盘呢？基本上可以确定B是错误的；所谓的千兆，即1000M=1G，C是对的；而对于DDR3的内存速度，有次为了创建ramdisk，使用工具对内存进行了鉴别，隐约记得速度是GB/s级别的，D选项中，100Gbps换算过来也就是12.5GB/s，有理由相信它是正确的。综上，可以判断出B是错误的。

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

A.共享内存

B.命名管道

C.信号量

D.临界区

所谓的临界区（critical section），实际上指的是一段代码。选D；在《Windows核心编程第五版》中，对临界区的解释是：它是一小段代码，它在执行之前需要独占对一些共享资源的访问权。这种方式可以让多行代码以“原子方式”来对资源进行操控。这里的原子方式，指的是代码知道除了当前线程之外，没有其他任何线程会同时访问该资源。当然，系统仍然可以暂停当前线程去调度其他线程。但是，在当前线程离开临界区之前，系统是不会去调度任何想要访问同一资源的其他线程。

至于A、B、C，都是进程通信的手段。

Linux中，进程通信的手段有：待补充。

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

这道题考察操作系统中有关进程调度，作业调度的有关内容。做题时，画图解比较清晰易懂。由于每个进程都有三个阶段：计算、IO、计算，我们将这三次计算命名为A、B、C。同时需要注意，题目中没有明说，我们假设P1、P2、P3是不可抢占的。

60ms     80ms    40ms       20ms   20ms     20ms       40ms     40ms     40ms

P1(A)--> P1(B)            --> P1(C) 

              P2(A)   P2(A) --> P2(B)   P2(B)              --> P2(C)          

                                                  P3(A)      P3(A) --> P3(B)    P3(B) --> P3(C)

最终耗时：60+80+40+20+20+20+40+40+40=360ms；

全串行执行耗时：160+200+160=520ms；

节约了520ms-360ms=160ms。

4.两个等价线程并发的执行下列程序，a为全局变量，初始为0，假设printf、++、--操作都是原子性的，则输出不可能是哪个（）
void foo() {
    if(a <= 0) {
        a++;
    }
    else {
        a--;
    }
    printf("%d", a);
}

A.01

B.10

C.12

D.22

当时我写的答案是D，而网上其他版本，好多都讲的是C。后来自己思考了一下，觉得A可能是正确的，下面将一下我的思路。

对于B答案，P1执行程序，输出1，P2执行程序，输出0；

对于C答案，初始为0，P1执行完判断语句，决定要执行a++，中断，P2进行判断，此时a仍然等于0，执行判断语句，并执行输出，得到1，P1然后继续执行，此时它该执行a++，这时a=1，执行并输出，结果为2；

对于D答案，初始为0，P1执行完判断语句，决定要执行a++，中断，P2进行判断，此时a仍然等于0，执行a++，得到a=1，中断，P1继续执行a++，a=2，P1输出，得到2，P1结束，P2继续执行输出语句，得到2；

对于A答案，我现在再三思考，绞尽脑汁也想不起来当初为什么会判断它不是答案。o(╯□╰)o。

思路：当时我的直觉告诉我应该选奇数，回来想了一下，好像得到了答案：看答案可知每个线程进foo函数不止一次，那么我们暂且假设两个线程分别进入foo函数X次，假设给线程编号，线程1有m次被堵在a++,线程2有n次被堵在a++处，那么线程1必然会执行（X-m)次a- -，线程2必然会执行（X-n)次a- -，那么最终a的值为（m+n)-((X-m)+(X-n))=2(m+n)-2X，也就是说a最后的值必然是偶数

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

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

A.0

B.10

C.55

D.3628800

递归展开，f(10)=10+f(9)=10+9+f(8)+……+1=55。

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

A.auto

B.extern

C.static

D.register

C语言中提供了存储四种修饰符：auto，register，extern，static的：

auto修饰符仅在语句块内部使用，初始化可为任何表达式，其特点是当执行流程进入该语句块的时候执行初始化操作，没有默认值。

使用register修饰符修饰变量，将暗示编译程序相应的变量将被频繁地使用，如果可能的话，应将其保存在CPU的寄存器中，以加快其存储速度。

static静态变量声明符。在声明它的程序块，子程序块或函数内部有效，值保持，在整个程序期间分配存储器空间，编译器默认值0。是C/C++中很常用的修饰符，它被用来控制变量的存储方式和可见性。static被引入以告知编译器，将变量存储在程序的静态存储区而非栈上空间。

extern可以置于变量或者函数前，以表示变量或者函数的定义在别的文件中，提示编译器遇到此变量和函数时在其他模块中寻找其定义。另外，extern也可用来进行链接指定。

寄存器快嘛，而且整型也正好能放进寄存器，详见变量的存储类型

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

A.O(n)

B.O(m+n)

C.O(n+logm)

D.O(m+logn)

笔试的时候，KMP算法还复习，现在都已经忘得差不多了，当时答案是蒙的。字符串匹配算法在最近也必须得重新复习。m=1时，匹配需要O(n)，m增大，也需要有相应的开销；C最像，所以选C。（注：此部分以后再补充）。

思路：KMP算法的时间复杂度是O(M+N)，但是BM算法会相对而言更快，但是也是O(M+N)。当时选的是B,但是加个“最”总让人不放心，回来查看资料，用后缀数组的方法可以在O(M+LOGN)时间内完成，但是这没有包含后缀数组预处理所需的时间（一般为NLOGN)。（ps:以后如果不确定还是跟着直觉走吧）

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

待补充。

9.下列排序算法中最坏复杂度不是n(n-1)/2的是D
A.快速排序     B.冒泡排序   C.直接插入排序   D.堆排序

显而易见。排序算法的比较待补充。

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

A.0.32

B.0.5

C.0.63

D.0.85

公式很简单，1-(1-p)^3=0.95。接下来需要有一定的估算技巧。A选项可以看作是1/3，C选项可看作是2/3，D选项可看作4/5。

 二、不定项选择题

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

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

这题考察linux系统的进程调度问题，A、B、C、E都是可以的。D中，阻塞到运行，中间需要经历就绪状态。

进程切换图，待补充。

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

这种题是常考的，要熟悉stack的后进先出规则。

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

用两个数代入看每一个选项的代码能否交换其数值，选出答案。如果不放心，可再选一组进行验证。

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

对于上述答案，A有必胜的策略，A、B、C、D、E都应该选择。首先，A先取，使剩余的星星为50的倍数。然后数星星的顺序为B、A、B、A……。B数k个星星，则A就数50-k个，使剩余星星始终为50的倍数，最后，一定是A数最后的星星。A必胜。

思路：排除法就好了，如果天上有x颗星星，必定有2n*k<x<=(2n+1)*k，先用k=20排除几个答案，然后用21排除就只剩一个答案了。貌似我当时排除完之后只剩下E了。

三、填空问答题

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

void revense(int * a,int n) {


}

void reverse(int * a,int n) {
	assert(a!=NULL);//当时写了这么一句，貌似有点画蛇添足了，因为要求不要用到任何库
	for(int i=0;i<n/2;++i)
	{
		//swap
		a[i]=a[i]+a[n-1-i];
		a[n-1-i]=a[i]-a[n-1-i];
		a[i]=a[i]-a[n-1-i];
	}
}

待补充。

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

待补充。

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

待补充。

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

待补充。

思路：我当时给出的答案是将n个士兵两个一组，组内交换信息，然后每组任意选一个出来得到（n+1）/2个士兵，其中每个士兵知道的信息是交换前的2倍，然后将这些士兵再两两分组，以此类推，这样的话，最终会有一个人知道所有的信息，然后依次分发给其余n-1个人即可，需要通话的次数是+n-1,但是我不确定这样是不是最快，这篇文章给出了解答，稍微看了一下，思路跟我差不多，只是汇总人的个数作为变量，据说有证明，对这一题不感兴趣，最终答案是2n-4.

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

解答：这个问题等价于找未知序列数中的最小数，我们将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中的哪里。（楼主这里是这个意思，按我的理解题中这个最小数一定是存在且唯一的）

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中的位置
}

思路：从第一个人开始问，问他是不是认识旁边的人，如果他认识，那么他肯定不是明星，直接把这个人去掉，如果他不认识，那么被问的人肯定不是明星，被问的人从集合中去掉，这样问一次就可以删掉一个人，最后剩下的就是明星了，时间复杂度O(N)

四、综合题

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

解答：
有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)中的中位数的时候，所需的代价最小
代码：
#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;
}

思路：这个在各种online-judge平台上都有答案，纯粹的数学问题，

如图，这是一个仓库分布的模拟，假设从第i个仓库向第i+1个仓库转移的物品为P_i个单位，其中P_i为负表示思是从i+1个仓库转移到第i个仓库，第n个仓库转移到第一个仓库即为P_n，设最后每个仓库平均后的货物为ave个单位，则有要最小化|P₁|+|P₂|+…+|P_i|+…+|P_n|

                               ave[i]=ave=A[i]-P_i+P_i-1

                               ave[1]=A[1]-P₁+P_n

                       然后设W[i]=ave[i]-A[i]=-P_i+P_i-1

                       于是S[i]=W[1]+W[2]+….W[i]=P_n-P_i

                   即P_i=P_n-S[i] ，所以问题归结到最小化|P_n-S[1]|+|P_n-S[2]|+…+|P_n-S[n]|

                 所以P_n是S中位数的时候最小