网易2018实习生招聘笔试题-JAVA开发实习生

程序员文章站 2024-03-12 15:46:44

...

网易2018实习生招聘笔试题-JAVA开发实习生

如何从有数字规律的网址抓取网页并保存在当前目录？假设网址为 http://test/0.xml，其中这个数字可以递增到100。
for(int i=0; i<100;++i)<br>wget http://test/$i.xml;
wget http://test/{$0-$100}.xml
wget http://test/`[0-100]`.xml
for((i=0;i<100;++i));do wget http://test/$i.xml; done
答案：D

牛牛找工作
为了找到自己满意的工作，牛牛收集了每种工作的难度和报酬。牛牛选工作的标准是在难度不超过自身能力值的情况下，牛牛选择报酬最高的工作。在牛牛选定了自己的工作后，牛牛的小伙伴们来找牛牛帮忙选工作，牛牛依然使用自己的标准来帮助小伙伴们。牛牛的小伙伴太多了，于是他只好把这个任务交给了你。

输入描述:

每个输入包含一个测试用例。
每个测试用例的第一行包含两个正整数，分别表示工作的数量N(N<=100000)和小伙伴的数量M(M<=100000)。
接下来的N行每行包含两个正整数，分别表示该项工作的难度Di(Di<=1000000000)和报酬Pi(Pi<=1000000000)。
接下来的一行包含M个正整数，分别表示M个小伙伴的能力值Ai(Ai<=1000000000)。
保证不存在两项工作的报酬相同。

输出描述:

对于每个小伙伴，在单独的一行输出一个正整数表示他能得到的最高报酬。一个工作可以被多个人选择。

示例1

输入

3 3 
1 100 
10 1000 
1000000000 1001 
9 10 1000000000

输出

100 
1000 
1001

题解：
<T> int binarySearch(T[] a, T key, Comparator<? super T> c)，key为待查找的元素，这是一个泛型方法。
Arrays.binarySearch返回值小于0，说明没有在数组中查到相应元素，此时返回值为(-第一个比该数大的位置-1)。-(index + 1) - 1则表示max(小于于查找元素)的索引。



//按照工作难度对工作数组排序后，遍历有序数组，更新报酬为当前难度下的最大报酬。而后，对每个伙伴只需二分搜索确定其胜任的最大工作难度即可获取当下最大报酬。

public class FindJob {
 
    public static void main(String[] args) {
 
        Scanner in = new Scanner(System.in);
        int jobNum = in.nextInt();
        int friendNum = in.nextInt();
        int[][] jdArray = new int[jobNum][2];
        for (int x = 0; x < jobNum; x++) {
            jdArray[x][0] = in.nextInt();
            jdArray[x][1] = in.nextInt();
        }
        int[] ability = new int[friendNum];
        for (int x = 0; x < friendNum; x++) {
            ability[x] = in.nextInt();
        }
        process2(jdArray, ability);
 
    }
 
