2012各大IT公司校招笔试题整理

2011阿里云计算研发中心笔试题(45minutes)

 

2011阿里云计算研发中心笔试题(45minutes)

 

应聘职位：软件开发工程师-数据平台

 

1.状态转换图，有限自动机，正则表达式

 

2.最小堆，删除堆根节点，画出任意结果

 

3.Heap与stack在进程中的区别

 

4.硬盘概率问题，对立事件，独立事件，平均分布，一季度，一年

 

5.工厂分布距离最小问题

 

6.多线程输出变量的所以可能值

 

7.补充题，堆排序补充

 

8.整数数组中求相加和最大的子数组，时间复杂度为O(n)，编程语言不限(C/C /JAVA)

 

附加知识：

 

一个由C/C++编译的程序占用的内存分为以下几个部分

 

1、栈区（stack）— 由编译器自动分配释放 ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。

 

2、堆区（heap） — 一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。注意它与数据结构中的堆是两回事，分配方式倒是类似于链表。

 

3、全局区（静态区）（static）—，全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域， 未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。 - 程序结束后有系统释放

 

4、文字常量区 —常量字符串就是放在这里的。 程序结束后由系统释放

 

5、程序代码区—存放函数体的二进制代码。

 

Heap：http://en.wikipedia.org/wiki/Heap_(data_structure)

 

 

2011百度校招笔试

今天在冶金馆中心考场3参加2011百度校招笔试了，题目太长啦，感觉不错就打出来分享一下，希望大家早早拿到心仪的offer！

 

一.编程题

 

1.用C语言写一个函数来执行一串任务。任务是互相依赖的。比如B任务依赖A任务，则A完成B才能执行。不考虑并发限制，假设所有的任务都能一次执行成功，所有的任务执行时间都相等。任务数据结构原型为：

 

typedef struct {

 

int id；//该任务的ID

 

int *child；//该任务依赖的任务的ID

 

int child_num;//该任务依赖的任务的个数

 

}task；

 

函数原型：

 

bool doschedule（task*pask，int task_num ）;

 

以下函数可以直接调用：

 

void dotask（int id）；//执行一个进程

 

int waittask（int timeout）；//等待timeout时间，并返回一个执行成功的任务的id，如果没有任务在时间片内完成，则返回-1

 

bool killtask（int id）；//杀掉一个进程

 

2.如果考虑并发限制，应该怎么改进？

 

二。简答题

 

1.阐述栈和堆在生命周期、速度、内存性能等方面的不同点。假如现在有一个缓冲区域绝大多数只需要1KB空间，极少数极端情况下需要100MB，怎么样合理分配内存？

 

2.说明以下包含const修饰符的语句的意义

 

a). double * ptr=&value；

 

b). const double * ptr=&value;

 

c). double *const ptr =&value;

 

d).const double *const  ptr=&value;

 

3.请问c语言中怎么去除const修饰？

 

比如：

 

const double value=0.2f；

 

double *ptr；

 

ptr怎么样获取value的值？

 

三.算法设计题

 

1.在一维坐标轴上存在许多条线段，用最简单的算法找出重合长度最长得两条线段。比如线段A（1,5）、B（2,8）、C（3,9），则B和C的重合长度最长，为5.

 

2.是一道求最短路径的问题，例子给出了一个包含5个节点的有向图，标有权值，求始点到终点的距离，图就不画了 。

 

这两道题都需要详细写明算法与函数设计 -_-

 

四.系统设计题

 

百度的某某服务机制类似于CS（customer-server），有时候大量用户访问服务器S，导致S运行效率缓慢。为了提升效率，拟在C上利用一些空余的结果空间作为缓存。已知在C的一台客户机上，每天接收1000w query，其中500w uniq query，每个query 5KB，客户机内存3GB，硬盘500GB。做出一个方案，说明系统结构、存储结构、性能优化等方面的设计。

 

 

【原】字符串反转代码的实现

2011-09-16 14:54

 

将一句话里面的单词进行倒置，标点符号不倒换，如“i come from tianjin.”，倒换后位"tianjin. from come i"，代码实现如下：

 

 

 

#include <stdio.h>

#include <string.h>

 

char* convert(char* pure)

{

 char *temp = malloc(strlen(pure) + 1);

 int i = 0;

 int j = strlen(pure) - 1;

 int pre = 0;

 int k = 0;

 

 for(i = 0; i < strlen(pure); i++)

 {

  temp[j--] = pure[i];

 }

 printf("%d\n",strlen(temp));

 for(i = 0; i < strlen(temp); i++)

 {

  printf("i is %d\n", i);

  if(temp[i] == ' ')

  {

   k = i;

   printf("here is %d\n", i);

   for(j = pre; j < i; j++)

    pure[j] = temp[--k];

   

   pure[j] = ' ';

   pre = i + 1;

  }

  if(i == (strlen(temp) - 1))

  {

   k = i;

   printf("i is %d, j is %d, pre is %d\n", i, j, pre);

   for(j = pre; j <= i; j++)

    pure[j] = temp[k--];

  }

 }

 return pure;

}

 

