爱奇艺秋季校招java工程师（第一场）-2018年

一、单项选择题

1、当分配给一个进程的页面数增加时，页故障数可能增大也可能变小，下述算法符合这种情况的是（ ）

A、FIFO算法

B、LRU算法

C、Clock算法

D、Clock算法

2、下面代码输出的结果为（ ）

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class Test{
    public static void main(String[] args) {
        List<Student> students = new ArrayList<Student>();
        students.add(new Student(10));
        students.add(new Student(18));
        students.add(new Student(15));
        Collections.sort(students);
        System.out.print(students.get(1).age);
    }
}
class Student implements Comparable<Student> {
    Integer age;
    public Student(Integer age) {
      this.age = age;
    }
    public int compareTo(Student s) {
        return s.age.compareTo(this.age);
    }
}

A、15

B、10

C、18

D、编译失败

3、一个提供NAT服务的路由器在转发一个源IP地址为10.0.0.1、目的IP地址为131.12.1.1的IP分组时，可能重写的IP分组首部字段是（ ）

Ⅰ.TTL

Ⅱ.片偏移量

Ⅲ.源IP地址

Ⅳ.目的IP地址

A、仅Ⅰ

B、仅I、Ⅱ

C、仅Ⅰ、Ⅱ、III

D、Ⅰ、Ⅱ、Ⅲ、Ⅳ

4、查看系统内存如下：

   [@server ~]# free -g
   total used free shared buffers cached
   Mem: 15 5 9 0 0 2
   -/+ buffers/cache: 3 12
   Swap: 0 0 0

那么程序实际可使用内存有多少（ ）

A、9G

B、11G

C、12G

D、21G

5、sql中，可以用来替换DISTINCT的语句是（ ）

A、ORDER BY

B、GROUP BY

C、DESC

D、HAVING

6、现定义如下三个类,

public class A{
    Private static A a = new A();
    Private A(){};
    Public static A getA(){
        return a;
    }
}
public class B{
    private static B b = null;
    private B(){};
    public static B getB(){
        b = new B();
        return b;
    }
}
public class C{
    private static C c = null;
    static{
        c = new C();
    }
    private C(){};
    public static C getC(){
        return c;
    }
}

请问属于单例模式的类是（ ）

A、classA和classB

B、classB和classC

C、只有classA

D、classA 和classC

7、java中如果需要将application/x-www-from-urlencode MIME字符转换为普通字符，可以使用下面哪个方法（ ）

A、URIEncode.encode(String s, String enc)

B、URLEncode.encode(String s, String enc)

C、URIDecode.decode(String s, String enc)

D、URLDecode.decode(String s, String enc)

8、若前缀表达式为-+a*b-cd/ef，后缀表达式为abcd-*+ef/-，那么对应二叉树的中序遍历序列是（ ）

A、a+c*d-b-e/f

B、a+b*c-d-e/f

C、a+b*d-c-e/f

D、a+e*c-d-b/f

9、下面关于选择排序说法正确的是（ ）

A、每扫描一遍数组，需要多次交换

B、选择排序是稳定的排序方法,因为时间复杂度是固定的O（n^2）

C、选择排序排序速度一般要比冒泡排序快

D、空间复杂度为O（1）

10、设置tcp的哪个socket参数会影响了 nagle算法（ ）

A、TCP_MAXSEG

B、TCP_KEEPALIVE

C、TCP_SYNCNT

D、TCP_NODELAY

二、编程题

1、对于任意两个正整数x和k,我们定义repeat(x, k)为将x重复写k次形成的数,例如repeat(1234, 3) = 123412341234,repeat(20,2) = 2020.

牛牛现在给出4个整数x1, k1, x2, k2, 其中v1 = (x1, k1), v2 = (x2, k2),请你来比较v1和v2的大小。

2、一个合法的括号匹配序列有以下定义:

(1)、空串""是一个合法的括号匹配序列

(2)、如果"X"和"Y"都是合法的括号匹配序列,"XY"也是一个合法的括号匹配序列

(3)、如果"X"是一个合法的括号匹配序列,那么"(X)"也是一个合法的括号匹配序列

(4)、每个合法的括号序列都可以由以上规则生成。

例如: "","()","()()","((()))"都是合法的括号序列