    public static void process2(int[][] jdArray, int[] ability) {
        // 按照工作难度升序排序
        Arrays.sort(jdArray, (int[] jd1, int[] jd2) -> {return jd1[0] - jd2[0];});
 
        // 更新每个工作的报酬为当前难度所能获取的最大报酬
        for (int i = 0; i < jdArray.length - 1; i++) {
            if (jdArray[i][1] > jdArray[i + 1][1]) {
                jdArray[i + 1][1] = jdArray[i][1];
            }
        }
 
        // 二分查找确定能胜任的最大工作难度及其最大报酬
        for (int i = 0; i < ability.length; i++) {
            int index = Arrays.binarySearch(jdArray, new int[] {ability[i], 0}, (int[] jd1, int[] jd2) ->{
                return jd1[0] - jd2[0];});
            index = index < 0 ? -(index + 1) - 1: index;
            System.out.println(index >= 0 ? jdArray[index][1] : 0);
        }
 
    }

关于计算机网络，以下说法正确的是

(1)在向下的过程中，需要添加下层协议所需要的首部或者尾部

(2)在向上的过程中不断拆开首部和尾部

(3)在向上的过程中，需要添加下层协议所需要的首部或者尾部

(4)在向下的过程中不断拆开首部和尾部

(5)SMTP属于TCP协议

(6)POP3属于UDP协议

(7)DNS属于TCP协议

(8)Telnet属于UDP协议

(1)(2)(5)
(1)(2)(6)
(1)(2)(8)
(3)(4)(5)(6)
(3)(4)(5)(7)
答案：A
解析：
1）TCP (Transmission Control Protocol)和UDP(User Datagram Protocol)协议属于传输层协议。
2）其中TCP提供IP环境下的数据可靠传输，它提供的服务包括数据流传送、可靠性、有效流控、全双工操作和多路复用。通过面向连接、端到端和可靠的数据包发送。通俗说，它是事先为所发送的数据开辟出连接好的通道，然后再进行数据发送；一般来说，TCP对应的是可靠性要求高的应用。
3）而UDP则不为IP提供可靠性、流控或差错恢复功能。UDP对应的则是可靠性要求低、传输经济的应用。
4）TCP支持的应用协议主要有：Telnet、FTP、SMTP等；
5）TCP对应的协议：
（1） FTP：定义了文件传输协议，使用21端口。
（2） Telnet：一种用于远程登陆的端口，使用23端口，用户可以以自己的身份远程连接到计算机上，可提供基于DOS模式下的通信服务。
（3） SMTP：邮件传送协议，用于发送邮件。服务器开放的是25号端口。
（4） POP3：它是和SMTP对应，POP3用于接收邮件。POP3协议所用的是110端口。、
（5）HTTP：是从Web服务器传输超文本到本地浏览器的传送协议。
UDP对应的协议：
（1） DNS：用于域名解析服务，将域名地址转换为IP地址。DNS用的是53号端口。
（2） SNMP：简单网络管理协议，使用161号端口，是用来管理网络设备的。由于网络设备很多，无连接的服务就体现出其优势。
（3） TFTP(Trival File Tran敏感词er Protocal)，简单文件传输协议，该协议在熟知端口69上使用UDP服务。

关于MySQL索引，下面说法正确的是（）

(1)B+Tree 索引是大多数 MySQL 存储引擎的默认索引类型

(2)在 MySQL 中只有 Memory 引擎显式支持哈希索引

(3)哈希索引只包含哈希值和列指针，而不存储字段值

(4)MyISAM 存储引擎支持空间索引，可以用于地理数据存储。

(5)空间索引使用 MATCH AGAINST，而不是普通的 WHERE

(6) 索引将顺序 I/O变为随机 I/O
(1)(2)
(2)(4)
(2)(5)
(2)(4)(5)
(2)(5)(6)
(4)(5)(6)
答案：B

解析：

(1)B Tree 索引是大多数 MySQL 存储引擎的默认索引类型

(2)对的

(3)哈希索引只包含哈希值和行指针，而不存储字段值，所以不能使用索引中的值来避免读取行。

(4)对的

(5)Mysql全文搜索match against

(6) 索引将随机 I/O 变为顺序 I/O

在Linux系统中，可以用来查找可执行文件的是？

(1)whereis

(2)locate

(3)which

(4)type

(5)find
(1)(2)(3)
(1)(2)(5)
(1)(2)(3)(5)
(1)(2)(3)(4)(5)

答案：D

(1)whereis：

whereis命令用来定位指令的二进制程序、源代码文件和man手册页等相关文件的路径。

whereis命令只能用于程序名的搜索，而且只搜索二进制文件（参数-b）、man说明文件（参数-m）和源代码文件（参数-s）。如果省略参数，则返回所有信息。

(2)locate：

locate命令和slocate命令都用来查找文件或目录。

locate命令其实是find -name的另一种写法，但是要比后者快得多，原因在于它不搜索具体目录，而是搜索一个数据库/var/lib/locatedb，这个数据库中含有本地所有文件信息。Linux系统自动创建这个数据库，并且每天自动更新一次，所以使用locate命令查不到最新变动过的文件。为了避免这种情况，可以在使用locate之前，先使用updatedb命令，手动更新数据库。

(3)which：

which命令用于查找并显示给定命令的绝对路径，环境变量PATH中保存了查找命令时需要遍历的目录。which指令会在环境变量$PATH设置的目录里查找符合条件的文件。也就是说，使用which命令，就可以看到某个系统命令是否存在，以及执行的到底是哪一个位置的命令。

(4)type：

type命令用来显示指定命令的类型，判断给出的指令是内部指令还是外部指令。

命令类型：

alias：别名。
keyword：关键字，Shell保留字。
function：函数，Shell函数。
builtin：内建命令，Shell内建命令。
file：文件，磁盘文件，外部命令。
unfound：没有找到。

-t：输出“file”、“alias”或者“builtin”，分别表示给定的指令为“外部指令”、“命令别名”或者“内部指令”；
-p：如果给出的指令为外部指令，则显示其绝对路径；
-a：在环境变量“PATH”指定的路径中，显示给定指令的信息，包括命令别名。

[aaa@qq.com ~]# type date date is /bin/date [aaa@qq.com ~]# type mysql mysql is /usr/bin/mysql

因为显示的是路径，可以理解为找到了这个文件（个人理解）。

(5)find：

find命令用来在指定目录下查找文件。任何位于参数之前的字符串都将被视为欲查找的目录名。如果使用该命令时，不设置任何参数，则find命令将在当前目录下查找子目录与文件。并且将查找到的子目录和文件全部进行显示。

（非常标准的查找指令~）

有一条TCP连接，它的最大报文段长度为4KB，TCP拥塞窗口为24KB，这时候发生超时，那么该拥塞窗口变为了（）
2KB
4KB
6KB
8KB
答案：B
解析：TCP报文中，当发生超时事件，阈值被设置成当前拥塞窗口的一半，而拥塞窗口被设为一个最大报文段，也就是4KB。

在Java中，包com中定义了类TestUtil，在com的子包util中定义了同名类TestUtil，给定如下Java代码，编译运行时，将发生（）。

package test;

import com.util.TestUtil;

import com.TestUtil;

public class Test {

public static void main(String[] args) {

TestUtil testutil = new TestUtil();

}

创建了一个com.TestUtil对象
创建了一个com.util.TestUtil对象
运行时出现异常
编译无法通过
答案：D

给定Java代码如下所示，则编译运行后，输出结果是（ ）。

public class Test {
    static int a;
    int b;
    static int c;
 
