爱奇艺笔试复盘 Java方向

在Lnux内核中,创建个文件操作可以使用()

A. write

B. fopen

C. open

D. create

C.

关于结点数相同的折半判定树和完全二叉树,以下说法正确的是()

A. 折半判定树的高度比完全二叉树高度大

B. 折半判定树的高度与完全二叉树高度没有关系

C. 折半判定树的高度比完全二叉树高度小

D. 折半判定树的高度与完全二叉树高度一致

A.

以下关于静态方法和静态变量,说法正确的是

A. 静态方法不能调用实例方法或引用一个实例变量

B. 实例方法可以任意调用方法

C. 实例方法不能调用静态方法或引用一个静态变量

D. 静态方法可以互相调用

AD.

除了访问限定符的情况下,一些方法不能调用;至少实例方法不能直接调用超类的类方法

前辈节点: 层号比该结点小的结点

请问下图的UM是什么设计模式?()

A. 模板方法模式

B. 责任链横式

C. 迭代器模式

D. 命令模式

关于队列,下列说法错误的是()

A. 在非空循环队列中,队头指针指向当前的队头元素

B. 允许删除的一端称为队头

C. 允许插入的一端称为队尾

D. 入队操作是在队头执行的

D.

设n位同学从左到右依次编号为1,2,…n,合唱队形需使队列满足T1Tn-1>Tn现已知有10个学生的身高(厘米)为:150、172、163、180、178、160、172、154、165、158,计算他们所组成的最长合唱队队形的长度为多少

A. 6

B. 5

C. 8

D. 7

D. 150、172、180、178、172、165、158

A. 该抽象类可以被实例化

B. 该抽象类的子类对象要调用show方法,必须对Animal中的show方法进行重写。

C. 该抽象类不能被继承。

D. 该抽象类中不能定义实例方法move

B.
不管对实例化的理解是什么,定义上抽象类不能被实例化。抽象类只在分配了在栈中的引用,没有分配堆中的内存。

MyISAM引擎的表 tg_user,主键为tg_id,tg_email是允许为空的列,下列确统计出该表记录数的语句是()

A. SELECT count(*) FROM tg_user

B. SELECT count(tg_id) FROM tg_user

C. SELECT count(tg_email) FROM tg_user

D. SELECT count(1) FROM tg_user

ABD.

下面关于 try-catch-finally语句块,描述正确的是

A. catch可以和final单独使用

B. try-catch-final块中的语句都可以被执行

C. 如果try中的语句抛出异常,程序会跳过try块中剩余的语句,开始查找处理这个异常的代码

D. try可以和 catch单独使用

BCD.

如果在带权有向图中,用顶质点表示事件,用有向边表示小活动,边上的权值表示活动的开销,则此带权有向图称为AOE网。AOE网是一个有向无AOE网如下图所示,则关键路径(即路径长度最长)的长度为

A. 13

B. 24

C. 23

D. 21

C.

以下关于 synchronized述不正确的是

A. 当一个线程访问某对象的 synchronized方法或者 synchronized代码块时,其他线程可以访问该对象的其他的 synchronized.方法或者 synchronized 代码块

B. 当一个线程访问某对象的 synchronized方法或者 synchronized代码块时,其他线程对该对象的该 synchronized方法或者 synchronized代码块的访问将被阻塞

C. 个线程访问某对象的 synchronized方法或者 synchronized代码块时,其他线程仍然可以访问该对象的非同步代码块

D. 当在对象上调用其任意 synchronized方法的时候,对象都被加锁

A.

下面关 wait()和sleep()两个方法描述错误的是()

A. wait()无参方法调用后,线程阻塞,需要其他线程只能使用notify()方法才能唤醒。而 sleep()可以在时间到后醒来继续运行

B. wait()方法属于 Object的方法,而sleep()方法属于 Thread类的方法

C. 两个方法都需要 InterruptedException异常处理

D. wait()方法可以有参数,也可以无参数; sleep()方法必须要传入long的参数

C.

A. 6144

B. 8300

C. 5703

D. 4831

AD.

在解决汉诺塔问题时,可使用哪种数据结构进行设计

A. 队列

B. 数组

C. 栈

D. 二叉树

C.

关于Java以下描述正确的有()

A. Class类可以装载其它类

B. Class类是 Object类的超类

C. Object类是一个final类

D. String类是一个final类

AD.

Class是Java中的java.lang.Class类。这个类用于记录Java中每个类的类型信息,并且jvm在类加载时会为每个类生成一个Class<A>的Class对象在Java堆中,每个A类型的实例都要通过这个Class对象来进行实例化。

下列关于时间复杂度的计算说法不正确的是()

A. 嵌套循环为循环体内计算时间与所有循环次数的乘积

B. for/while循环时间计算为循环体内计算时间与循环次数计算的乘积

C. 顺序语句为各语句计算时间的和

D. if-else语句为语句计算时间与else语句计算时间的和

D.

A. 2018/8/20

B. 08/20/18 19:08:00

