2017滴滴前端笔试题总结

总结了2017滴滴前端笔试题，欢迎指正、讨论

一、基础题

1.【单选】对于满足SQL92标准的SQL语句：SELECT foo,count(foo) FROM pokes WHERE foo>10 GROUP BY foo HAVINGORDER BY foo,其执行的顺序应为（）

A. From –>GroupBY->WHERE->HAVING->SELECT->ORDER BY

B. From->WHERE –>GroupBY ->HAVING->SELECT->ORDER BY

C. From->WHERE –>GroupBY ->HAVING->ORDER BY ->SELECT

D. From->WHERE ->ORDERBY–>Group BY ->HAVING->SELECT

参考：B

SQL查询中用到的关键词主要包含6个

SQL的语法顺序：

SELECT -> FROM ->WHERE->GROUP BY-> HAVING-> UNION-> ORDER BY

SQL的执行顺序：

FROM -> WHERE ->GROUPBY ->HAVING ->SELECT ->UNION ->ORDER BY

 

2.【单选】浏览器中可以使用LRU（least recently used）内存淘汰旧数据的策略，如果内存需要加载新数据但又空间不足，则会按照最近访问时间进行排序，并将最老的数据淘汰，假设现在内存空间大小为6，原本内存中没有数据，对内存中的数据的访问顺序如下：1,2,5,3,4,6,1,4,3,6,7,8,3,9，则缺页次数为（）

A. 4

B. 9

C. 10

D. 5

参考：C

内存为6，当第7个页面进入时，如果没在内存中，则淘汰最前（最老）的页面，如果在内存中，则将该页面调整到最末（最新）位置。

计算过程如下表：

原内存	当前进入页面	现内存	缺页次数
空	1,2,5,3,4,6（前6次）	1,2,5,3,4,6	6
1,2,5,3,4,6	1	2,5,3,4,6,1	6
2,5,3,4,6,1	4	2,5,3,6,1,4	6
2,5,3,6,1,4	3	2,5,6,1,4,3	6
2,5,6,1,4,3	6	2,5,1,4,3,6	6
2,5,1,4,3,6	7	5,1,4,3,6,7	7
5,1,4,3,6,7	8	1,4,3,6,7,8	8
1,4,3,6,7,8	3	1,4,6,7,8,3		9
1,4,6,7,8,3	9	4,6,7,8,3,9		10

 

3. 【单选】若数据元素序列为11,12,13,7,8,9,23,4,5是采用下列排序方法之一得到的第二趟排序后的结果，则该排序算法只能是（）

A. 插入排序

B. 冒泡排序

C. 选择排序

D. 归并排序

参考：D

 

4. 【单选】以下哪个指令对象不可以用来做对象（obj）文件的分析？

A. objump

B. nm

C. readelf

D. ar

参考：C

linux 的库操作命令，OBJ文件格式分析工具: objdump, nm,ar

 

5.【单选】深度学习中，softmax是一个常用的函数，计算公式如下 ：

softmax[x(i)] =exp[x(i)] / sum[exp[x(i)]], {I , j = 1 … N},

当这个函数的输入序列{x0, x1, x2, x3…}为非常小的负数时，如下描述正确的是（）

A. 分母下溢，结果异常

B. 分子下溢，结果正常

C. 分母上溢，结果异常

D. 分子上溢，结果正常

参考：A

 

6.【单选】小桔A在事务1中第一次读取年龄为20岁的员工总数为1000人，之后小桔B在事务2中增加了100名年龄20岁的员工，之后小桔A在事务1中在次读取年龄20岁的员工数发现总数变为1100，属于（）

A. 不可重复读

B. 脏读

C. 幻读

参考：C

脏读：一个事务读到另一个事务，尚未提交的修改，就是脏读。

不可重复读：在同一个事务中，再次读取数据时（select操作），所读取的数据，和第1次读取的数据，不一样了。就是不可重复读。

幻读：事务1读取指定的where子句所返回的一些行。然后，事务2插入一个新行，这个新行也满足事务1使用的查询where子句。然后事务1再次使用相同的查询读取行，但是现在它看到了事务2刚插入的行。

 

7.【单选】UDP最大包长度（）

A. 1024

B. 512

C. 65535

D. 无限制

参考：C

 

9.【单选】假定T是一个C++类，下列语句执行之后，内存里创建了（）个对象。

T a();

T b(5);

T c[6];

T &d = b;

T e = b;

T *p = new T(4);

A. 9

B. 6

C. 10

D. 13

参考：C

T a();  //+1

T b(5); //+1

T c[6]; //+6

T &d = b;

T e = b; // +1

T *p = new T(4);// +1

1+1+6+1+1=10

 