    public int aMethod() {
        a++;
        return a;
    }
 
    public int bMethod() {
        b++;
        return b;
    }
 
    public static int cMethod() {
        c++;
        return c;
    }
 
    public static void main(String args[]) {
        Test test1 = new Test();
        test1.aMethod();
        System.out.println(test1.aMethod());
        Test test2 = new Test();
        test2.bMethod();
        System.out.println(test2.bMethod());
        Test test3 = new Test();
        test3.cMethod();
        System.out.println(test3.cMethod());
    }
}

1 0 2
2 1 2
0 0 2
2 2 2
答案：D

给定某Java程序的main方法如下，该程序编译运行后的结果是（ ）。

public static void main(String[] args) {
    String str=null;
    str.concat("abc");
    str.concat("123");
    System.out.println(str);
}

输出：null
输出：abc123
编译错误
运行时出现异常
答案：D

给定某Java程序的main方法如下，该程序编译运行后的结果是（ ）。

public class Test {
    int count = 21;
    public void count() {
        System.out.println(++count);
    }
    public static void main(String args[]) {
        new Test().count();
        new Test().count();
    }
}

22 23
21 22
22 22
21 23
答案： C

在JDK1.8中，HashMap没有实现哪个接口（ ）。
Map
AbstractMap
Serializable
Cloneable
答案：B

下面关于进程和线程说法错误的是（）
进程是系统进行资源分配和调度的基本单位，而线程是CPU调度和分配的基本单位
线程也拥有自己的系统资源
一个线程可以创建和撤销另一个线程
一个进程中的多个线程共享资源
答案：B

下面关于线程同步说法错误的是（）
用户模式和内核模式下同步方式不同
对于临界区的访问适用于单进程中线程间的同步
事件对象适用于多个进程间的各线程实现同步
互斥对象也只适用于单进程中线程间的同步
答案：D

下面关于死锁的说法错误的是（）
死锁是指多个进程因抢占资源而发生的一种阻塞且相互等待的现象
死锁的产生源于系统资源不足和进程推进顺序不当
可以通过终止和撤销进程来解除死锁
银行家算法用在预防死锁策略中
答案：D
银行家算法（Banker's Algorithm）是一个避免死锁（Deadlock）的著名算法，是由艾兹格·迪杰斯特拉在1965年为T.H.E系统设计的一种避免死锁产生的算法。它以银行借贷系统的分配策略为基础，判断并保证系统的安全运行。


用1*3的瓷砖密铺3*20的地板有几种方式？
1278
872
595
406

答案：A
3*n的区域铺瓷砖为f(n)，如果第一列竖着，那么就是f(n-1)，如果横着铺，就是f(n-3)。
f(n) = f(n-1) + f(n-3),递推结果为1278。

已知有4个矩阵分别大小为M1(5*3) M2(3*4) M3(4*2) M4(2*7) 下面组合计算所需要的乘法次数最优的为？
(M1(M2(M3M4)))
(M1((M2M3)M4))
((M1M2)(M3M4))
((M1(M2M3))M4)
(((M1M2)M3)M4)

答案：D
矩阵 乘法运算。m*n的矩阵乘以n*p的矩阵得到m*p的矩阵。其中元素个数为m*p个，每个元素需要n次乘法运算，n-1次加法运算。所以先将矩阵的维数降（n越大）下来，即降低元素个数，更有利于快速计算。

一个完全二叉树节点数为200，则其叶子结点个数为？

98
99
100
101
答案：C
解析：

完全二叉树(Complete Binary Tree)定义：

若设二叉树的深度为h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数，第 h 层所有的结点都连续集中在最左边，这就是完全二叉树。

完全二叉树是由满二叉树而引出来的。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。

一棵二叉树至多只有最下面的一层上的结点的度数可以小于2，并且最下层上的结点都集中在该层最左边的若干位置上，而在最后一层上，右边的若干结点缺失的二叉树，则此二叉树成为完全二叉树。

完全二叉树的特点是：

1）只允许最后一层有空缺结点且空缺在右边，即叶子结点只能在层次最大的两层上出现；

2）对任一结点，如果其右子树的深度为j，则其左子树的深度必为j或j+1。即度为1的点只有1个或0个

解析：

这里总结点200个，这里是偶数，可以判断度为1的结点是1个。

根据二叉树性质n0 = n2 + 1;叶子结点数量等于度为2的结点数+1

n0 + n1 + n2 = 200

∴n0 + n1 + n0 -1 =200;

∴2n0 = 201-n1 = 200 （完全二叉树度为1的结点个数要么1，要么0. 叶子结点数为整数，这里也可以推断出度为1的结点个数是1）

∴n0 = 100

叶子结点数是100.

字符串zmnzizi用哈夫曼编码来编码，则共有多少位？
14
13
12
11
答案：B
网易2018实习生招聘笔试题-JAVA开发实习生

已知中序遍历的序列为abcdef，高度最小的不可能的二叉树的前序遍历是

dbacfe
dbacef
cbaedf
cabefd

答案:D
解析：

这个题解题我们需要结合前序遍历和中序这个点来画出可能的二叉树图解：基本如图：

网易2018实习生招聘笔试题-JAVA开发实习生

前序遍历：遵循的是：根节点左子节点右子节点 root left right

中序遍历：遵循的是：左子节点根节点右子节点 left root right

所以我们看出来：前序遍历的第一个节点就是最上面那个节点，其在中序遍历中充当分界线的作用，左右分离便是二叉树的原型。然后我们在根据同样的规律将左子节点和右子节点补充完整。可以得出完整的二叉树。

上面是我画出来的情况。D图无法绘制，所以D选项不是二叉树。

基于哈希算法在信息安全中主要应用在？
(1)    文件校验
(2)    数字签名
(3)    鉴权协议
(1)(2)
(1)(3)
(2)(3)
(1)(2)(3)
答案:D

下列选项中，不可能是快速排序第2趟排序结果的是（）
4 14 10 12 8 6 18
4 6 10 8 12 14 18
6 4 10 8 14 12 18
8 4 6 10 12 14 18
答案：C
解析：只需要掌握一点就可以解出这个问题：每趟排序就有一个元素排在了最终的位置上。那么就是说，第n趟结束，至少有n个元素已经排在了最终的位置上。所以我们把最终排序结果写出来：然后计算在最终位置上的个数就可以

牛牛以前在老师那里得到了一个正整数数对(x, y), 牛牛忘记他们具体是多少了。

但是牛牛记得老师告诉过他x和y均不大于n, 并且x除以y的余数大于等于k。

牛牛希望你能帮他计算一共有多少个可能的数对。

import java.util.*;  
public class Main { public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);  
        long n=sc.nextLong();
        long k=sc.nextLong();
        if(k == 0){
            System.out.println(n*n);
            return ;
                }