int main()

{

 char a[] = "iam love you, baby.";

 

 convert(a);

 printf("%s\n", a);

 

 

}

 

xdyang 于2011-9-16 于东大IC学院302

 

 

【原】2012华为上机考试题目2012-9-17

2011-09-17 18:50

 

一共三道题，第一题为数字到字符的转换，不解释，加'0'即可。

 

第二道为单链表的逆序，继续不解释，看宝典或搜索。

 

第三道题是，读入一个文本，返回文本内出现次数最多的单词，和出现最少的单词。单词部分大小写，单词以逗号，句号或空格分隔。

 

个人实现如下，感觉还是得花一个小时左右才能调试好。

 

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

 

typedef struct test

{

 char word[20];

 struct test* next;

 int len;

 int count;

} Test;

 

 

void find(char* pure, char *max_string, char *min_string)

{

 int len = strlen(pure);

 int i = 0;

 int pre = 0;

 Test* head = (struct test*)malloc(sizeof(struct test));

 Test* pre_point = head;

 Test* temp = NULL;

 Test* sec_temp = NULL;

 int max = 0;

 int max_count = 0;

 int min = 0;

 int min_count = 0;

 int j = 0;

 int panduan = 0;

 

 printf("len is %d\n", len);

 for(i = 0; i < len; i++)

 {

  if((pure[i] == ' ') || (pure[i] == ',') || (pure[i] == '.'))

  {

   if(i - pre != 0)

   {

    temp = (struct test*)malloc(sizeof(struct test));

    temp->len = i - pre;

    for(j = 0; j < temp->len; j++)

     temp->word[j] = pure[pre + j];

    temp->word[j] = '\0';

    temp->count = 1;

    pre_point->next = temp;

    temp->next = NULL;

    pre_point = temp;

   }

   pre = i + 1;

  }

 }

 

 strcpy(max_string, head->next->word);

 strcpy(min_string, head->next->word);

 min = len;

 for(temp = head->next; temp->next != NULL; temp = temp->next)

 {

  for(sec_temp = head->next; sec_temp->next != NULL; sec_temp = sec_temp->next)

  {

   panduan = 0;

#if 0

   if(!strcmp(temp->word, sec_temp->word))

   {

    temp->count++;

   }

#endif

   if(temp->len == sec_temp->len)

   {

    for(i = 0; i < temp->len; i++)

    {

     if((temp->word[i] != sec_temp->word[i]) && (temp->word[i] != sec_temp->word[i] + 'A' - 'a')  && (temp->word[i] != sec_temp->word[i] + 'a' - 'A'))

     {

      panduan = 1;

      break;

     }

    }

    if(!panduan)

     temp->count++;

   }

  }

  if(temp->count > max)

  {

   max = temp->count;

   strcpy(max_string, temp->word);

  }

  if(temp->count < min)

  {

   min = temp->count;

   strcpy(min_string, temp->word);

  }

 }

 

}

 

int main()

{

 char* test = "Hello, everybody. Hello boy, hello boy love.";

 char* max_string = (char*)malloc(20);

 char* min_string = (char*)malloc(20);

 

 find(test, max_string, min_string);

 printf("max %s\n", max_string);

 printf("min %s\n", min_string);

}

 

 

 

xdyang  2012-9-17与东南大学IC学院302

 

 

======================

 

【原】（两个大数相乘）华为2012校园招聘上机题2011-9-18

2011-09-19 18:47

 

这次继续讲第三题，这次的题目是两个大数相乘，每个100位，保存在一个字符串中，结果也要保存到一个字符串中，我断断续续花了近两个小时搞定。基本思想还是用手算乘法的方法来解决，代码如下：

 

PS:

 

1、没有注释，大家将就将就。

 

2、代码格式不规范，没有开头空格什么的，这个我代码是有的，但拷贝到空间就没了，有人知道怎么解决可以给我留言，谢谢。

 

#include <stdio.h>

#include <math.h>

#include <stdlib.h>

#include <string.h>

 

char* add_result(char* result, char* single_result, int num)

{

 int i = 0;

 int temp = 0;

 int temp_add = 0;

 int len1 = strlen(result);

 int len2 = strlen(single_result);

// int max_len = MAX(len1, len2 + num);

 int j = len1;

// printf("len2 is %d, len1 is %d, num is %d\n", len2, len1, num);

 if((len2 + num) >= len1)

 {

  for(i = len2 - 1; i >= 0; i--)

  {

   if((j - num - 1) >= 0)

   {

 //   printf("here\n");

    temp = (result[j - num - 1] - '0') + (single_result[i] - '0');

    temp += temp_add;

    temp_add = temp / 10;

    temp = temp % 10;

    result[j - num -1] = temp + '0';

    j--;

   }

   else

   {

    if(temp_add != 0)

    {

     single_result[i] += temp_add;

     temp_add = 0;

    }

    result[len1 + i + 1] = '\0';

    for(j = len1 - 1; j >= 0; j--)

    {

     result[j + i + 1] = result[j];

    }

    while(i >= 0)

    {

     result[i] = single_result[i];

     i--;

    }

  

   }

  }

 }

 if(temp_add != 0)

 {

  for(i = len2 + num + 1; i > 0; i--)

   result[i] = result[i - 1];

  result[0] = temp_add + '0';

  temp_add = 0;

 }

// printf("result is %s\n", result);

 return result;

}

 

 

