百度面试 01

 

百度技术研发笔试题目

 

 

/*百度面试题

 * 有一根27厘米的细木杆，在第3厘米、7厘米、11厘米、17厘米、23厘米这五个位置上各有一只蚂蚁。

 * 木杆很细，不能同时通过一只蚂蚁。开始 时，蚂蚁的头朝左还是朝右是任意的，它们只会朝前走或调头，

 * 但不会后退。当任意两只蚂蚁碰头时，两只蚂蚁会同时调头朝反方向走。假设蚂蚁们每秒钟可以走一厘米的距离。

 * 编写程序，求所有蚂蚁都离开木杆 的最小时间和最大时间。

 * 

 * 

 * 分析:题目中的蚂蚁只可能相遇在整数点,不可以相遇在其它点,比如3.5cm处之类的,也就是可以让每只蚂蚁走 1秒,然后

 * 查看是否有相遇的即可.

 * 

 * 这样我的程序实现思路就是,初始化5只蚂蚁,让每只蚂蚁走1秒,然后看是否有相遇的,如果有则做相应处理.当每只蚂蚁都

 * 走出木杆时,我就记录当前时间.这样就可以得到当前状态情况下,需要多久可以走出木杆,然后遍历所有状态则可以得到所胡

 * 可能.

 */

 

package baidu;

 

public class Ant {

 /*

  * step 表示蚂蚁每一个单位时间所走的长度

  */

 private final static int step = 1;

 

 /*

  * position表示蚂蚁所处的初始位置

  */

 private int position;

 

 /*

  * direction表示蚂蚁的前进方向，如果为1表示向27厘米的方向走， 如果为－1，则表示往0的方向走。

  */

 private int direction = 1;

 

 /*

  * 此函数运行一次，表示蚂蚁前进一个单位时间，如果已经走下木杆则会抛出异常

  */

 public void walk() {

  if (isOut()) {

   throw new RuntimeException("the ant is out");

  }

  position = position + this.direction * step;

 };

 

 

 /**

  * 检查蚂蚁是否已经走出木杆，如果走出返回true

  *

  */

 

 public boolean isOut() {

  return position <= 0 || position >= 27;

 }

 

 /**

  * 检查此蚂蚁是否已经遇到另外一只蚂蚁

  * @param ant

  * @return 如果遇到返回true

  */

 public boolean isEncounter(Ant ant) {

  return ant.position == this.position;

 }

 

 /**

  * 改变蚂蚁的前进方向

  */

 public void changeDistation() {

  direction = -1 * direction;

 }

 

 

 /**

  * 构造函数,设置蚂蚁的初始前进方向,和初始位置

  * @param position

  * @param direction

  */

 public Ant(int position, int direction) {

  this.position = position;

  if (direction != 1) {

   this.direction = -1;//方向设置初始位置,比如为0时,也将其设置为1.这样可以方便后面的处理

  } else {

   this.direction = 1;

  }

 }

 

}

 

 

 

/////////////////////////////////////////////////////////

 

 

package baidu;

 

public class Controller {

 

 public static void main(String[] args) {

 

  int time = 0;

  for (int i = 0; i < 32; i++) {

   Ant[] antArray = getAntList(getPoistions(), getDirections(i));

   while (!isAllOut(antArray)) {

    for (Ant ant : antArray) {

     if (!ant.isOut()) {

      ant.walk();

     }

    }

    time++;

    // 查看是否有已经相遇的Ant,如果有则更改其前进方向

    dealEncounter(antArray);

   }

   System.out.println(time);

 

   // 将时间归0,这样可以重新设置条件,再次得到全部走完所需要的时间.

   time = 0;

  }

 

 }

 

 /**

  * 这个函数的算法很乱，但暂时能解决问题

  * 

  * @param list

  */

 public static void dealEncounter(Ant[] antArray) {

 

  int num_ant = antArray.length;

  for (int j = 0; j < num_ant; j++) {

   for (int k = j + 1; k < num_ant; k++) {

    if (antArray[j].isEncounter(antArray[k])) {

     antArray[j].changeDistation();

     antArray[k].changeDistation();

    }

   }

  }

 

 }

 