        long count = 0;  //记录找到的整数对个数
        long temp;
                //思路：固定y，找x
        for (long y = k + 1; y <= n; y++) {    //  x/y>=k,说明y>k
            // 假设n = a*y +b；在每个长度为y的区间里只有（y-k）个数模y余数>=k。
            count += n/y*(y-k);    
            temp = n%y;
            if(temp >= k) {                    //再考虑余数b是否>=k
                count += temp-k+1;
            }
        }        
        System.out.println(count);  
    }
}

平面内有n个矩形, 第i个矩形的左下角坐标为(x1[i], y1[i]), 右上角坐标为(x2[i], y2[i])。

如果两个或者多个矩形有公共区域则认为它们是相互重叠的(不考虑边界和角落)。

请你计算出平面内重叠矩形数量最多的地方,有多少个矩形相互重叠。

解析：点计数法，重叠后的矩形左下角坐标一定是{x1[0]~x1[50], y1[0]~y1[50]}这2500个点中产生，只要分别判断这些点在多少矩形中即可

import java.util.Scanner;
public class Main {
    private static int n;
    private static int[][] rec;
    private static long res = 1;
    public static void main(String[] args){
        int loop = 1;
        //System.setIn(No2.class.getResourceAsStream("2.txt"));
        Scanner scanner = new Scanner(System.in);
        //loop = scanner.nextInt();
        for (int i = 0; i < loop; ++i) {
            n = scanner.nextInt();
            rec = new int[n][4];
            for (int j = 0; j < 4; j++) {
                for (int k = 0; k < n; k++) {
                    rec[k][j] = scanner.nextInt();
                }
            }
            solve();
            output();
        }
        scanner.close();
    }
    private static void solve() {
        int x, y, count;
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                x = Math.max(rec[i][0], rec[j][0]);
                y = Math.max(rec[i][1], rec[j][1]);
                count = 0;
                for (int k = 0; k < n; k++) {
                    if(x >= rec[k][0] && y >= rec[k][1] && x < rec[k][2] && y < rec[k][3])
                        ++count;
                }
                res = Math.max(count, res);
            }
        }
    }
    private static void output() {
        System.out.println(res);
    }
}