char* single_multi(char a, char* num2, int len2)

{

 int num1 = (a - '0');

 int i = 0;

 char* result = (char*)malloc(len2 + 1);

 int mul_two_num = 0;

 char* mul_two_char = (char*)malloc(3);

 

// memset(result, '0', (len2 + 1));

#if 0

 for(i = 0; i < len2 + 1; i++)

 {

  result[i] = '0';

 }

#endif

 result[0] = '\0';

 for(i = (len2 - 1); i >= 0; i--)

 {

  mul_two_num = (num2[i] - '0') * num1;

  itoa(mul_two_num, mul_two_char, 10);

  result = add_result(result, mul_two_char, (len2 - 1 - i));

 }

 

 return result;

}

 

 

char* multi(char* num1, char* num2)

{

 int len1 = strlen(num1);

 int len2 = strlen(num2);

// printf("len1 len2 is %d, %d\n", len1, len2);

 int i = 0;

 char* result = (char*)malloc(len1 + len2 + 1);

 char* result_temp = (char*)malloc(len1 + len2 + 1);

 char* single_result = (char*)malloc(len2 + 2);

#if 0

 for(i = 0; i < (len1 + len2); i++)

 {

  result[i] = '0';

 }

#endif

 result[0] = '\0';

 for(i = len1 - 1; i >= 0; i--)

 {

//  printf("num1 is %c, num2 is %s\n", num1[i], num2);

  single_result = single_multi(num1[i], num2, len2);

  result = add_result(result, single_result, (len1 - 1 - i));

 }

 for(i = 0; i < strlen(result); i++)

 {

  result_temp[i] = result[strlen(result) - i - 1];

 }

 return result;

}

 

int main()

{

 char* num1 = "1234678";

 char* num2 = "9875545678";

 

 printf("%s\n",multi(num1, num2));

}

 

xdyang   2011-9-19于东南大学IC学院302

 

 

【转】笔试出现频率最高的strcpy函数的实现

2011-07-28 15:54

 

题目：

    已知strcpy函数的原型是：

        char * strcpy(char * strDest,const char * strSrc);

    1.不调用库函数，实现strcpy函数。

    2.解释为什么要返回char *。

 

    解说：

    1.strcpy的实现代码

        char * strcpy(char * strDest,const char * strSrc)

        {

                if ((strDest==NULL)||(strSrc==NULL)) //[1]

                        throw "Invalid argument(s)"; //[2]

                char * strDestCopy=strDest;  //[3]

                while ((*strDest++=*strSrc++)!='\0'); //[4]

                return strDestCopy;

        }

