爱奇艺笔试复盘 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);
    }
}

Media笔试复盘

在 MySQL的UTF-8字符集下,执行CHAR_LENGTH('美云Meicloud')和 LENGTH('美云 Meicloud')的结果分别为

A. 10 10

B. 14 10

C. 10 14

D. 10 12

C.

length:   是计算字段的长度一个汉字是算三个字符,一个数字或字母算一个字符
char_length:不管汉字还是数字或者是字母都算是一个字符

以下代码输出正确的是()。
public class Test {
    public static void main(String[] args) {
        Integer i1 = 1;
        Integer i2 = 1;
        Integer i3 = 128;
        Integer i4 = 128;
        System.out.println(i1 == i2);
        System.out.println(i3 == i4);
    }
}

A. false false

B. false true

C. true false

D. true true

C.

Integer的缓存区,默认[-128,127],很经典了。

代码 String s= new String"meicloud");创建了多少个字符串对象()。

A. 1

B. 2

C. 3

D. 4

B.

首先在String常量池内找,找到?不创建String对象,否则创建, 这样就一个String对象
遇到new运算符号了,在堆内存上创建String对象,并将其返回给s,s在栈中的一个引用,又一个对象

Spring事务的默认传播方式是()

A. REQUIRES_NEW

B. REQUIRED

C. NESTED

D. MANDATORY

B.

Propagation (事务的传播属性)
默认是 REQUIRED 需要事务,上下文已有事务,直接使用,没有新建事务;
REQUIRES_NEW 新建事务, 上下文已有事务,则挂起当前事务,新建事务,执行事务后,恢复上下文事务;
MANDATORY强制要求有事务,没有事务,就抛出异常;
NESTED理解Nested的关键是savepoint。与REQUIRES_NEW的区别是,REQUIRES_NEW另起一个事务,将会与他的父事务相互独立,而Nested的事务和他的父事务是相依的,他的提交是要等和他的父事务一块提交的。也就是说,如果父事务最后回滚,他也要回滚的。而Nested事务的好处是他有一个savepoint。

我们通常所说的监听器诸如应用启动监听器等,其使用的设计模式为()

A. 状态模式

B. 观察者模式

C. 访问者模式

D. 代理模式

B. 这几个设计模式辨识度很高。

在关系数据库设计中,设计关系模式属于数据库设计的哪个阶段()

A. 需求分析阶段

B. 概念设计阶段

C. 逻辑设计阶段

D. 物理设计阶段

C. 关系模式理解为表,而不是E-R图。

链接:https://www.nowcoder.com/questionTerminal/ecb857187a4546fabb4e70de747294e1
来源:牛客网

数据库设计包括六个主要步骤:
1、需求分析:了解用户的数据需求、处理需求、安全性及完整性要求;
2、概念设计:通过数据抽象,设计系统概念模型,一般为E-R模型;
3、逻辑结构设计:设计系统的模式和外模式,对于关系模型主要是基本表和视图;
4、物理结构设计:设计数据的存储结构和存取方法,如索引的设计;
5、系统实施:组织数据入库、编制应用程序、试运行;
6、运行维护:系统投入运行,长期的维护工作

以下关于线程 yield()与sleep()描述不正确的是

A. 调用yield()或 sleep()后,线程都处于可运行状态;

B. yield()仅给优先級相同或更高的线程更高的执行机会

C. yield()不显式捕获任何异常,而 sleep() 显式捕了 InterruptedException异常

D. sleep比yield方法有更好的可移植性

A.

  • sleep()使当前线程进入停滞状态,所以执行sleep()的线程在指定的时间内肯定不会执行;yield()只是使当前线程重新回到可执行状态,所以执行yield()的线程有可能在进入到可执行状态后马上又被执行。
  • 其他三点见选项
HashMap的默认容量为多少()。

A. 8

B. 12

C. 16

D. 4

C.

MySQL中 Varchar(50)的50代表()

A. 最多可存储50个字节

B. 最多可存储50个字符

C. 虚值,不代表任何意义

D. 最多可存储50位

B.

D肯定错的,因为Varchar还需要1到2位存储可变字符串的长度。