9.【单选】设栈S和队列Q的初始状态均为空，元素abcdefg依次进入栈S，若每个元素出栈后立即进入队列Q，且7个元素出队的顺序是bdcfeag，则栈S的容量至少是（）

A. 2

B. 1

C. 4

D. 3

参考：C

栈：先进后出 队列：先进先出所以出栈的顺序是bdcfeag

入栈	出栈	栈内元素
a		a
b		ba
	b	a
c		ca
d		dca
	d	ca
	c	a
e		ea
f		fea
	f	ea
	e	a
	a
g		g
	g
abcdefg	bdcfeag	Max = 3

 

 

10.【单选】在以B+树数据结构索引存储的关系型数据库中，假设表R只有一个联合唯一索引（a,b,c），请问下面哪个查询条件，无法使用该索引进行加速查询（）

A. select * from Rwhere a = ‘1’ and b = ‘1’;

B. select * from Rwhere a = ‘1’ and c = ‘1’;

C. select * from Rwhere b = ‘1’ and c = ‘1’;

D. select * from Rwhere a = ‘1’ and b = ‘1’ and c = ‘1’;

参考：C

查询条件中出现联合索引第一列,或者全部,则能利用联合索引。查询条件中没有出现联合索引的第一列,而出现联合索引的第二列,或者第三列,都不会利用联合索引查询。

 

二、智力题

 略

三、编程题

1.

题目描述：

给定无序整数序列，求连续子串最大和。

输入描述：

输入为整数序列，数字用空格分隔。例：-23 17 – 7 11 -2 1 -34

输出描述：

输出位子序列的最大和。例：21

思路：

遍历依次，求从第一个数开始累加的和，并记录最大值和最小值，最小值和最大值的差就是子序列最大的和。

package coding;

import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
        String nextLine = in.nextLine();
        String[] splits = nextLine.split(" ");
        ArrayList A = new ArrayList();
        for (int i = 0; i < splits.length; i++) {
        	A.add(Integer.parseInt(splits[i])) ;
        }
		
		
		if(A==null||A.size()==0) return ;    
	     ArrayList result = new ArrayList();  
	     result.add(-1);  
	     result.add(-1);  
	     int min = 0;  
	     int max = Integer.MIN_VALUE;  
	     int minpos = -1;  
	     int sum = 0;  
	          
	     for(int i = 0;i max){  
	             result.set(0 , minpos);  
	             max = sum - min;  
	             result.set(1 , i);  
	         }  
	              
	         if(sum < min){  
	             min = sum;  
	             minpos = i;  
	         }  
	     }  
	     int temp = result.get(0);  
	     result.set(0 , temp + 1); 
	     int re = 0;
	     for(int i = result.get(0); i <= result.get(1); i ++){
	    	 re += A.get(i);
	     }
	     System.out.println(max);  
	}
}

 

2.

题目描述：

给定无序整数序列，求其中第K大的数。

输入描述：

输入的第一行为整数序列，数字用空格分隔。例：45 67 33 21

输入的第二行一个整数K，K在数组长度范围以内。例：2

思路：采用两个指针left和right，分别从数组起始和末尾开始查找，满足left左侧的元素小于等于current值，right右侧的元素大于等于current，直至left = right。返回left指针位置，根据left和K的关系，确定下一步的查找范围。

 

package cn.thinking17;
import java.io.*;
import java.util.*;
public class NOK {
	 public static void main(String args[])
    {
        Scanner in = new Scanner(System.in);
        String nextLine = in.nextLine();
        int kth = in.nextInt();
        String[] splits = nextLine.split(" ");
        int[] numbers = new int[splits.length];
        for (int i = 0; i < numbers.length; i++) {
        	numbers[i] = Integer.parseInt(splits[i]);
        }
        System.out.println(kthLargestElement(2, numbers));
    }
    
    public static int kthLargestElement(int k, int[] nums) {
        if (nums == null || nums.length == 0) {
            return 0;
        }
        if (k <= 0) {
            return 0;
        }
        return helper(nums, 0, nums.length - 1, nums.length - k + 1);
        
    }
    public static int helper(int[] nums, int l, int r, int k) {
        if (l == r) {
            return nums[l];
        }
        int position = partition(nums, l, r);
        if (position + 1 == k) {
            return nums[position];
        } else if (position + 1 < k) {
            return helper(nums, position + 1, r, k);
        }  else {
            return helper(nums, l, position - 1, k);
        }
    }
    public static int partition(int[] nums, int l, int r) {
        int left = l, right = r;
        int pivot = nums[left];
        while (left < right) {
            while (left < right && nums[right] >= pivot) {
                right--;
            }
            nums[left] = nums[right];
            while (left < right && nums[left] <= pivot) {
                left++;
            }
            nums[right] = nums[left];
        }
        nums[left] = pivot;
        return left;         
    }
	
}