复制代码

 

 

    错误的做法：

    [1]

    (A)不检查指针的有效性，说明答题者不注重代码的健壮性。

    (B)检查指针的有效性时使用((!strDest)||(!strSrc))或(!(strDest&&strSrc))，说明答题者对C语言中类型的隐式转换没有深刻认识。在本例中char *转换为bool即是类型隐式转换，这种功能虽然灵活，但更多的是导致出错概率增大和维护成本升高。所以C++专门增加了bool、true、false三个关键字以提供更安全的条件表达式。

    (C)检查指针的有效性时使用((strDest==0)||(strSrc==0))，说明答题者不知道使用常量的好处。直接使用字面常量（如本例中的0）会减少程序的可维护性。0虽然简单，但程序中可能出现很多处对指针的检查，万一出现笔误，编译器不能发现，生成的程序内含逻辑错误，很难排除。而使用NULL代替0，如果出现拼写错误，编译器就会检查出来。

    [2]

    (A)return new string("Invalid argument(s)";，说明答题者根本不知道返回值的用途，并且他对内存泄漏也没有警惕心。从函数中返回函数体内分配的内存是十分危险的做法，他把释放内存的义务抛给不知情的调用者，绝大多数情况下，调用者不会释放内存，这导致内存泄漏。

    (B)return 0;，说明答题者没有掌握异常机制。调用者有可能忘记检查返回值，调用者还可能无法检查返回值（见后面的链式表达式）。妄想让返回值肩负返回正确值和异常值的双重功能，其结果往往是两种功能都失效。应该以抛出异常来代替返回值，这样可以减轻调用者的负担、使错误不会被忽略、增强程序的可维护性。

    [3]

    (A)忘记保存原始的strDest值，说明答题者逻辑思维不严密。

    [4]

    (A)循环写成while (*strDest++=*strSrc++);，同[1](B)。

    (B)循环写成while (*strSrc!='\0') *strDest++=*strSrc++;，说明答题者对边界条件的检查不力。循环体结束后，strDest字符串的末尾没有正确地加上'\0'。

 

    2.返回strDest的原始值使函数能够支持链式表达式，增加了函数的“附加值”。同样功能的函数，如果能合理地提高的可用性，自然就更加理想。

    链式表达式的形式如：

        int iLength=strlen(strcpy(strA,strB));

    又如：

        char * strA=strcpy(new char[10],strB);

    返回strSrc的原始值是错误的。其一，源字符串肯定是已知的，返回它没有意义。其二，不能支持形如第二例的表达式。其三，为了保护源字符串，形参用const限定strSrc所指的内容，把const char *作为char *返回，类型不符，编译报错。

 

 

转者注：

 

    我很想知道在linux中C语言是如何实现的第一二两点的判断检查的，于是我去看了源码，关于这个函数有两种实现：一、内嵌汇编。加入我是一个嵌入式开发者，我严重偏向这种实现。二、C语言如下：

 

char *strcpy(char *dest, const char *src)

{

 char *tmp = dest;

 

 while ((*dest++ = *src++) != '\0')

  /* nothing */;

 return tmp;

}

 

内核版本是2.6.32，没有做任何的检查，这就是内核源码。另外，在所有的汇编实现中也没有任何检查。看来内核也不是万能的，它的代码也不够健壮啊。

 

xdyang 2011-7-28 于东南大学IC学院302

 

 

 

【创新工场】笔试题

发信人: qtian (华子), 信区: Job

标  题: 【求解】【创新工场】笔试题

发信站: 北邮人论坛 (Fri Sep 16 17:21:21 2011), 站内

只记下了三道编程题

   1.求两个大于2的31次方的整数的乘机，只能使用32位整数且给出精确结果。

   2.一篇文章有n（10<n<100）个段落，第i个段落有number[i]个单词，设计算法，不得调用库函数，找出第m个单词属于第几个段落，查询共有k（k>10000）次，说明时间复杂度。（段落编号从0开始）

   3.A,B,C,D,E五个人捕鱼后已凌晨，大家便睡觉。早上A第一个醒来，将鱼均分成五份，把多余的一条鱼扔掉，拿走自己的一份，B第二个醒来，也将鱼均分为五份，把多余的一条鱼扔掉，拿走自己的一份。CDE依次醒来，也按同样的方法拿鱼，问他们合伙至少捕了几条鱼。

 

 

 

阿里云2011.9.17招聘会笔试题

(2011-09-27 09:34:45)

转载 标签：杂谈        分类： job

 

1、 堆和栈的区别？

 

答：1、栈区（stack）—   由编译器自动分配释放   ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。

    2、堆区（heap） 一般由程序员分配释放，   若程序员不释放，程序结束时可能由OS回收   。注意它与数据结构中的堆是两回事，分配方式倒是类似于链表，呵呵。

    3、栈是向下增长的，堆是向上增长的。（可以参考上一篇博客）

 

下面是一个例子程序：

    //main.cpp    

    int   a = 0;   //全局初始化区    

    char   *p1;   //全局未初始化区    

    void main() 

    { 

        int b;              //栈    

        char s[] = "abc";   //栈    

        char *p2;           //栈    

        char  *p3 = "123456";   // 123456\0在常量区，p3在栈上。    

        static int c=0;          //全局（静态）初始化区    

        p1   =   (char *)malloc(10);     //在堆上动态开辟空间  

        p2   =   (char *)malloc(20);    

        //分配来的10和20字节的区域就在堆区。    

        strcpy(p1, "123456");       //123456\0放在常量区，编译器可能会将它与p3所指向的"123456" 优化成一个地方。    

    } 

 

申请方式不同：  

  stack： 由系统自动分配。速度较快。但程序员是无法控制的。   例如，在函数中声明一个局部变量   int   b;   系统自动在栈中为b开辟空间

  heap：  需要程序员自己申请，并指明大小，一般速度比较慢，而且容易产生内存碎片，不过用起来最方便。在c中malloc函数。

  如p1   =   (char   *)malloc(10); 

  在C++中用new运算符  

  如p2   =   new   char[10];  

  但是注意p1、p2本身是在栈中的。  

 

 2、进程和线程区别？

 

线程是指进程内的一个执行单元,也是进程内的可调度实体.

与进程的区别:

(1)地址空间:进程内的一个执行单元;进程至少有一个线程;它们共享进程的地址空间;而进程有自己独立的地址空间;

(2)资源拥有:进程是资源分配和拥有的单位,同一个进程内的线程共享进程的资源

(3)线程是处理器调度的基本单位,但进程不是。4)二者均可并发执行。

 

进程和线程都是由操作系统所体会的程序运行的基本单元，系统利用该基本单元实现系统对应用的并发性。进程和线程的区别：

 