C. 2018/8/20 19:08:00

D. 08/20/18

D.

使用printf格式化日期,printf 方法可以很轻松地格式化时间和日期。使用两个字母格式,它以 %t 开头并且以下面表格中的一个字母结尾。

转  换  符说    明示    例
c包括全部日期和时间信息星期六 十月 27 14:21:20 CST 2007
F"年-月-日"格式2007-10-27
D"月/日/年"格式10/27/07
r"HH:MM:SS PM"格式(12时制)02:25:51 下午
T"HH:MM:SS"格式(24时制)14:28:16
R"HH:MM"格式(24时制)14:28
多个 ALOHA用户每秒产生60个请求,时间槽单位为20ms,则首次成功发送的概率为多少()

A. 0.1

B. 0.167

C. 0.3

D. 0.05

第1道

假设有N个人要玩游戏,每轮游戏必须选出一个人当我判,剩下的N-1个人作为玩家。现在第个人要求作为玩家进行至少A轮游戏,那么至少需要进行多少轮游戏才能满足所有人的要求?

输入描述:

第一行包含一个整数N,2≤N≤10^5。
第二行包含N个空格隔开的整数A1到AN,0≤Ai≤10^9。

输出描述:

输出至少需要进行的游戏轮数。

示例1

输入:

3
2 2 3

输出:

4
import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();
        int[] a = new int[N];
        int maxValue = Integer.MIN_VALUE;
        long sum = 0;
        long res = 0;
        for (int i = 0; i < N; i++) {
            a[i] = sc.nextInt();
            maxValue = Math.max(maxValue, a[i]);
            sum += a[i];
        }
        sc.close();
        long low = maxValue;
        long high = sum;
        while (low <= high) {
            long mid = (low + high) / 2;
            if (mid * N - sum >= mid) {
                res = mid;
                high = mid - 1;
            } else
                low = mid + 1;
        }
        System.out.println(res);
    }
}

第2道

首先给出一个长度为k=2^n(其中n为正整数)的序列A={a1,a2…a_{k-1},ak},我们定义一个值v,这个值是由如下计算方法得到的,首先将A序列的第 i 位和第 i+1 位进行 OR 操作得到新数列A‘,然后再对A’序列操作,将A’ 序列的第 i 位和第 i+1 位进行 XOR 操作得到A‘’,对A‘’按照第一次操作方式进行OR操作,因为序列长度为2^n,所以显然进行n次操作之后就只剩下一个数字了,此时这个数字就是v。
 例如A={1,2,3,4},第一次操作之后为{1|2=3,3|4=7},第二次操作后,{3^7=4},所以v=4。
 但是显然事情并没有那么简单,给出A序列后,还有m个操作,每个操作表示为“a b”,表示将A[a]改为b,之后再对A序列求v值。(注意每一次对序列的修改的永久的,即第i次修改是建立在前i-1次修改之上的)

输入描述:

输入第一行包含两个正整数n,m,分别表示A序列的长度为2^n,操作数量为m。(1<=n<=17,1<=m<=10^5)
输入第二行包含n个正整数,中间用空格隔开,表示A序列。(0<=ai<=2^30)
接下来有m行,每行包含两个正整数a,b,表示一次操作,即把A[a]变成b。

输出描述:

输出包含m行,第i行表示进行了第i次操作之后,A序列的v值。

示例1

输入:

2 4
1 2 3 4
1 4
3 4
1 3
1 3

输出:

1
2
7
7
import java.util.Scanner;
public class T2 {
    static int[][] res;

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();
        int M = sc.nextInt();
        int len = (int) Math.pow(2, N);
        res = new int[N + 1][len];
        for (int i = 0; i < len; i++) {
            res[N][i] = sc.nextInt();
        }
        fill(N, true, len);

        for (int i = 0; i < M; i++) {
            int a = sc.nextInt();
            int b = sc.nextInt();
            res[N][a - 1] = b;
            process(N, a - 1, b, true);
            System.out.println(res[0][0]);
        }
        sc.close();
    }

    private static void process(int n, int a, int b, boolean flag) {
        if (n == 0) return;
        int other = -1;
        if (a % 2 == 0) other = a + 1;
        else other = a - 1;
        if (flag) {// OR
            res[n - 1][a / 2] = res[n][a] | res[n][other];
        } else {// XOR
            res[n - 1][a / 2] = res[n][a] ^ res[n][other];
        }
        process(n - 1, a / 2, res[n - 1][a / 2], !flag);
    }

    private static void fill(int n, boolean flag, int len) {
        if (n <= 0) {
            return;
        }
        if (flag) {// OR
            for (int i = 0; i < len; i += 2) {
                res[n - 1][i / 2] = res[n][i] | res[n][i + 1];
            }
        } else {// XOR
            for (int i = 0; i < len; i += 2) {
                res[n - 1][i / 2] = res[n][i] ^ res[n][i + 1];
            }
        }
        fill(n - 1, !flag, len / 2);
    }
}