 /**

  * 因为有5只Ant，所以组合之后有32种组合.刚好用5位二进制来表示,如果为0则表示Ant往0的方向走 如果为1,则表示往27的方向走

  * 

  * 注:在通过Ant的构造函数设置初始值时,通过过滤把0修改成了-1.

  */

 public static int[] getDirections(int seed) {

  int result[] = new int[5];

  result[0] = seed % 2;

  result[1] = seed / 2 % 2;

  result[2] = seed / 4 % 2;

  result[3] = seed / 8 % 2;

  result[4] = seed / 16 % 2;

 

  System.out.println("directions is " + result[0] + "|" + result[1] + "|"

    + result[2] + "|" + result[3] + "|" + result[4]);

 

  return result;

 

 }

 

 /**

  * 批量设置Ant的初始位置,这样设置不是十分必要,可以直接在代码中设置

  * 

  * @return

  */

 public static int[] getPoistions() {

  return new int[] { 3, 7, 11, 17, 23 };

 }

 

 /**

  * 取得设置好初始值的5只Ant

  * 

  * @param positions

  * @param directions

  * @return

  */

 public static Ant[] getAntList(int[] positions, int[] directions) {

  Ant ant3 = new Ant(positions[0], directions[0]);

  Ant ant7 = new Ant(positions[1], directions[1]);

  Ant ant11 = new Ant(positions[2], directions[2]);

  Ant ant17 = new Ant(positions[3], directions[3]);

  Ant ant23 = new Ant(positions[4], directions[4]);

 

  return new Ant[] { ant3, ant7, ant11, ant17, ant23 };

 }

 

 /**

  * 判断是否所有的Ant都已经走出了木杆,也就是设置退出条件

  * 

  * @param antArray

  * @return

  */

 public static boolean isAllOut(Ant[] antArray) {

  for (Ant ant : antArray) {

   if (ant.isOut() == false) {

    return false;

   }

  }

  return true;

 }

}

 

 

 

 

 

 

 

 

 

编程： 
用C语言实现一个revert函数，它的功能是将输入的字符串在原串上倒序后返回。
2 编程：
用C语言实现函数void * memmove(void *dest,const void *src,size_t n)。memmove
函数的功能是拷贝src所指的内存内容前n个字节
到dest所指的地址上。

3 英文拼写纠错：
在用户输入英文单词时，经常发生错误，我们需要对其进行纠错。假设已经有一个包
含了正确英文单词的词典，请你设计一个拼写纠错
的程序。
（1）请描述你解决这个问题的思路；
（2）请给出主要的处理流程，算法，以及算法的复杂度；
（3）请描述可能的改进（改进的方向如效果，性能等等，这是一个开放问题）。

4 寻找热门查询：
搜索引擎会通过日志文件把用户每次检索使用的所有检索串都记录下来，每个查询串
的长度为1-255字节。假设目前有一千万个记录，
这些查询串的重复度比较高，虽然总数是1千万，但如果除去重复后，不超过3百万个
。一个查询串的重复度越高，说明查询它的用户越多，
也就是越热门。请你统计最热门的10个查询串，要求使用的内存不能超过1G。
（1）请描述你解决这个问题的思路；
（2）请给出主要的处理流程，算法，以及算法的复杂度。