VARCHAR列中的值为可变长字符串。长度可以指定为0到65535之间的值。VARCHAR的最大有效长度由最大行大小和使用的字符集确定。
在MySQL 4.1之前的版本,VARCHAR(50)的“50”指的是50字节(bytes)。如果存放UTF8汉字时,那么最多只能存放16个(每个汉字3字节)。
从MySQL 4.1版本开始,VARCHAR(50)的“50”指的是50字符(character),无论存放的是数字、字母还是UTF8汉字(每个汉字3字节),都可以存放50个。

关于并发编程根源描述正确的是()

A. 缓存导致可见性问题;

B. 线程切换带来的原子性问题

C. 编译优化带来的有序性问题

D. 以上描述都对

D.

以下代码输出正确的是()。
public class Test {
    public static void main(String[] args) {
        String s1 = "meicloud";
        String s2 = new String("meicloud");
        String s3 = "mei" + "cloud";
        System.out.println(s1 == s2);
        System.out.println(s1 == s3);
        System.out.println(s1 == s1.intern());
    }
}

A. true true false

B. true false true

C. true false false

D. false true true

D. 字符串常量池,很经典的题目了

MySQL的 innodb存储引擎的默认事务隔离级别为

A. SERIALIZABLE

B. REPEATABLE_READ

C. READ_COMMITTED

D. READ_UNCOMMITTED

B.

MySQL索引使用的数据结构为()

A. 平衡二叉树

B. 红黑树

C. B+树

D. B-树

C.

都是概念和知识型的,没有多少推断。

关于 final-关键字说法正确的是

A. String类被final关键字修饰,因此无法再继承;

B. 被final关键字修饰的基础类型变量,诸如int、byte等,不可再重新赋值

C. 被final关键字修饰的容器类型变量,诸如set、Map等,不可再往容器内添加元素

D. 被final关键字修饰的方法,不可被重写;

ABD.

设计模式中适配器横式的角色包括

A. Target

B. Adapter

C. Adaptee

D. Strategy

ABC.

Reds的持久化方式包括

A. AOF

B. RDB

C. RDB-AOF

D. MDB

AB.

以下排序算法中具备稳定性的是

A. 堆排序法

B. 快速排序法

C. 归并排序法

D. 基数排序法

CD.

58同城后端笔试复盘

下图是一个B+树的结构,做 range操作(26,35),总共需要查找()次

A. 8

B. 9

C. 10

D. 11

为什么我感觉是6。还是不知道选什么。

查找26、35在第一个磁盘块,各查找了1次;在第2个磁盘块查找26,第三个磁盘块查找35,各1次;在第7个磁盘块查找26,在第9块磁盘块查找35;一共6次啊。之后用B+树的叶子节点链表遍历,不用查找了吧。

机器间传输数据,发送端发送2096字节的数据,接收端会出现丢失部分数据情兄(传输协议使用:UDP),引起这问题最大可能原因()

A. 网络环境问题

B. 接收端网卡问题

C. 数据长度大于接收端缓冲区

D. 网络传输分包

C.
虽然UDP的报文长度最大可以达到64 kb,但是当报文过大时,稳定性会大大减弱。这是因为当报文过大时会被分割,使得每个分割块的长度小于MTU。以太网的MTU通常是1500 bytes,其他一些诸如拨号连接的网络MTU值为1280 bytes。 网络传输分包是要分割的,但不能分得太大。
发送的包较大,超过接受者缓存导致丢包:包超过mtu size数倍,几个大的udp包可能会超过接收者的缓冲,导致丢包。这种情况可以设置socket接收缓冲。调整接收缓冲设置的大小。

Socket 读缓冲区、写缓冲区 默认大小122k好像。通过以下配置修改:
/proc/sys/net/core/rmem_max
/proc/sys/net/core/wmem_max

下列哪种方法不能用来减小过拟合?

A. 更少的训练数据

B. L1正则化

C. L2正则化

D. 减小模型的复杂度

A.
减少过拟合的方法; https://www.zhihu.com/question/59201590

  • 获取更多数据
  • 使用合适的模型
  • 结合多种模型
  • 贝叶斯方法
假设电文A,B,C,D,E的权值为5,6,9,10,15则报文 AECDB的哈夫曼编码为()

A. 101001110010

B. 100110001101

C. 110011011010

D. 100101011010

B. A,B同为3个字符表示,哈夫曼编码必然前2个字符相同。

下边IPv6地址中写法正确的是?