简而言之,一个程序至少有一个进程,一个进程至少有一个线程。

线程的划分尺度小于进程，使得多线程程序的并发性高。

另外，进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。

线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。

从逻辑角度来看，多线程的意义在于一个应用程序中，有多个执行部分可以同时执行。但操作系统并没有将多个线程看做多个独立的应用，来实现进程的调度和管理以及资源分配。这就是进程和线程的重要区别。

 

进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统进行资源分配和调度的一个独立单位。

线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源。

 

一个线程可以创建和撤销另一个线程;同一个进程中的多个线程之间可以并发执行。

 

3、C语言中两种方式使用#include命令，#include <>与#include ””的区别是什么？

 

答："#include <stdlib.h> ” 用于标准库文件或系统提供的头文件，到保存系统标准头文件的位置查找头文件。

 

而"#include "userdefined.h"用于用户自定义的头文件，先从当前目录查找是否有指定名称的头文件，若当前目录未找到该头文件，再从标准文件目录中查找。这两种方式有他们的本质区别。

 

在c语言程序设计中包含的头文件可分为系统标准头文件和用户工程中自定义的头文件，对于系统标准库头文件可以用这两种方式进行包含，但是采用第一种方式更节省时间，所以一般建议采用第一种方式。对于用户自己定义的头文件（保存在工程路径下）只能用第二种方式进行包含操作，否则出错（当然也可以把自己定义的工程中需要的头文件放在标准头文件路径下，但是这违背常规操作）。

 

4、抽象类为什么不能实例化？

 

抽象类中的纯虚函数没有具体的实现，所以没办法实例化。

5、设计模式：工厂模式和 单例模式 介绍一下？

 

工程模式即将对象创建过程封装即为工厂模式。

单例模式即整个类只有一个对象，并且不允许显示创建。

6、vector 和 list的区别？

 

vector内部使用顺序存储，访问速度快，但是删除数据比较耗性能。

list内部使用链式存储，访问速度慢，但是删除数据比较快。

7、纯虚函数是怎样实现的？在编译原理上讲一下？

 

答：在类内部添加一个虚拟函数表指针，该指针指向一个虚拟函数表，该虚拟函数表包含了所有的虚拟函数的入口地址，每个类的虚拟函数表都不一样，在运行阶段可以循此脉络找到自己的函数入口。

 

8、两个线程，几个变量，线程执行次序不确定，某个变量的可能取值。。

 

9、hash冲突时候的解决方法？

 

1）、开放地址法

2）、再哈希法

3）、链地址法

4）、建立一个公共溢出区

 

10、单链表的倒置。

    //逆转链表，并返回逆转后的头节点 

    node* reverse(node *head) 

    { 

        if(head == NULL || head->next == NULL) 

        { 

            return head; 

        } 

        node *cur = head; 

        node *pre = NULL; 

        node *tmp; 

        while(cur->next) 

        { 

            tmp = pre; 

            pre = cur; 

            cur = cur->next; 

            pre->next = tmp;                  //操作pre的next逆转 

        } 

        cur->next = pre;                     //结束时，操作cur的next逆转 

        return cur; 

} 

 

 

百度2012校招

 

做的系统的题目

 

简答题

 

l  Sizeof 以及likely unlikely

 

l  文件系统区别

 

l  DMA，优点

 

l  Tcp关闭

 

l  脚本统计单词个数

 

l  Malloc和new差别

 

编程题

 

l  Pthread实现生产者消费者模型

 

l  去掉字符串中的空格

 

算法题

 

l  文件中N个数字，找出不在这个文件中的一个数字

 

l  数字a到b，可以选择 2a， a+1， a-1，中方法

 

写出a到b最短步数和每一步a的值

 

 

2012校招之百度笔试

