百度笔试题练习[1] （08-17）

Date: 2019-08-17

1.  有如图所示的二叉树，其先序遍历的序列为（      ）  ABDGCEHF  【回顾树的先序遍历-中序遍历-后序遍历】

2.   下列有关串，说法正确的是（      ） A

A 除主串S本身外，S的其他子串称为S的真子串      (对比真子集的概念)

B 子串在主串的位置是子串最后一个字符在主串的位置  （应该是子串的第一个位置）

C 空串与空格串相等  （不相等，空格串是有长度的）

D 空格串的串长度为0

3.  给定文法G[E]:E→E+E|E*E|id（id表示任意小写字母），下列表达式合法的是  D  (回顾文法)

A  a*(b+c)

B a-(b+c)

C    a-b-c

Da+b*c

4.  设一个栈的输入序列为1，2，3，4，5, 6，则借助一个栈所得到的输出序列不可能是（      ）  栈：先进后出[C]

A  1,2,3,4,5,6

B  2,4,3,1,6,5

C 3,1,5,4,2,6

D  2,3,1,5,6,4

5.  信息检索系统的评价指标有哪些（） ABCD

A 响应时间

B 空间耗费

C 精确度

D召回率

补充： 信息检索的目的是：较少消耗情况下尽快尽全面地返回正确的结果(包含了以上四个选项)

信息检索系统常用的评价指标（准确率，召回率，F1，MAP(mean average precision)，NDCG(normalized discounted cumulative gain)）

信息检索评价指标介绍

6.  下列关于语言模型的说法错误的是（）  B

A 基于知识的语言模型通过非歧义的规则解释歧义过程

B 基于知识的语言模型是经验主义方法  (错误，是非经验主义的方法)

C 基于语料库的统计分析模型需要从大规模的真实文本中发现知识

D 基于语料库的统计模型更加注重用数学的方法

7.  下列关于现有的分词算法说法错误的是（） A

A基于统计的分词方法是总控部分的协调下，分词子系统获得有关词、句子等的句法和语义信息来对分词歧义进行判断

B由于在上下文中，相邻的字同时出现的次数越多，就越有可能构成一个词，统计语料中的频度可以判断是否构成一个词

C统计分词系统将串频统计和串匹配结合起来，既发挥匹配分词切分速度快、效率高的特点，又利用了无词典分词结合上下文识别生词、自动消除歧义的优点

D中文分词的准确度，对搜索引擎结果相关性和准确性有相当大的关系

8. 

有一家医院为了研究癌症的诊断，对一大批人作了一次普查，给每人打了试验针，然后进行统计，得到如下统计数字：

    ①这批人中，每1000人有5个癌症病人；

    ②这批人中，每100个正常人有1人对试验的反应为阳性，

    ③这批人中，每100个癌症病人有95人对试验的反应为阳性。

   通过普查统计，该医院可开展癌症诊断。

   现在某人试验结果为阳性，根据最小风险贝叶斯决策理论，将此患者预测为患癌症的风险概率为（ ）。

假设将正常人预测为正常人和将癌症患者预测为癌症患者的损失函数均为0，将癌症患者预测为正常人的损失函数为3，将正常人预测为癌症患者的损失函数为1.

&&&& 直接根据贝叶斯定理进行计算：67.7%