A. fe80:0:b4f9:6c6f:b658:a4aa

B. fe80:0:0:0:b4u9:6c6f:b658:d4aa

C. fe80::04f9:6c6f:b658:d4aa

D. fe80::b4f9:6c6f:b658::d4aa

C. B中有u

IPv6地址为128位长,但通常写作8组,每组为四个十六进制数的形式。
如果四个数字都是零,可以被省略。
如果因为省略而出现了两个以上的冒号的话,可以压缩为一个,但这种零压缩在地址中只能出现一次

如果这个地址实际上是IPv4的地址,后32位可以用10进制数表示;因此: ffff:192.168.89.9 等价于 ::ffff:c0a8:5909, 但不等价于 ::192.168.89.9 和 ::c0a8:5909。
ffff:1.2.3.4格式叫做IPv4映像地址,是不建议使用的。而::1.2.3.4格式叫做IPv4一致地址(这也是混合符号(IPv4-compatible address)表示)。

以下哪项是对单核cpu执行程序时间的正确描述:

A. 程序CPU执行时间=指令数 × 时钟周期时间

B. 程序CPU执行时间=CPU时钟周期数 × 单条指令平均执行周期

C. 程序CPU执行时间=指令数 × 单条指令平均执行周期 × 时钟周期时间

D. 程序CPU执行时间=CPU时钟周期数 × 指令数 × 单条指令平均执行周期×时钟周期时间

C.

程序CPU执行时间=CPU时钟周期数*时钟周期时间
=指令数*单条指令平均执行周期*时钟周期时间

以下关于进程调度算法的描述中,错误的是

A. 优先级调度算法会引起进程的饥饿问题

B. 短作业优先调度算法的平均等待时间最少

C. 当系统最长响应时间一定时,时间片轮转调度算法的时间片大小与系统允许的最大进程数成正比

D. 高响应比优先调度算法综合考虑了进程等待时间和执行时间

C.

响应比 =(等待时间+要求服务时间)/ 要求服务时间,
即RR=(w+s)/s=1+w/s,因此响应比一定是大于1的。

采用快排对3 7 6 9 10 12 1进行排序( 第一个为基准数 ),第1轮探测结果为

A. 1 3 6 9 10 12 7

B. 9 1 6 3 10 12 7

C. 3 1 6 9 10 12 7

D. 1 3 6 7 9 10 12

A.

连接平台通过号码池来管理虚拟号码,如果每个号池管理15个号码,将有7个号码池每个号码池多2个号码;如果每个号码池管理12个号码,则会有11码没有号码池管理;如果每个号码池管理18个号码,将有一个号码池差1个号码。这批虚拟号码数量在500-600之间,这批虛拟号码有多少个()

A. 559

B. 539

C. 540

D. 541

运维同学通知我们台服务器(inux)存放日志的磁盘分区快满了,因此我们决定删除一些日志。但该服务器部醫了多个服务,我们想优先删除磁盘占用量比较大的服务的日志。已知所有服务都将日志打印到 /opt/scf/log/{服务名}/{服务名}.log,请帮忙选出一个命令来查看各个服务日志占用的空间

A. df -h /opt/scf/log