节后的招聘大潮终于拉开了大幕，首当其冲的便是百度的笔试。先抱怨一句，笔试的组织很是混乱，整个武大考场都很乱，教室改来改去，时间一拖再拖。

     拿到试卷，2个小时的笔试只有一页试卷，6个大题。不愧是百度，果然够霸气。凭记忆说一下——

     一是简答题，3道，一共30分

     1. 远程登录一个unix/linux系统，用到客户端软件和SSH等，如果网络这时断掉，则远端unix/linux系统上正在运行的程序也会终止。问原理是什么？可以怎样防止这种情况的发生？防止的原理是什么？

     这个问题真不是很清楚，没接触过，乱填一气

     2. 一个小根堆，存在数组a[]。问1.a[n]的左右儿子怎么找   2.新加入一个元素，保持堆序性质，写出代码   3. 拿掉堆顶元素，保持堆序性质，写出代码

     这是最简单的一个问题了，但是要写一些代码，所以花一定时间。

     3. 假设一个哈希函数hash能使用户均匀的分布。这样一个哈希称为一个层。现有层A和层B，如何使层A的任意一段，均匀的分布于层B的100%？例如，使层 A的45%~67%均匀的分布于层B的100%。如果有这样超过十层，每两层之间都有这样的关系，怎么解决这个问题。

     这个问题想看懂都要认真看一下，可能我的描述也不是很清楚。

    二是算法题，2道，一共40分

    1. 假设有一个数N，此数最高位可以为0，如 020。 有一数M，满足，M中的各位数字之和与N的各位数字之和相等。M是这种数中，大于N的，最小的一个。这种关系描述为f(N)=M.  例如  N=134， M=143； N=020  M=101.

        设N开始为1000位的数，最大不超过10^500，有S1=f(N), S2=f(S1)......一直到S(i+1)为负数，则负数不输出，N，S1。。。。S（i）。

        写出算法思想和代码。

       这个题关键在找出f（）的规律来。

    2. 给你一个序列。如{1,2,3}

         1.输出所有全排列。{1,2,3} {1,3,2} {2,1,3}{2,3,1} {3,1,2} {3,2,1}，给出算法思想和伪代码

         2.输出所有组合。{1}{2}{3}{1,2}{1.3}{2,3}{1,2,3}，给出算法思想和伪代码

    三是系统题，1道，30分

    一个存储和检索海量数据的系统，10G内存，海量的数据。有这么几个字段：termID， urlnum， urlno1，urlno2.。。。。，urlno共用10万个。支持∩，∪，补等集合运算。

    1. 设计存储方法和检索方式，要求速度和资源利用率

    2. 设计支持多线程的检索模型

    3. 设计一个算法，对于∩，∪，补等运算：

             1.支持括号优先级

             2.支持截断，当找出最先的100个url时就停止检索

 

    这个题描述的比较笼统，但据说这个题百度经常考，大家可以去网上查一下。

 

 

 

笔试（阿里云）

2011-09-22 21:45

 

今天参加了两场笔试；一场是阿里云，另一场比较小（10道选择题）；

 

1.知道前序和中序，求二叉树；

 

2.数组A，有n个数，已知x，求数组中是否存在2个数的和为x；要求时间复杂度O（n）;用归并排序?

 

3.10个人，分2组，每组从矮到高；而且第一组比第二组要高；求有几种方法；

 

4.已知一个整数和一个二叉树；如已知数为：22；里面的节点是：10-5-7-4-12；则有2条路径；编程；

 

5.操作系统中：FIFO...LRU...以及相关的算法?

 

6.链表的逆序；

 

7.堆与栈的区别；

 

8.char  a[]="ABCDEFG";

 

   int  b=(int *)a;

 

   printf("%d",b);

 

***************************

 

A 97  B 98

把它们转化成二进制

 

32767

VC那么占4个字节，如果是TC则占2个字节

 

在C语言中，int类型、long类型、float类型、double类型和char类型数据，在16位和32位计算机中各占几个字节

16位

2,4,4,8,1

32位

4,4,4,8,1

********************************

 

9.设有以下宏定义：

#define N 3

#define Y(n)((N1)*n)

则执行语句：z=2 *(NY(51))；后，z的值为

A)出错      B)42       C)48       D)54

10.关于“&”“*”的使用；

 

11.a[3][4],用“&”“*”表示a[1][1]的；

 

http://bbs.yingjiesheng.com/forum.php?mod=viewthread&tid=80335&page=3

 

 

腾讯2012  校园招聘

 

腾讯笔试回忆

 

20道选择题

 

涉及到：物理地址转换，内存管理，sql语句，c++多态，sizeof，数据结构，算法。。。

两个程序填空

 

l  一个链表，实现归并排序

 

l  实现图的佛洛依德算法

 

 

 

Ps.今天的笔试感觉题量还是很大滴，有点蛋疼。

 

 

微软SDET面经(9月26日)

 

 

发信人: ddkk (【意涵团】听说痞子奋斗也能成英雄), 信区: Job

标  题: 微软SDET面经(9月26日)

发信站: 北邮人论坛 (Mon Sep 26 18:18:03 2011), 站内

 

面试3个小时，共三面每面1小时，三个面试官，感觉三轮面试是平行的，都是技术面

一面：英文自我介绍，问了几个基本概念，stack&heap, array&list, process&thread,然后写一个数组或链表的排序，自选方法，然后是一个算法题：给一个数组，求出两个元素和为a的所有组合。又问了一些开发测试的认识。

二面：介绍项目，又问了一些开放性问题，然后本来想问单链表有环检测的经典问题，但是我说见过了，就pass了，问了一道URL解析的问题，本质上是树的深度遍历，写完代码后又加了海量的条件等等深入问题。

三面：给一个字符串，打印字符的所有排列情况，这个没写出来，然后给出一个类似链表的数据结构，让随机取出100个元素。

总之三个小时的技术面实在伤不起啊，到最后都想不动了，其实都不难，学计算机的童鞋应该都能轻松应付吧。

最后祝大家都面试成功吧~

 

 

 

360笔试两道编程题（C语言实现）

 