9.  假设测试样本x,若最近邻样本为s,y是类别集合，则KNN分类出错的概率为（）  1-∑_(b∈y){P(b|x){P(b|s))

10.  【没懂】如当前样本集合D中第K类样本所占的比列为P(k)（k= 1,2,3,…,y），则样本的信息熵最大值为（ ）C

C Log2(y)

D log2(P(y)) 但个人觉得是概率，应该选D

11.  下列说法错误的是（） ACD

A 在聚类分析当中，簇内的相似性越大，簇间的差别越大，聚类的效果就越差

B  聚类分析可以看作是一种非监督的分类

C K均值是一种产生划分聚类的基于密度的聚类算法，簇的个数由算法自动地确定。

D  给定由两次运行K均值产生的两个不同的簇集，误差的平方和最大的那个应该被视为较优。

12.  下列关于数据降维方法说法正确的是（      ）ABCD

A  MDS要求原始空间样本之间的距离在降维后的低维空间中得以保持

B  PCA采用一组新的基来表示样本点，每个基向量都是原来基向量的线性组合，通过使用尽可能少的新基向量来表出样本，从而实现降维

C  核化主成分分析为先将样本映射到高维空间，再在高维空间中使用线性降维

D  流形学习是一种借助拓扑流形概念的降维方法，采用的思想是"邻域保持"

解释：

机器学习领域中所谓的降维就是指采用某种映射方法，将原高维空间中的数据点映射到低维度的空间中。降维的本质是学习一个映射函数 f : x->y，其中x是原始数据点的表达，目前最多使用向量表达形式。 y是数据点映射后的低维向量表达，通常y的维度小于x的维度（当然提高维度也是可以的）。f可能是显式的或隐式的、线性的或非线性的。

　　目前大部分降维算法处理向量表达的数据，也有一些降维算法处理高阶张量表达的数据。之所以使用降维后的数据表示是因为：①在原始的高维空间中，包含有冗余信息以及噪音信息，在实际应用例如图像识别中造成了误差，降低了准确率；而通过降维,我们希望减少冗余信息所造成的误差,提高识别（或其他应用）的精度。 ②又或者希望通过降维算法来寻找数据内部的本质结构特征。

　　在很多算法中，降维算法成为了数据预处理的一部分，如PCA。事实上，有一些算法如果没有降维预处理，其实是很难得到很好的效果的。

• 数据降维的目的

　　数据降维，直观地好处是维度降低了，便于计算和可视化，其更深层次的意义在于有效信息的提取综合及无用信息的摈弃。

• 数据降维的方法

　　主要的方法是线性映射和非线性映射方法两大类。

　降维方法 __ 属性选择：过滤法、包装法、嵌入法； 
　　　　　　 |_ 映射方法  __线性映射方法：PCA、LDA等  
　　　　　　　　　　　　|__非线性映射方法： 
　　　　　　　　　　　　　　　　　　　　　　|__核方法：KPCA、KFDA等 
　　　　　　　　　　　　　　　　　　　　　　|__二维化： 
　　　　　　　　　　　　　　　　　　　　　　|__流形学习：ISOMap、LLE、LPP等。 
　　　　　　　　　　　　|__其他方法：神经网络和聚类 

PCA和LDA区别： PCA是最常用的线性降维方法，它的目标是通过某种线性投影，将高维的数据映射到低维的空间中表示，并期望在所投影的维度上数据的方差最大，以此使用较少的数据维度，同时保留住较多的原数据点的特性。【尽量保持原数据的信息，但是不容易进行不同类别的数据的区分】

LDA：核心思想：往线性判别超平面的法向量上投影，是的区分度最大（高内聚，低耦合）。LDA是为了使得降维后的数据点尽可能地容易被区分！【不管原始数据的信息，尽量的将数据进行区分】

数据降维小结

关于MDS（多维缩放）：保证所有数据点对在低维空间中的距离等于在高维空间中的距离。 MDS

13.  下列属于常用的分箱方法的是（）ABC

A 统一权重法

B 统一区间法

C 自定义区间法

D 平均值法

分箱方法：  数据分箱 特征分箱

假设要将某个自变量的观测值分为k个分箱，一些常用的分箱方法有：1.无监督分箱（1）等宽分箱：将变量的取值范围分为k个等宽的区间，每个区间当作一个分箱。

（2）等频分箱：把观测值按照从小到大的顺序排列，根据观测的个数等分为k部分，每部分当作一个分箱，例如，数值最小的1/k比例的观测形成第一个分箱，等等。

（3）基于k均值聚类的分箱：使用第五章将介绍的k均值聚类法将观测值聚为k类，但在聚类过程中需要保证分箱的有序性：第一个分箱中所有观测值都要小于第二个分箱中的观测值，第二个分箱中所有观测值都要小于第三个分箱中的观测值，等等。

2.有监督分箱

在分箱时考虑因变量的取值，使得分箱后达到最小熵（minimumentropy）或最小描述长度（minimumdescriptionlength）。这里仅介绍最小熵。

（1）假设因变量为分类变量，可取值1，…，J。令pl（j）表示第l个分箱内因变量取值为j的观测的比例，l=1，…，k，j=1，…，J；那么第l个分箱的熵值为Jj=1［-pl（j）×log（pl（j））］。如果第l个分箱内因变量各类别的比例相等，即pl（1）=…=pl（J）=1/J，那么第l个分箱的熵值达到最大值；如果第l个分箱内因变量只有一种取值，即某个pl（j）等于1而其他类别的比例等于0，那么第l个分箱的熵值达到最小值。

（2）令rl表示第l个分箱的观测数占所有观测数的比例；那么总熵值为kl= 1rl×Jj=1［-pl（j）×log（pl（j ））］。需要使总熵值达到最小，也就是使分箱能够最大限度地区分因变量的各类别。

14.  在linux系统中查看正在通过ssh登录的用户与终端(      )  who | awk '{print $1,$3}'

15.  【没懂】某数据存放在DS=2000H和DI=1234H的数据段的存储单元中，则该存储单元的物理地址为（      ） 21234H

16.  在分时系统中，时间片设置Q=3,以下关于响应时间的分析，正确的是（     ）AD

A  用户数量越多响应时间越长

B 内存空间越大响应时间越长

C 时间片越小响应时间越长

D 进程数量越多响应时间越长

分时系统百科

17. 

Bool bcreateOK=::CreateProcess  

(szFilename,                           

 szCmdLine,                                            

 ① null, 

 ② null,                                                            

    false,                    

 create_new_console,                                        

 ③ null, 

 ④ null,                                                 

 &si,&pi) ;

以上创建进程的代码中四次出现“null”,作用分析正确的是（     ）

①缺省的进程安全性                 

②缺省的线程安全性                  

③新的环境                                  

④当前目录   

18.  TCP协议规定DNS进程的（ ）端口号是53    ；服务器的端口是53

19.  关于数组，以下说法正确的是（      ）A

A 数组也是一种线性表

B 只有一维数组是线性表

C 数组不是线性表

D 部分数组是线性表

20.  序列[9,14,11,16,21,15,20,31]为小顶堆，在删除堆顶元素9之后，调整后的结果是（      ）[11,14,15,16,21,31,20]

直接建立初始最大堆，然后交换堆顶和最后节点的值，然后进行堆的调整！

21.  对任意数列进行排序时，平均排序时间最短的排序算法为（      ） 归并排序【除基本有序，快速排序是被公认的最快的排序算法】

22. 利用折半查找算法要在有序表(17，21，34，38，47，54，70)查找元素34需经过（      ）次比较  3次比较

解释：38 —— 34 ——21 注意： 加1  减1 的操作

 

数据挖掘试题：

1. 设A[n][n]为一个对称矩阵，数组下标从[0][0]开始。为了节省存储，将其上三角部分按行存放在一维数组B[0…m-1]，m=n(n+1)/2，对上三角部分中任一元素Aij（i=

解释：  先求出前i-1行的元素个数，（首项+末项）×项数÷2=（n+n-i+1）×i÷2=(2n-i+1)i/2;
再求第i行的元素个数，上三角（j-i+1）
所以下标k值是(2n-i+1)i/2+j-i

2.  若用一个大小为7的数组来实现循环队列，且当前front和rear的值分别为3和0，当从队列中删除一个元素，再加入两个元素后，front和rear的值分别是（      ）  4 和2  【记住：队列是先进先出的数据结构】

3.  如果W是由有序树V转换的二叉树，则V中的结点的后序遍历顺序是W结点的（      ）  中序遍历

4.  判定一个有向图上是否存在回路除了可以利用拓扑排序方法外，还可以用： 深度优先遍历(DFS)【深度优先遍历是先在一条路径走到叶节点后回溯，然后继续遍历】

5.   设某数据结构的二元组形式表示为A=（D,R）,D={1,2,3,4,5,6,7),R={r},r={<1,2>,<1,3>,<1,4>,<2,5>,<2,6>,<3,7>,<5,6>}D

A 线性结构 (一对一为线性结构，一对多为非线性结构)

B 树型结构 (不存在环路，这里存在环路)

C 物理结构

D 图型结构 （允许存在环路）

6.  假设磁头当前位于第105道，正在向磁道序号增加的方向移动。现有一个磁道访问请求序列为35，45，12，68，110，180，170，195，采用SCAN调度算法得到的磁盘访问序列是(  )  110，170，180，195，68，45，35，12 

7.  

假如我们有如下的mail配置文件：

文件名：/etc/mail/access

test1.com REJECT

test2.com RELAY

test3.com DISCARD

test4.com 501 send message example

对于如上的规则，邮件服务器可以转或发信的客户允许来自于（      ） B，允许delay,不允许拒绝、放弃、请求错误

A  test1.com 

B  test2.com 

C  test3.com

D  test4.com 

8.  

下面四个关系表达式是等价的,试判别它们的执行效率（      ）

E1 =πA (σ B=C ∧ D=E′ (R×S) ) 

E2 =πA (σ B=C (R× σD=E′ (S) ) 

E3 =πA (R∞B=CσD=E′(S) )   (执行效率最快)

E4 =πA (σD=E′ (R∞B=C S) ) 

9.  假设设计数据库性能用“开销”，即时间，空间及可能的费用来衡量,则在数据库应用系统生存期中存在很多开销.其中，对物理设计者来说，主要考虑的是（      ）操作开销

因为物理设计阶段主要负责：存储结构+存取方法+存取路径

10.  用parzen窗法估计类概率密度函数时，窗宽过窄导致波动过大的原因是（      ）  

B  窗函数幅度过大

C  窗口中落入的样本数过少

11. 下面关于决策规则思想方法说法错误的是（      ） D

A   基于最小错误率的贝叶斯决策是利用概率论中的贝叶斯公式，得出使得错误率最小的分类规则

B   基于最小风险的贝叶斯决策是引入了损失函数，得出使决策风险最小的分类

C  最大最小决策是在类先验概率未知的情况下，考察先验概率变化对错误率的影响，找出使最小贝叶斯奉献最大的先验概率，以这种最坏情况设计分类器

D   序贯分类方法只考虑分类造成的损失，先用一部分特征分类，然后逐步加入性特征以减少分类损失，同时平衡总的损失，以求得最优效益【实际：序贯分类又称序次分类。采用树形分类器,由粗到细。树形分类器则采用序次分类的办法,每次选择不同的特征和不同的决策规则划分出不同的类别,直至识别出所有的类别。】

12.  

1） 给定n个数据点，一半用于训练，另一半用于测试，则训练误差和测试误差之间的差别随着n的增加而增加

2） AdaBoost迭代的训练分类器，每次更新时，增加之前分错样本的权重，减弱分类正确样本的权重！

3) GBDT是一阶taylor展式，而XGBoost是二阶泰勒展式  【Bagging是高方差，Boosting是高偏差 】

13.  考虑两个分类器：1）核函数取二次多项式的SVM分类器 和 2）没有约束的高斯混合模型（每个类别为一个高斯模型）。对R2空间上的点进行两类分类。假设数据完全可分，SVM分类器中不加松弛惩罚项，并且假设有足够多的训练数据来训练高斯模型的协方差。下面说法正确的是：这两个分类器的VC维相同。

注意：在一般的r维空间中，线性决策面的VC维=r+1,  所以所以VC维与所用的分类器或者方法没有关系？？

14.  针对机器学习算法，下面说法错误的是： D

A  Apriori算法分为两个阶段：寻找频繁项集和由频繁项集找关联规则。

B  SVM是基于分类边界的分类算法，主要是通过训练，找到这些分类之间的边界。

C  Adaboost是一种迭代算法，核心思想是针对同一个训练集训练不同的分类器，然后将这些分类器集合起来，构成一个更强的最终分类器。 【是在同一训练集上，而Bagging是有放回的抽样，是在不同的训练集上！！！但总体一样】

D   EM算法是在概率模型中寻找参数最小似然估计的算法，其中概率模型依赖于无法观测的隐藏变量。【最大似然估计！！】

15.  以下描述正确的是（      ）D

A MapReduce 只支持 Java 语言编写

B如果 NameNode 意外终止，SecondaryNameNode 会接替它使集群继续工作。

CBlock Size 是不可以修改的。

DTaskTracker是运行在多个节点上的slaver服务。

16.  DNS服务器配置主要区域的参数有(       ) ABC

Amaster

Btype

Cfile

17.  下面程序的输出结果为： 8，1

int change(int m,int n); 
main () 
{ int aa=40,ab=24,ac,ad; 
  ac=change(aa,ab);
  ad=change(aa-1,ab-2);
  printf("%d,  %d\n",ac,ad); 
｝
int change(int u,int v)
{ static int w; 
   u=u/(w+1);
   v=v/(w+1);
   while(v) 
   { w=u%v; u=v; v=w; } 
   return u; 
}

18. 某时刻进程的资源使用情况如下表所示，此时的安全序列是（      ） D

A  P1，P2，P3，P4 

B  P1，P3，P2，P4

C  P1，P4，P3，P2 

D  不存在

19.。 输出结果为 10，14 (个人认为答案是：10，13)

# include 
int f(int x){ 
   static y=2;
   ++y;
   x+=y;
   return x;
}
int main(){
 int k;
 k=f(7);
 printf("%d %d\n", k, f(k));
}

编程题一：excel中cell的记号的转换：

从R22C54到BB22的相互转换！

# excel编号转换
import sys
import heapq
if __name__ == "__main__":
    n = int(sys.stdin.readline())
    for i in range(n):
        line = sys.stdin.readline().strip()
        if "R" == line[0] and line[1].isdigit() and "C" in line:
            x, y = line.replace("R", "").replace("C", " ").split()
            y = int(y)

            prefix = ""
            while y > 0:
                if y % 26:
                    prefix += chr(ord('A') + y % 26 - 1)
                    y /= 26
                else:
                    prefix += "Z"
                    y = y / 26 - 1

            print("".join(list(reversed(prefix))) + x)

        else:
            prefix = ""
            for i, c in enumerate(line):
                if c.isdigit():
                    prefix = line[:i]
                    break

            num = 0

            for j, c in enumerate(prefix):
                num += (ord(c) - ord('A') + 1) * 26 ** (len(prefix) - 1 - j)

            print("R" + line[i:] + "C" + str(num))

编程题二： 正则表达式中（）的处理：【没通过，来自网络】

#  正则表达式匹配
# -*-coding:utf-8 -*-
import numpy as np
import re
def cost_min_sequence():  # 找到代价最小的括号序列
    result_list = []  # 记录每次输入对应的输出
    # 定义转换规则
    rule = {'0': '(', '1': ')'}
    while True:
        sequence = raw_input()
        if sequence is '':
            break
        else:
            sequence_flag = True  # 记录输入的(??)是否合法
            # 判断长度
            if len(sequence) > 50000:
                result_list.append(-1)
                sequence_flag = False
            # 判断格式是否为(???)
            pattern = '^\(.*?\)$'
            match_result = re.compile(pattern).findall(sequence)
            if len(match_result) == 0:
                sequence_flag = False
                result_list.append(-1)
            # 计算问号的个数
            n = 0
            for i in range(len(sequence)):
                if sequence[i] == '?':
                    n += 1
            if n >= 1:
                costs_list = []
                # 输入每个问号的代价
                for i in range(n):
                    cost = raw_input()
                    # print cost
                    cost_list = cost.strip().split()
                    # print 'cost_list: \n', cost_list
                    str = ''.join(cost_list)
                    # print 'str: \n', str
                    # print len(str)
                    if str.isalpha() and str.isalnum():  # 检查输入的代价是否含有字母
                        return False
                    elif len(str) != 2:
                        return False
                    else:
                        cost_list = [int(i) for i in cost_list]  # 变为int型
                        costs_list.append(cost_list)

                if not sequence_flag:  # 输入不合法不用计算
                    continue
                else:
                    if n == 1:  # 如果只有一个问号就不需要计算了
                        result_list.append(-1)
                        continue
                    # 计算每种组合及其代价
                    all_sequence = []  # 保存所有组合
                    all_cost = []  # 保存所有组合的代价
                    for i in range(2**n):  # 如果n=3则有8种组合，第一种000，第二种001，以此类推
                        # 将i用二进制表示出来,并且过滤掉0b
                        bin_i = bin(i)
                        bin_i = bin_i[2:]
                        # 如果bin_i的长度不等于n则用0补齐
                        while len(bin_i) != n:
                            bin_i = '0'+bin_i
                        # 第i种括号组合
                        kh_sequence = '('
                        for j in bin_i:
                            kh_sequence += rule[j]
                        kh_sequence += ')'
                        # 判断该组合是否满足正则序列（使用栈）
                        flag = False  # 标识该组合是否是正则序列
                        dict = {'(': ')'}
                        left_list = []
                        for i in kh_sequence:
                            if i in dict.keys():  # 如果是左括号
                                left_list.append(i)
                            else:
                                if len(left_list) == 0:
                                    break
                                else:
                                    if dict[left_list[-1]] != i:
                                        break
                                    else:
                                        left_list.pop()
                        if len(left_list) == 0:
                            flag = True
                        # 如果满足正则序列计算其代价
                        if flag:  # 比如bin_i = 010,代表有3个问号，第1个和第3个问号取'('，第2个问号取')'
                            all_sequence.append(kh_sequence)
                            cost_sum = 0  # 保存该组合的代价
                            m = 0  # 表示第几个问号
                            for i in bin_i:
                                cost_sum += costs_list[m][int(i)]
                                m += 1
                            all_cost.append(cost_sum)
                        else:
                            continue  # 该组合不满足正则序列，计算下一个序列组合

                # 选择最低的代价
                temp_cost_arr = np.array(all_cost)
                index = np.argsort(temp_cost_arr)  # 返回排序后的索引数组
                min_cost = all_cost[index[0]]
                min_cost_sequence = all_sequence[index[0]]
                # 保存将代价最低的正则序列及其最低代价
                result_list.append(min_cost)
                result_list.append(min_cost_sequence)
            else:  # n<1则退出，比如‘()’
                result_list.append(-1)
                break
    # 打印结果
    if len(result_list) != 0:
        for result in result_list:
            print(result)
if __name__ == '__main__':
    cost_min_sequence()