5 集合合并：
给定一个字符串的集合，格式如：
{aaa bbb ccc}， {bbb ddd}，{eee fff}，{ggg}，{ddd hhh}
要求将其中交集不为空的集合合并，要求合并完成后的集合之间无交集，例如上例应
输出
{aaa bbb ccc ddd hhh}，{eee fff}， {ggg}
（1）请描述你解决这个问题的思路；
（2）请给出主要的处理流程，算法，以及算法的复杂度
（3）请描述可能的改进（改进的方向如效果，性能等等，这是一个开放问题）。
////////////////////////////////1
1 题
char *revert(char * str)
{
int n=strlen(str);
int i=0;
char c;
for(i=0;i
{
c=str;
str=str[n-i];
str[n-i]=c;
}
return str;
}
///////////////////////////////////
2 题
void * memmove(void *dest,const void *src,size_t n)
{
assert((dest!=0)&&(src!=0));
char * temp=(char * )dest;
char * ss=(char * )src;
int i=0;
for(;i<N;I++)
{
*temp++=*ss++;
}
return temp;
}

/////////////////////////////////////////////////
3 题
(1)思路 : 
字典以字母键树组织，在用户输入同时匹配

(2)
流程:
每输入一个字母： 
沿字典树向下一层，
a）若可以顺利下行，则继续至结束，给出结果；
b)若该处不能匹配，纠错处理，给出拼写建议,继续至a）；
算法:
1.在字典中查找单词
字典采用27叉树组织,每个节点对应一个字母,查找就是一个字母
一个字母匹配.算法时间就是单词的长度k.
2.纠错算法
情况:当输入的最后一个字母不能匹配时就提示出错,简化出错处理，动态提示
可能 处理方法:
(a)当前字母前缺少了一个字母：搜索树上两层到当前的匹配作为建议；
(b)当前字母拼写错误：当前字母的键盘相邻作为提示；（只是简单的描述，可 
以有更多的）
根据分析字典特征和用户单词已输入部分选择(a),(b)处理

复杂性分析：影响算法的效率主要是字典的实现与纠错处理
（a）字典的实现已有成熟的算法，改进不大，也不会成为瓶颈；
(b)纠错策略要简单有效 ,如前述情况，是线性复杂度；
(3)改进
策略选择最是重要，可以采用统计学习的方法改进。

//////////////////////////////////////////////
4 题
(1)思路：
用哈希做
(2)
首先逐次读入查询串，算哈希值，保存在内存数组中，同时统计频度
（注意值与日志项对应关系）
选出前十的频度，取出对应的日志串，简单不过了。
哈希的设计是关键。 
//////////////////////////////////////////////////
5 题
（1）思路：先将集合按照大小排列后,优先考虑小的集合是否与大的集合有交集。有
就合并，如果小集合与所有其他集合都没有交集，则独立。独立的集合在下一轮的比
较中不用考虑。这样就可以尽量减少字符串的比较次数。当所有集合都独立的时候，
就终止。
（2）处理流程：
1.将集合按照大小排序，组成集合合并待处理列表
2.选择最小的集合，找出与之有交集的集合，
如果有，合并之；
如果无，则与其它集合是独立集合，从待处理列表 中删除。
3.重复直到待处理列表为空

算法：
1。将集合按照大小从小到大排序,组成待处理的集合列表。
2。取出待处理集合列表中最小的集合，对于集合的每个元素，依次在其他集合中搜索
是否有此元素存在：
1>若存在，则将此小集合与大集合合并，并根据大小插入对应的位置 。转3
。
2>若不存在，则在该集合中取下一个元素。如果无下一个元素，即所有元素
都不存在于其他集合。则表明此集合独立，从待处理集合列表中删除。并加入结果集
合列表。转3。
3。如果待处理集合列表不为空，转2。
如果待处理集合列表为空，成功退出，则结果集合列表就是最终的输出。
算法复杂度分析：
假设集合的个数为n，最大的集合元素为m
排序的时间复杂度可以达到n*log(n)
然后对于元素在其他集合中查找，最坏情况下为（n-1）*m
查找一个集合是否与其他集合有交集的最坏情况是m*m*(n-1)
合并的时间复杂度不会超过查找集合有交集的最坏情况。
所以最终最坏时间复杂度为O(m*m*n*n)
需要说明的是：此算法的平均时间复杂度会很低，因为无论是查找还是合并，都是处
于最坏情况的概率很小，而且排序后优先用最小集合作为判断是否独立的对象，优先
与最大的集合进行比较，这些都最大的回避了最坏情况。
(3)可能的改进：
首先可以实现将每个集合里面的字符串按照字典序进行排列，这样就可以将查找以及
合并的效率增高。
另外，可能采取恰当的数据结构也可以将查找以及合并等操作的效率得到提高。