36.请编程实现C语言标准库函数strncpy，要求使用C语言编写，不能调用现成的C标准库函数，函数原型如下：

char % strncpy (char * dest,cst char*src, size_t n);

 

37.请编程实现逆波兰表达式（后缀表达式）的计算，要求用C语言编写，函数原型如下：

double calcrpn(int opnum, char* opstr[]);

其中，opnum表示操作数/操作类的个数，opstr数组按顺序存放操作数/操作符。操作符支持加减乘除四则运算即可。

说明：逆波兰表达式是将运算符号写在操作数之后的表达式。例如：(1+2)*3的逆波兰表达式为12+3*

 

 

C语言不是很精通，所以会的朋友留下你们的答案！

 

 

2012淘宝校园招聘笔试

川大站笔试：（本人亲手经历）

1个小时的笔试时间，人还是非常多，快没有位置了。

选择题考察的面非常广，我记得住的只有下面几道题：

（1）进程死锁

（2）双链表插入节点

（3）插座问题：用树的知识解决

（4）平衡树的概念：红黑树，B数，AVL树

（5）ICMP协议在哪一层？

（6）一道概率题目：后概概率

（7）排列组合问题

（8）具体网络协议使用的什么协议问题：Http(TCP),SNMP(udp),TFTP（UDP），,FTP(TCP),telenet（TCP）连接，主要是后面对应的是TCP还是UDP。

TCP:FTP、Telnet、SMTP、HTTP、POP3

UDP:DNS、SNMP、QQ,tftp

（9）敲钟问题：没做

（10）sizeof问题

其余的选择题目记不住了。

填空题目

1.硬盘接口的四种类型

2.登陆验证使用什么记录信息（cookie）

3.java程序题，主要是++的使用

4.还是概率题（还是后概事件，做不来，忘记公式了）

编程题目

1、如何求树中的两个节点的公共祖先

2. 实现strncmp(const *char s1, const char* s2, int n)

 

杭州站笔试

http://topic.csdn.net/u/20110922/10/e4f3641a-1f31-4d35-80da-7268605d2d51.html

 

一、单选题
1、我们有很多瓶无色的液体，其中有一瓶是毒药，其它都是蒸馏水，实验的小白鼠喝了以后会在5分钟后死亡，而喝到蒸馏水的小白鼠则一切正常。现在有5只小白鼠，请问一下，我们用这五只小白鼠，5分钟的时间，能够检测多少瓶液体的成分（）
a 5瓶 b 6 c 31 d 32

2、若某链表最常用的操作是在最后一个结点之后插入一个结点和删除最后一个结点，则采用（）存储方式最节省时间？
A 单链表 B 带头结点的非循环双链表 C 带头节点的双循环链表 D 循环链表

3、如果需要对磁盘上的1000W条记录构建索引，你认为下面哪种数据结构来存储索引最合适？（）
A Hash Table B. AVL-Tree C. B-Tree D. List

4、可用来检测一个web服务器是否正常工作的命令是（）
A ping B tracert C. telnet D. ftp

5、下面哪个操作是Windows独有的I/O技术（）
A. Select B.Poll C.IOCP D. Epoll

6、IPV6地址包含了（）位
A. 16 B. 32 C. 64 D.128

7、数据库里建索引常用的数据结构是（）
A 链表 B队列 C 树 D 哈希表

8、在公司局域网上ping www.taobao.com没有涉及到的网络协议是（）
A. ARP B. DNS C. TCP D. ICMP

二、填空题
1、http属于（）协议，ICMP属于（）协议

2、深度为k的完全二叉树至少有（）个结点，至多有（）个结点

3、字节为6位的二进制有符号整数，其最小值是（）

4、设有28盏灯，拟公用一个电源，则至少需有4插头的接线板数（）个。

三、综合题
1、有一颗结构如下的树，对其做镜像反转后如下，请写出能实现该功能的代码。注意：请勿对该树做任何假设，它不一定是平衡树，也不一定有序。
  1 1
  / | \ / | \
  2 3 4 4 3 2
  /|\ /\ | | / \ / | \
  6 5 7 8 9 10 10 9 8 7 5 6
 
2、假设某个网站每天有超过10亿次的页面访问量，出于安全考虑，网站会记录访问客户端访问的ip地址和对应的时间，如果现在已经记录了1000亿条数 据，想统计一个指定时间段内的区域ip地址访问量，那么这些数据应该按照何种方式来组织，才能尽快满足上面的统计需求呢，设计完方案后，并指出该方案的优 缺点，比如在什么情况下，可能会非常慢？

四、附加题
1、写出C语言的地址对齐宏ALIGN（PALGNBYTES），其中P是要对齐的地址，ALIGNBYTES是要对齐的字节数（2的N次方），比如说：ALIGN(13,16)=16

2、在高性能服务器的代码中经常会看到类似这样的代码：
typedef union
{
  erts_smp_rwmtx_t rwmtx;
  byte cache_line_align_[ERTS_ALC_CACHE_LINE_ALIGN_SIZE(sizeof(erts_smp_rwmtx_t))];
}erts_meta_main_tab_lock_t;