B. df -h /opt/scf/log/*

C. du -sh /opt/scf/log

D. du -sh /opt/scf/log/*

C.

du 本身就能递归显示到文件,其实 du -h /opt/scf/log 就可以了;
-s, --summarize display only a total for each argument,对每项大小总结,目录算一项。失去了递归显示,反而要加上通配符
du -sh /opt/scf/log ,就只显示 /opt/scf/log 大小
所以, du -sh /opt/scf/log/* 把每个服务名目录总结大小

现有长度分别为1,2,3,4,5,6,7,8,9,10的木棍各根,现要求用这些木棍(可以多根组合,但组合A=B=C=D,ABCD、ACDB等重排列算一种正方形)拼成一个正方形,可以有几种拼法

A. 18种

B. 19种

C. 20种

D. 15种

现有t表存在索引:idx a b c(a,b,c)下面那些SQL会被索引?

A. SELECT * FROM tI WHERE a!=1:

B. SELECT * FROM t1 WHERE b=1 AND a=4;

C. SELECT * FROM t1 WHERE b=2 OR c=3;

D. SELECT * FROM t1 WHERE a=1 AND b=2 AND c=3;

D.

or连接索引失效。!=不能用于索引项,也会失效。
最左前缀匹配原则,指的是查询从索引的最左前列开始并且不跳过索引中的列

以下关于web攻击手段错误的是

A. SQL注入攻击通过将任意SQL代码插入数据库查询,使攻击者能够完全控制web应用程序后面的数据库服务器

B. 对进入数据库的特殊字符等进行转义处理可有效预防SQL注入攻击

C. XSS攻击的主要方法是发送大量请求使服务器痒痪

D. XSS攻击可分为存储型XSS和反射型XSS两大类

C.

XSS攻击通常指的是通过利用网页开发时留下的漏洞,通过巧妙的方法注入恶意指令代码到网页,使用户加载并执行攻击者恶意制造的网页程序。 这些恶意网页程序通常是JavaScript

  • 存储型XSS,持久化,代码是存储在服务器中的,如在个人信息或发表文章等地方,加入代码,如果没有过滤或过滤不严,那么这些代码将储存到服务器中,用户访问该页面的时候触发代码执行。这种XSS比较危险,容易造成蠕虫,盗窃cookie等
  • 反射型XSS,非持久化,需要欺骗用户自己去点击链接才能触发XSS代码(服务器中没有这样的页面和内容),一般容易出现在搜索页面。
游戏中升级一把武器,假定每使用一个石头,有50%的概率会成功让武器升级,50%的概率会失败。如果武器等级大于等于5的话,升级失败会使得武器降1级。如果武器的级数小于5的话,失败没有效果。问:期望用多少个石头可以让一把初始为1级的武器升到级?()

A. 20

B. 26

C. 36

D. 48

在采用LRU算法的系统中,程序P的某次调用依次问8、7、6、5、4、3、2、1、2、3页。假设分配给P的最大内存是4页。则在该次调用中的缓存命中率

A. 0.6

B. 0.5

C. 0.4

D. 0.2

D.

第1道

给定个字符串,字符串是有序的整数集合,逗号相连,移除相同的数字,使每个数字只出现一次,输出最终的数字个数

输入描述:

1,2,2

输出描述:

2

示例1

输入:

0,0,1,1,1,2,2,3,3,4

输出:

5
import java.util.HashSet;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String line = sc.next();
        sc.close();
        String[] splits = line.split(",");
        HashSet<Integer> s = new HashSet<>();
        for (String split : splits) {
            s.add(Integer.parseInt(split));
        }
        System.out.println(s.size());
    }
}

第2道

幼儿园老师给她班上的孩子分饼干。所有的孩子都坐在-条线上,每个孩子都根据在课堂上的表现得到评分。老师必须给每个孩子至少1个饼干。如果两个孩子坐在起,那么评分较高的孩子必须得到更多的饼干(孩子必须左右都比较)。输出老师购买的饼干总数的最小值。例如,假设她的学生的评分为[3,6,3,5,6,2]。她给学生饼干的数量如下: [1,2,1,2,3,1] 。她必须购买至少10个饼干

输入描述:

假设学生评分为:[1,2,3],则输入应为:
3
1
2
3
第1行为数组元素大小,2至n+1行为数组元素(每行一个)

输出描述:

可分配最小值

示例1

输入:

6
3
6
3
5
6
2

输出:

10

示例2

输入:

10
1
2
4
2
6
1
7
8
9
2
1

输出:

19

孩子数量为10,所以饼干数为1+2+1+2+1+2+3+4+2+1=19
(最后一个孩子获得一个饼干,但是他比前一个孩子评分小,所以前一个孩子饼干数加一)

没有通过所有测试用例,事后修改,不知道对不对

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
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[] b = new int[n];
        List<Integer> list = new ArrayList<>();
        int min = Integer.MAX_VALUE, minIdx = 0;
        for (int i = 0; i < n; i++) {
            a[i] = sc.nextInt();
            if (a[i] < min) {
                min = a[i];
                minIdx = i;
            }
        }
        for (int i = 0; i < n; i++) {
            if (a[i] == a[minIdx])
                list.add(i);
        }
        sc.close();
        Arrays.fill(b, 0);
        b[minIdx] = 1;
        int sum = 0;
        for (int i = minIdx - 1; i >= 0; i--) {
            if (a[i] < a[i + 1]) {
                b[i] = b[i + 1] - 1;
                if (b[i] == 0) {
                    for (int j = i; j < minIdx; j++) {
                        b[j] = b[j] + 1;
                    }
                }
            } else if (a[i] > a[i + 1]) {
                b[i] = b[i + 1] + 1;
            } else {
                b[i] = b[i + 1];
            }
        }
        for (int i = minIdx + 1; i < n; i++) {
            if (a[i] < a[i - 1]) {
                b[i] = b[i - 1] - 1;
                if (b[i] == 0) {
                    for (int j = i; j > minIdx; j--) {
                        b[j] = b[j] + 1;
                    }
                }
            } else if (a[i] > a[i - 1]) {
                b[i] = b[i - 1] + 1;
            } else {
                b[i] = b[i - 1];
            }
        }
        // fix
        if (b[n - 1] != 1) {
            int delta = b[n - 1] - 1;
            for (int i = n - 1; i > 0; i--) {
                if (a[i] > a[i - 1]) break;
                if (a[i] < a[i - 1]) {
                    b[i] = b[i] - delta;
                }
            }
        }
        if (b[0] != 1) {
            int delta = b[0] - 1;
            for (int i = 0; i < n; i++) {
                if (a[i] > a[i + 1]) break;
                if (a[i] < a[i + 1]) {
                    b[i] = b[i] - delta;
                }
            }
        }
        for (int i = 0; i < n; i++) sum += b[i];
        System.out.println(sum);
    }
}

第3道

现有一个地图,由横线与竖线组成(参考围棋棋盘),且两点之间有行走距离起点为左上角,终点为右下角在地图上,每次行走只能沿线移动到临近的点,并累加路径计算一个人从地图的起点走到终点的最小路径为多少

输入描述:

mxn地图表示如下:
3
3
1 3 4
2 1 2
4 3 1
其中m=3,n=3表示3*3的矩阵
行走路径为:下>右>右>下

输出描述:

路径总长:1+2+1+2+1=7

示例1

输入:

1
2
1 2

输出:

3

示例2

输入:

2
3
9 8 6
2 3 7

输出:

21

把i写成了 j , 行复制误大事,事后发现懊悔不已,我竟然犯这种错。
算了过去了。

搜索解题,会有测试用例超时。

import java.util.Arrays;
import java.util.Scanner;

public class Main {
    static int ans = Integer.MAX_VALUE;
    static int m;
    static int n;
    static int[][] a;
    static int[][] d = {{1, 0}, {0, 1}};

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        m = sc.nextInt();
        n = sc.nextInt();
        a = new int[m][n];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                a[i][j] = sc.nextInt();
            }
        }
        sc.close();
        dfs(0, 0, 0);
        System.out.println(ans);
    }

    private static void dfs(int x, int y, int sum) {
        if (x < 0 || y < 0 || x >= m || y >= n) return;
        if (x == m - 1 && y == n - 1) {
            sum += a[m - 1][n - 1];
            ans = Math.min(ans, sum);
            return;
        }
        for (int i = 0; i < d.length; i++) {
            int posx = x + d[i][0];
            int posy = y + d[i][1];
            dfs(posx, posy, sum + a[x][y]);
        }
    }
}

这道题是一道经典的动态规划题。

中兴笔试复盘

中兴的笔试是AMCAT测评机构的,翻译着实令人着急。
虽然简单,但考了很多C语言,真的好久不用,一些C特有的语法知识都忘了,考得真不好。

题目具体表记不清了,
考虑给定的info和 acc info表。执行以下查询时,输出表中将有多少行?
SELECT name FROM info A1 LEFT OUTER JOIN acc info A2 ON A1.name=A2.name

注意LEFT OUTER JOIN虽然是保留左表的悬浮元组,其他属性置NULL。但结果集中不一定不等于左表记录数。

enum fun {a, b=4, c, e=-5, f};
int main() {
     enum fun W,X,Y,Z;
     W=f;
     X=a;
     Y=c;
     Z=e;
     printf("%d",X+Z-Y-W);
     return 0;
 } 

A. -1

B. -6

C. -8

D. -11

B. a=0, c=5, f=-4.

第一个枚举成员的默认值为整型的 0,后续枚举成员的值在前一个成员上加 1。

哪种构造不能用于进程同步?

A. 信号量

B. 监视器

C. 互斥锁

D. 以上都不是

D. 线程同步机制:互斥量、读写锁、信号量和监视器

在给出的关于下列查询输出的陈述中,哪句是正确的
SELECT Name,Age FROM tb1_student 
WHERE Age NOT BETWEEN 12 AND 15

A. 结果集包括年龄数值为12和15的记录

B. 结果集将具有除NULL、12、13、14和15之外的所有年龄值

C. 结果集只有年龄值为NULL的记录

D. 查询中有错误

B.

BETWEEN确定范围,包括上限和下限。
BETWEEN、NOT BETWEEN 操作的对象既然有范围,肯定是排除NULL的。

其中主系统具有一个系统架构,而客户系统构建另外种架构时所用的技术,其名称是什么?

A. 半虛拟化

B. VMware工作站

C. 系统合并

D. 模拟

A.

typedef union error {
     int warning, err, exception;
 }ERROR; 
 int main(){
     ERROR el={1};
     union error e2;
     e2.err=el.warning;
     printf("%d", e2.warning);
     e2=el;
     printf(" %d", e2.exception);
 }
当执行给出的代码段时,输出会是什么?

A. 1 1

B. 0 0

C. 1 0

D. e2=e1;处产生编译错误

A.

结构体和共用体的区别在于:结构体的各个成员会占用不同的内存,互相之间没有影响;而共用体的所有成员占用同一段内存,修改一个成员会影响其余所有成员
共用体占用的内存等于最长的成员占用的内存。共用体使用了内存覆盖技术,同一时刻只能保存一个成员的值,如果对新的成员赋值,就会把原来成员的值覆盖掉。

当执行以下代码段时,翰出会是什么?
int main(){
     int i = 5;
     printf("%d %d %d", ++i, i++,i++);
}

A. 7 6 5

B. 6 7 8

C. 6 6 7

D. 8 6 5

D.

关于 UNIQUE 键,以下哪个些陈述是正确的
 1.UNIQUE键可以具有多个NULL值
 2.每个候选码(alternate key)都是 UNIQUE 键
 3.每个 UNIQUE 键都是主键

A. 2和3

B. 1和2

C. 1和3

D. 只有2

B.

ACID规则中对于数据库中事务的隔离是什么意思?

A. 整个事务的影响都反映在数据库上,或者数据库回滚到其原始状态

B. 任何事务都不能干涉另一个事务的最终结果

C. 成功事务的影响必须存留在数据库中。

D. 每个单独的事务必须使数据库保持致状态,以保持数据库的完整性

B.

哪种接入点模式可用于远距离连接有线网络?

A. 根模式

B. 中继模式

C. 桥接模式

D. 工作组模式

B. 猜的。

搜到无线网络路由器AP、路由、中继、桥接模式的区别。是不是题目翻译错了。
Repeater(中继)模式Bridge(桥接)模式都是通过无线的方式连接到一台可以上网的无线路由器上,放大该无线路由器上的无线信号;区别在于Repeater(中继)模式下放大后的无线信号名称和之前路由器上的一致,而Bridge(桥接)模式放大后的无线信号名称和之前路由器上的无线信号名称不同。

在C++中私有继承时,如何在派生类中访可基类的受保护成员?

A. 私有

B. 公有

C. 受保护

D. 不继承

A. 现在复盘猛然醒悟。很多题目翻译的有问题吧,什么破系统。

  • 公有继承 继承自父类的成员保持不变。
  • 私有继承 继承自父类的成员全部变为私有成员。
  • 保护继承 继承自父类的公有成员变为保护成员,其余不变。
应该使用哪个设备将两个不同的网络地址192.168.10.0和172.20.10.0连接到一个设备?

A. 集线器

B. 网桥

C. 交换机

D. 路由器

D.
第一层 物理层    网线,集线器
第二层 数据链路层   网卡,交换机
第三层 网络层        路由器 (三层交换机)

哪种高层协议通常同时使用TCP和UDP?

A. HTTP

B. DNS

C. Telnet

D. FTP

B.

有5层,每个节点有4个子节点或没有子节点。同一层的所有节点具有相同数量的子节点。该树有多少个节点?(请注意:根在第1层。)

A. 341

B. 256

C. 1000

D. 以上都不是

A.

两道编程题都很简单。其中一道翻译还有问题,我佛了。