对于一个合法的括号序列我们又有以下定义它的深度:

(1)、空串""的深度是0

(2)、如果字符串"X"的深度是x,字符串"Y"的深度是y,那么字符串"XY"的深度为max(x,y) 3、如果"X"的深度是x,那么字符串"(X)"的深度是x+1

例如: "()()()"的深度是1,"((()))"的深度是3。牛牛现在给你一个合法的括号序列,需要你计算出其深度。

3、考虑定义在两正整数上的函数SSR(平方根之和的平方):SSR(A, B) = (sqrt(A) + sqrt(B))^2。牛牛对函数值为整数的情况很感兴趣。现在给定整数n和m,请帮助牛牛计算有序对(A, B)的数量, 满足1 ≤ A ≤ n, 1 ≤ B ≤ m而且SSR(A, B)是一个整数。

参考答案

一、

1~5：AACCB

6~10：DDBDD

二、

1、

public class Test {
    public static String repeat(String str){
        String []nums=str.split("\\s+");
        for(int i=0;i<nums.length;i++){
            if(nums[i].length()==0&&null==nums[i]){
                return null;
            }
        }
         
        int x1=Integer.parseInt(nums[0]);
        int k1=Integer.parseInt(nums[1]);
        int x2=Integer.parseInt(nums[2]);
        int k2=Integer.parseInt(nums[3]);
         
        if(x1<0&&k1<0&&x2>Math.pow(10, 9)&&k2>50){
            return null;
        }
         
        StringBuffer s1=new StringBuffer();
        StringBuffer s2=new StringBuffer();
         
        for(int i=1;i<=k1;i++){
            s1.append(x1);
        }
         
        for(int i=1;i<=k2;i++){
            s2.append(x2);
        }
         
        long num1=Long.parseLong(s1.toString());
        long num2=Long.parseLong(s2.toString());
         
        if(num1<num2){
            return "Less";
        }else if(num1==num2){
            return "Equal";
        }else {
            return "Greater";
        }       
    }   
}

2、

class Solution {
public:
    int longestConsecutive(vector<int> &num) {
        unordered_set<int> s(num.begin(),num.end());
        int res=1;
        for(auto val:num)
        {
            if(s.find(val)==s.end())
                continue;
            s.erase(val);
            int pre=val-1;
            int post=val+1;
            while(s.find(pre)!=s.end())
            {
                s.erase(pre--);
            }               
            while(s.find(post)!=s.end())
            {
                s.erase(post++);
            }
            res=max(res,post-pre-1);
        }
        return res;
    }
};

3、

#include<stdio.h>
#include<map>
#include<algorithm>
using namespace std;
const int MAXN=100005;
int prime[MAXN+1],factor[100][2];
void getPrime();
int getFactors(int);
int main(){
    int n,m,res=0,i;
    getPrime();
    scanf("%d%d",&n,&m);
    map<int,int> mpn,mpm;
    for(i=1;i<=n;i++) mpn[getFactors(i)]++;
    for(i=1;i<=m;i++) mpm[getFactors(i)]++;
    map<int,int>::iterator it;
    for(it=mpn.begin();it!=mpn.end();it++)
        if(mpm.count(it->first))
            res+=it->second*mpm[it->first];
    printf("%d",res);
}
void getPrime(){
    for(int i=2;i<=MAXN;i++){
        if(!prime[i])prime[++prime[0]]=i;
        for(int j=1;j<=prime[0]&&prime[j]<=MAXN/i;j++){
            prime[prime[j]*i]=1;
            if(i%prime[j]==0) break;
        }
    }
}
int getFactors(int x){
    int fatCnt=0,tmp=x,res=1,i;
    for(i=1;prime[i]<=tmp/prime[i];i++){
        factor[fatCnt][1]=0;
        if(tmp%prime[i]==0){
            factor[fatCnt][0]=prime[i];
            while(tmp%prime[i]==0){
                factor[fatCnt][1]++;
                tmp/=prime[i];
            }
            fatCnt++;
        }
    }
    if(tmp!=1){
        factor[fatCnt][0]=tmp;
        factor[fatCnt++][1]=1;
    }
    for(i=0;i<fatCnt;i++)
        if(factor[i][1]%2) res*=factor[i][0];
    return res;
}