erts_meta_main_tab_lock_t main_tab_lock[16];

请问其中用来填充的cache_line_align的作用是？

3、在现代web服务系统的设计中，为了减轻源站的压力，通常采用分布式缓存技术，其原理如下图所示，前端的分配器将针对不同内容的用户请求分配给不同的缓存服务器向用户提供服务。
  分配器
  / | \
  缓存 缓存 ...缓存
  服务器1 服务器2 ...服务器n

1）请问如何设置分配策略，可以保证充分利用每个缓存服务器的存储空间（每个内容只在一个缓存服务器有副本）

2）当部分缓存服务器故障，或是因为系统扩容，导致缓存服务器的数量动态减少或增加时，你的分配策略是否可以保证较小的缓存文件重分配的开销，如果不能，如何改进？

3）当各个缓存服务器的存储空间存在差异时（如有4个缓存服务器，存储空间比为4：9：15：7），如何改进你的策略，按照如上的比例将内容调度到缓存服务器？

 

 

 

2011-09-24百度笔试题（技术研发）85+%回忆版真题

 

今天去参加的百度笔试，凭记忆记住的百度的题，留个备份：笔试好像分3套卷子。我这套是技术类。研发什么的都是这套通用卷子。


一、简答
      1、系统又很多任务，任务之间有依赖，比如B依赖于A，则A执行完后B才能执行
            （1）不考虑系统并行性，设计一个函数（Task *Ptask,int Task_num）不考虑并行度，最快的方法完成所有任务。
            （2）考虑并行度，怎么设计
             typedef struct{
                int ID;
                int * child;
                int child_num;
        }Task;
        提供的函数:
                    bool doTask(int taskID);无阻塞的运行一个任务；
                    int waitTask(int timeout);返回运行完成的任务id，如果没有则返回-1；
                    bool killTask(int taskID);杀死进程
    2、堆和栈的生命周期，内存分配性能，不同处，如果一般情况下要求1KB，偶尔需要100MB的缓存空间怎么设计？
二、必答题（各种const）

1、解释下面ptr含义和不同（好像是。。。。题干了大概意思是这样。下面应该没错）

double* prt = &value

const double* ptr = &value

double* const ptr=&value

const double* const ptr=&value

2、去掉const属性，例：

      const double value = 0.0f;

      double* ptr = NULL;

怎么才能让ptr指向value？

三、算法设计

1、一个一维数轴上有不同的线段，求重复最长的两个线段。

例：a：1~3

        b:   2~7

        c：2~8

最长重复是b和c

 

2、有向带权图最短路径

四、系统设计

大概意思是：百度内部有一个类似cs系统的计算系统，由于大并发计算很耗资源，所有要设计一个缓存系统。c做缓存，配置 2.66MHZ,3G内存，大概有1000w个查询，唯一的查询大概有500w。要缓存24小时。设计这个缓存系统的运行机制，算法等等东西。。。。。记 不太清了。。。

---

第一次这么正事的参加一个笔试，准备不足啊。现在分享出来给大家看看吧。希望对大家有帮助。
笔试好像分3套卷子。我这套是技术类。研发什么的都是这套通用卷子。
还有个移动终端，还有个销售的卷子。。。我不知道。。。

 

 

 

1、一个一维数轴上有不同的线段，求重复最长的两个线段。

例：a：1~3

        b:   2~7

        c：2~8

最长重复是b和c

我的做法，大家看看对不对。
复杂度：O（nlogn）

typedef struct
{
        int b;
        int e;
}line;
void max_overlap(line * p, int cnt, int * a, int * b)
{
        int maxsofar = 0;
        int ending = 0;
        int index_max_e = 0;
        int i;
        int index_a = 0, index_b = 1;

        if (cnt < 2)
                return;

        sort(p, cnt );//按照line::b排序

        for (i = 1; i < cnt; i++)
        {
                ending = ((p+index_max_e)->e > (p + i)->e)?
                        ((p + i)->e - (p + i)->b):
                        ((p + index_max_e)->e - (p + i)->b);
                if (maxsofar < ending)
                {
                        maxsofar = ending;
                        index_a = index_max_e;
                        index_b = i;
                }
                if ((p + index_max_e)->e < (p + i)->e)
                        index_max_e = i;
        }

        *a = index_a;
        *b = index_b;
}

不知道有没有复杂度更低的算法。有的话指教我下了

 

 

 

【淘宝技术】两道笔试大题

 

记了个大概，

第一道是一个完全二叉树，给同层的每个节点添加一个指向右侧节点的指针（如右侧无节点为则空指针），

 

第二题是社交网络上可能加别人为好友，也 可能被别人加好友，或者与别人互为好友，根据这种特定关系设计一种数据结构进行存储。使用这种数据结构查找无效用户（与任何人无好友关系），尽量节约存储 空间和内存空间。