Java常用的数据结构中，请描述Vector, ArrayList, LinkedList的不同场景下的性能差别。

LinkedList是一个双向链表结构.线程不安全.适合于中间部位添加和删除.

ArrayList 是一个数组结构.线程不安全.适合于查询和修改，以及尾部的添加和删除.

Vector 是一个数组结构。但是关键的添加，删除等方法都已经用synchronized修饰，是线程安全的.适合于查询，以及尾部的添加和删除.

Java服务器网络开发时，请说明通讯中阻塞（blocking）/非阻塞（non-blocking 与同步/异步IO的区别。

同步／异步主要针对客户端：

同步：就是当客户端发出一个功能调用时，在没有得到结果之前，该调用就不返回。也就是说必须一件一件的事情去做，等一件做完了才能去做下一件。

异步：就是当客户端发出一个功能调用时，调用者不用等接收方发出响应。实际处理这个调用的部件在完成后，会通过状态，通知和回调来通知调用者。客户端可以接着去做后面的事情。

虽然主要是针对客户端，但是服务器端不是完全没有关系的，同步／异步必须配合服务器端才能实现。同步／异步是由客户端自己控制，但是服务器端是否阻塞/非阻塞，客户端完全不需要关心。

阻塞／非阻塞主要是针对服务器端：

阻塞：阻塞调用是指服务器端被调用者调用结果返回之前，当前线程会被挂起。调用线程只有在得到结果之后才会返回。

非阻塞：指在不能立即得到结果之前，该调用不会阻塞当前线程。

上一篇：面试编程题解题思路（二）

下一篇： MATLAB绘制直方图和阶梯形图