网易有道2017内推选择题
1、[单选题]
关于数据解析以下说法正确的是:
A、XML数据结构有且只有一个根节点，并且不能嵌套
B、JSONObjetWithData:options:error:使用文件流
C、writeJSONObject:toStream:options:error:使用缓冲区数据解析json
D、XML解析分为两种：SAX解析和DOM解析
解析：
A、XML只能有一个根节点，但是可以嵌套
B、JSONObjetWithData:options:error:使用缓冲区数据来解析
C、writeJSONObject:toStream:options:error:使用流来解析
答案：D
分析：
有XMLDOM解析、SAX解析、StAX解析
XMLDOM：（XMLDocumentObjectModel）处理大型文件时其性能下降的非常厉害。这个问题是由DOM的树结构所造成的，这种结构占用的内存较多，而且DOM必须在解析文件之前把整个文档装入内存,适合对XML的随机访问；
SAX：（SimpleAPIforXML）不同于DOM,SAX是事件驱动型的XML解析方式。它顺序读取XML文件，不需要一次全部装载整个文件。当遇到像文件开头，文档结束，或者标签开头与标签结束时，它会触发一个事件，用户通过在其回调事件中写入处理代码来处理XML文件，适合对XML的顺序访问；
StAX：（StreamingAPIforXML）与其他方法的区别就在于应用程序能够把XML作为一个事件流来处理，无论从性能还是可用性上都优于其他方法；
3、[不定项选择题]
已知两个一维模式类别的类概率密度函数为:
先验概率P(1)=0.6,P(2)=0.4,则样本{x1=1.35,x2=1.45,x3=1.55,x4=1.65}各属于哪一类别?
A、x4∈w2
B、x3∈w1
C、x2∈w1
D、x1∈w1
解析：
比较后验概率p(w|x)，哪个类的后验概率大，就属于哪个类
后验概率：p(w|x)=p(x|w)p(w)/p(x)，分母p(x)总是常数可以忽略，先验概率p(w)已知，计算类条件概率p(x|w)，即可得到后验概率
在算x1=1.35时，p(w1|x1)=p(x1|w1)*p(w1)/p(x1) = (2-1.35)*0.6/p(x1)=0.39/p(x1)
p(w2|x1)=p(x1|w2)*p(w2)/p(x1)=(1.35-1)*0.4/p(x1)=0.14/p(x1)
所以p(w1|x1) > p(w2|x1)，所以x1属于w1类
同理可以算出其他的。
答案：ABCD
4、[不定项选择题]
程序员小李通过管道统计prog.c函数中for语句通过的次数，需要使用的指令分别是
A、vi
B、grep
C、wc
D、sort
解析：
使用的命令： grep “for” proc.c | wc –l
grep, GlobalRegular Expression Print，使用正则表达式搜索文本，并把匹配的行打印出来
wc, word count，统计指定文件中的字节数，字数，行数，并将统计结果显示输出。如果没有给出文件名，则从标准输入读取，wc同时也给出所指定文件的总统计数。命令参数：-c 统计字节数。-l 统计行数。-m统计字符数
可以使用vi编辑器编辑现有的文件，也可以创建一个新文件，还能以只读模式打开文本文件。
sort将文件的每一行作为一个单位，相互比较，比较原则是从首字符向后，依次按ASCII码值进行比较，最后将他们按升序输出。
答案：BC
分析：
更准确的应该是grep -ow "for" prog.c |wc -w
不管源文件格式如何都能准确统计
grep：-w只匹配“for”这个单词（“for”两边必须有空字符）
-o只输出匹配到的“for”，而不是把含for的一整行都输出，这样用wc -w统计单词数就行了
wc：-w统计单词。如果统计行的话，有多个for在一行时统计有误。
分析二：Linux系统中的wc(Word Count) 命令的功能为统计指定文件中的字节数、字数、行数，并将统计结果显示输出。
1． 命令格式：
wc[选项]文件...
2． 命令功能：
统计指定文件中的字节数、字数、行数，并将统计结果显示输出。该命令统计指定文件中的字节数、字数、行数。如果没有给出文件名，则从标准输入读取。wc同时也给出所指定文件的总统计数。
3． 命令参数：
-c统计字节数。
-l统计行数。
-m统计字符数。这个标志不能与 -c 标志一起使用。
-w统计字数。一个字被定义为由空白、跳格或换行字符分隔的字符串。
-L打印最长行的长度。
-help显示帮助信息
--version显示版本信息
WC命令
5、[单选题]
请将下列构造函数补充完整，使得程序的运行结果是5
#include<iostream>
using namespace std;
class Sample{
public:
Sample(intx){
________
}
~Sample(){
if(p) deletep;
}
intshow(){
return*p;
}
private:
int*p;
};
int main(){
Sample S(5);
cout<<S.show()<<endl;
return 0;
}A、*p=x;
B、p=new int(x);
C、*p=new int(x);
D、p=&x;
解析：
A选项 *p=x；代表将p指向的变量赋值为x，但是题中，p没有初始值，是个空指针，所以无法使用这种方式赋值，应该先给p赋值，才能给*p赋值
C和A是一样的道理
D：p=&x表示的是，对x取地址，赋值给指针p，那么p将指向x的那块内存空间，但是x是形式参数（也有人说是方法参数，都可以），函数调用完了之后，内存就释放了，所以再返回*p（即取出那块内存空间的值），已经找不到了，所以错误。
答案：B
解析2：x是方法参数，则x的值和它所在的内存位置，都会在方法结束后失效，所以， 指针p不应该指向x的内存地址，而应该指向自己申请的一个地址空间，于是D错；而至于B和C，为何选B，由于 ‘p’和‘*p’，一个表示p指向的地址，一个则表示p指向的地址位置的值，所以，p = new int(x); 大致做了两件事：① 让p指向一个不会由于方法结束而失效的地址 ②将x值传给这个地址空间处， 所以最终，*p 也就是 p指向位置的值，就是x值。最终，选B。C错误的原因是 new返回的是申请地址空间成功的首地址，只能将赋值给p，而无法给*p
9、[不定项选择题]
关于解释系统的叙述中，正确的是（）
A、解释程序不是直接执行，而是转换成机器可识别码之后才能执行
B、使用解释系统时会区分编译阶段和运行阶段
C、目标程序可以脱离其语言环境独立执行，使用比较方便、效率较高
D、一般来说，建立在编译基础上的系统在执行速度要优于建立在解释执行基础上的系统
解析：
目标程序是 编译系统生成的，解释系统不生成目标程序。
编译：源代码->目标代码
解释：源代码->中间代码->目标代码
目标代码是机器可直接执行的代码
不管编译还是解释，都需要转为机器识别的才能执行，只不过解释是靠虚拟机或者其他机制。
A：计算机不能直接理解任何除其语言以外的语言，所以必须要把程序员所写的程序语言翻译成机器语言，计算机才能执行程序。将其他语言翻译成机器语言的工具，被称为编译器。编译器翻译的方式有两种：一个是编译，一个是解释，相对应的是编译型语言和解释型语言。
B：编译语言程序执行分为编译、执行两个阶段
C：编译语言如JAVA是跨平台语言，编译一次可以在别的系统中不需再次编译直接执行。
D：编译语言首先将源码编译成字节码或者编译成二进制码，C就是把源码编译成二进制码，JAVA编译成字节码。编译语言执行的效率往往比较高。因为它会对编译好的代码直接执行，而编译好的代码已经接近机器语言，无需再去做解释的工作。解释性语言不同，在执行的时候才把源代码调到执行它的地方，比如是引擎或者解释器，调用一句执行一句。
答案：AD
10、[单选题]
在一个10阶的B-树上，每个树根结点中所含的关键字数目最多允许为( )个，最少允许为( )个。
A、10,5
B、9,4
C、8,3
D、7,6
解析：m/2 - 1<= j <= m - 1；
答案：B
除根以外的非叶节点，每个节点包含分支数范围［m/2,m］,即关键字字数的范围是［m/2 -1,m-1］。
B-树是一种多路搜索树（并不是二叉的）：
1. 定义任意非叶子结点最多只有M个儿子；且M>2；
2. 根结点的儿子数为[2, M]；
3. 除根结点以外的非叶子结点的儿子数为[M/2, M]；
4. 每个结点存放至少M/2-1（取上整）和至多M-1个关键字；（至少2个关键字）
5. 非叶子结点的关键字个数=指向儿子的指针个数-1；
6. 非叶子结点的关键字：K[1], K[2], …, K[M-1]；且K[i] < K[i+1]；
7. 非叶子结点的指针：P[1], P[2], …, P[M]；其中P[1]指向关键字小于K[1]的 子树， P[M] 指向关键字大于 K[M-1] 的子树，其它 P[i]指向关键字属于 (K[i-1], K[i]) 的子树；
8. 所有叶子结点位于同一层；
11、[不定项选择题]
下列程序编译时会出现错误，请根据行号选择错误位置( )
#include <iostream>
using namespace std;
class A{
int a1;
protected:
int a2;
public:
int a3;
};
class B: public A{
int b1;
protected:
int b2;
public:
int b3;
};
class C:private B{
int c1;
protected:
int c2;
public:
int c3;
};
int main(){
B obb;
C obc;
cout<<obb.a1;//1
cout<<obb.a2;//2
cout<<obb.a3;//3
cout<<obc.b1;//4
cout<<obc.b2;//5
cout<<obc.b3;//6
cout<<obc.c3;//7
return 0;
}A、1,2
B、2,5,7
C、3,4,7
D、4,5,6
解析：
继承有三种方式，即公有（public）继承，私有（private）继承，保护（protected）继承。（私有成员（private属性）不能够被继承）
1. 公有继承就是将基类的公有成员变为自己的公有成员，基类的保护成员变为自己的保护成员。
2. 保护继承是将基类的公有成员和保护成员变成自己的保护成员。
3. 私有继承是将基类的公有成员和保护成员变成自己的私有成员。
private，public，protected访问标号的访问范围：
private:只能由（1）该类中的函数（2）其友元函数访问
不能被任何其他访问，该类的对象也不能访问
protected：可以被（1）该类中的函数（2）子类的函数（3）其友元函数访问
但不能被该类的对象访问
public：可以被（1）该类中的函数（2）子类的函数（3）其友元函数访问（4）该类的对象访问。
cout<<obb.a1;//1 a1是A私有的
cout<<obb.a2;//2 a2是A开放给派生类使用的，客户代码不能使用
cout<<obc.b1;//4 C是私有继承于B，不能使用B的成员
cout<<obc.b2;//5 同上
cout<<obc.b3;//6 同上
答案：AD
12、[单选题]
一磁带机有9道磁道，带长700m，带速2m/s，每个数据块1k字节，块间间隔14mm。如果数据传输率为128000字节/秒,求记录位密度为（）字节/m.
A、500000
B、64000
C、1000000
D、12800
解析：
数据传输率（C）= 记录位密度（D） x 线速度（V）
所以D = C/V = 128000/2 = 64000
多余的数据用于混淆大家
答案：B
13、[单选题]
以下几条路由，10.1.193.0/24,10.1.194.0/24,10.1.196.0/24,10.1.198.0/24，如果进行路由汇聚，则能覆盖这几条路由地址的是（）
A、10.1.192.0/22
B、10.1.200.0/22
C、10.1.192.0/21
D、10.1.224.0/20
答案
：C
10.1.193.0的二进制：00001010.00000001.11000 001.00000000
10.1.194.0的二进制：00001010.00000001.11000 010.00000000
10.1.196.0的二进制：00001010.00000001.11000 100.00000000
10.1.198.0的二进制：00001010.00000001.11000 110.00000000
子网掩码为：11111111.11111111.11111 000.00000000 （十进制为255.255.248.0）即可覆盖。
子网掩码是用来划分主机号和网络号，上面的二进制中只有001， 010， 100， 110这三位以后不同。
取前面21位相同为网络号，后面11位为主机号。
故为： 00001010.00000001.11000 000.00000000 (10.1.192.0)
子网掩码为 11111111.11111111.11111 000.00000000 (255.255.248.0, 缩写为21)
193: 1100 0001
194: 1100 0010
196: 1100 0100
198: 1100 0110
这四个数的前五位都是11000，加上10.1这两部分相同的位数，网络号就是8+8+5=21
而1100 0000的十进制数是192. 所以路由汇聚的IP地址就是10.1.192.0/21
将四类IP地址中第三位转为二进制，如下：
10.1. 193.0=>1100 0001
10.1. 194. 0=> 1100 0010
10.1. 196. 0=> 1100 0100
10.1. 198. 0=> 1100 0110
可以得出有五位是相同的=====》得出网络号应该占用8+8+5=21位，即
10.1. 1100 0000 . 0 ==》 10.1.192.0/21
