笔试真题解析 ALBB-2015 算法工程师实习生机试

朴灿烈づ我的快乐病毒、 2022-08-02 15:40 200阅读 0赞

1.用十进制计算30!（30的阶乘），将结果转换成3进制进行表示的话，该进制下的结果末尾会有\_\_\_\_个0。  
【解析】  
计算N！下3进制结果末尾有多少个0，其实就是计算3进制中的3被进位多少次，只要将N！因式分解成3^m\*other，m就是答案。技巧性的解法就是m=N/3+N/(3^2)+N/(3^3)....+N(3^k) (k<=N/3) —— N=30；N/3+N/9+N/27=14。

2.小赵和小钱二人分别从寝室和图书馆同时出发，相向而行。过了一段时间后二人在中途相遇，小赵继续向图书馆前进，此时：若小钱继续向寝室前进，则当小赵到达图书馆时，小钱离寝室还有600米；若小钱立即折返向图书馆前进，则当小赵到达图书馆，小钱离图书馆还有150米。那么图书馆与寝室间的距离是\_\_\_\_。  
【解析】

方法一：

![Center][]

设小赵，小钱速度分别位v1，v2，相遇前后时间为t1,t2。则可以得到：  
v1( t1+t2 )=s；v2( t1+t2 )= s-600；v1/v2=s /( s-600 )  
(v1-v2)( t1+ t2 ) = 600；(v1-v2) t2 = 150；v2 t1 = v1 t2；v1/v2 = 1/3  
s/(s-600) = 1/3；s=900。

方法二：

![Center 1][]

(x+150)/y =(x+150)/x=(600+y)/(x+150)=v1/v2；

x=y=75；s=600+75\*2+150=900。

3.某开发团队有6位开发同学,需参加5个项,每位同学需要恰好参加1个项,那么总共有\_\_\_\_ 种不同的分配案  
【解析】

六人五个项目，必有一项目两人做C(1/5)\*C(2/6)，剩下四人座剩下四个项目A(4/4)，则N=C(1/5)C(2/6)A(4/4)。

4.如下SQL语句中，\_\_\_\_可能返回null值。  
(1) select count(\*) from t1;  
(2) select max(col1) from t1;  
(3) select concat('max=',max(col1)) from t1;  
【解析】  
(1)返回的是表的行数，如果没有记录，应该返回0，不会出现NULL，  
(2) 和(3) 正常情况下不会出现NULL，但是如果表里面没有记录，则会出现NULL。  
  
5.略

6.以下关于STL的描述中，\_\_\_\_是错的。

> STL容器是线程不安全的
> 
> 当容量不够时，vector内部内存扩展方式是翻倍
> 
> std::sort是稳定排序
> 
> std::bitset不是一个STL容器
> 
> std::stack默认是用deque实现的
> 
> std::string中可以存储多个’\\0’字符

【解析】  
A：“很多程序员希望STL实现是完全线程安全的“。所以不安全。  
B：vector的存在可以使开发者不必关心内存的申请和释放。但是，vector的一个缺点就是它的内存分配是按照2的倍数分配内存的。  
C：错误。要知道 std::sort 不是稳定的排序算法，它不保证“相等”元素的相对位置，使用 std::stable\_sort 来保证这一点  
D：STL的容器可以分为以下几个大类:  
一：序列容器，　有vector, list, deque, string.  
二：关联容器, 有set, multiset, map, mulmap, hash\_set, hash\_map, hash\_multiset, hash\_multimap  
三：其他的杂项： stack, queue, valarray, bitset  
E：正确。堆栈是一个线性表，插入删除操作都在一端进行，deque是先进先出的，操作原理和stack是一样的  
  
7.有8只球队,采用抽签的方式随机配对,组成4场比赛。假设其中有4只强队,那么出现强强对话 (任意两只强队相遇)的概率是\_\_\_\_。  
【解析】  
全部可能性是C8 2C6 2C4 2/A4 4 = 105 种。  
强弱搭配，因为恰好都是4个，共有A4 4 = 24 种。  
答案就是 1-(24/105) = 27/35  
  
8.两个市区C1和C2，其人口比率是1:3，从今年的患病统计来说，C1市区由于污染严重，患癌的概率是0.1%，而C2市的患癌概率是0.02%，现在医院接收到一位患癌病人，他是C1市区来的概率是\_\_\_\_。  
【解析】  
这里运用了概率论中的贝叶斯公式，只是换了一种方式，通过已知结果找寻原因。假设C1市区有100人，C2市区有300人，假设患病事件记为Y。现在医院接收到一位患癌病人，他是C1市区来的概率P（C1|Y）=(100\*0.1%)/(100\*0.1%+300\*0.02%)=0.625  
  
9.下面代码在64位Linux系统编译执行，输出结果是\_\_\_\_。

#include <stdint.h> 
    #include <stdio.h> 
    void print_size(int32_t array[10]){ 
     printf("%d\n", sizeof(array)); 
    } 
    int main () { 
     int32_t myArray[10]; 
     printf("%d ", sizeof(myArray)); 
     print_size(myArray); 
    }

【解析】

64位Linux系统指针占8个字节；int32\_t 仍然占用32位，4个字节；  
输出： 40 8  
  
10.假设某棵二叉查找树的所有键均为1到10的整数，现在我们要查找5。下面\_\_\_\_不可能是键的检查序列。

10,9,8,7,6,5  
2,8,6,3,7,4,5  
1,2,9,3,8,7,4,6,5  
2,3,10,4,8,5  
4,9,8,7,5  
以上均正确  
【解析】  
二叉搜索树不可能存在一种检索方式是后面的键值有比当前键值大的也有比当前键值小的，要么比当前键都大，要么都小。因此，2,3,10,4,8,5有可能，2,8,6,3,7,4,5绝对没可能。  
  
11.以下程序在32位机器上运行输出是\_\_\_\_。

#include <iostream>
    using namespace std;
    class animal
    {
    protected:
        int age;
    public:
        virtual void print_age(void) = 0;
    };
    class dog : public animal
    {
    public:
           dog() {this -> age = 2;}
           ~dog() { }
           virtual void print_age(void) {cout<<"Wang, my age = "<<this -> age<<endl;}
    };
    class cat: public animal
    {
    public:
        cat() {this -> age = 1;}
        ~cat() { }
        virtual void print_age(void) {cout<<"Miao, my age = "<<this -> age<<endl;}
    };
    int main(void)
    {
         cat kitty;
         dog jd;
         animal * pa;
         int * p = (int *)(&kitty);
         int * q = (int *)(&jd);
        p[0] = q[0];
        pa = &kitty;
        pa -> print_age();
        return 0;
    }

【解析】

指针的数据类型是实函数的类型，指针指向的对象的数据类型，是虚函数的数据类型。  
详见：[C++ 覆盖 重载 隐藏 浅析][C_ _ _ _]  
详址：http://blog.csdn.net/u013630349/article/details/46706299

详见：[C++ 虚指针、成员变量与类对象的偏移地址][C_]

详址：http://blog.csdn.net/u013630349/article/details/47834803

输出为 ：Wang, my age = 1

/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*  
http://www.nowcoder.com/test/question/done?tid=449827&qid=23484\#summary  
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/

12.A，B，C三位同学都是很聪明的同学，面试官给他们背上依次贴上了数字2，4，8，他们都能看见别人的数字但无法看见自己的数字，现在面试官告诉他们这些数字都是自然数并且构成一个等比数列，让A、B、C同学依次循环回答是否确定自己的数字是多少，每位同学的回答算作一次，经过\_\_\_\_次有同学能准确说出自己的数字。  
【解析】  
1、第一次是A，此时他看到4和8，能判断出来等比是2，自己的数字可能是2或者16。回答不确定   
2、第二次是B，此时他看到2和8，此时等比可能是2，那么自己的数字是4；或者等比是4，自己的数字是32。B知道A能看到8和自己的数字，如果自己的数字是4，那么A有两种可能，所以A回答不确定；如果自己的数字是32，那么A仍然有多种可能，所以A仍然可以回答不确定。所以B此时不能通过A的回答排除其中一种可能性。回答不确定   
3、第三次是C，此时他能看到2和4，能判断等比是2，自己的数字可能是1或者8。C知道B能看到2和自己的数字，如果自己的数字是1，那么对B来说只能是4，是确定的。但B回答不确定，所以可以排除这种可能。因此C能确定自己的数字是8。  
  
**13.给定一个整数sum，从有N个无序元素的数组中寻找元素a、b、c、d，使得 a+b+c+d =sum，最快的平均时间复杂度是\_\_\_\_。  
【解析】  
leetcode k sum 问题，思路是利用快速排序思想，排序之后利用动态规划算法从而求解——先排序后加逼。  
算法时间复杂度 O(N^2logN)。**  
  
14.设二叉树结点的先根序列、中根序列和后根序列中，所有叶子结点的先后顺序\_\_\_\_。  
【解析】  
三者相同  
  
15.将整数序列（7-2-4-6-3-1-5）按所示顺序构建一棵二叉排序树a（亦称二叉搜索树），之后将整数8按照二叉排序树规则插入树a中，请问插入之后的树a中序遍历结果是\_\_\_\_。  
【解析】  
看清每一个字 1-2-3-4-5-6-7-8  
  
**16.下列各项技术中，目的与程序的容错（fault-tolerance）最不相关的是\_\_\_\_。  
fail fast  
graceful degradation  
backup  
sandbox  
checkpoint  
watchdo  
【解析】  
1.graceful degradation （优雅降级）：优雅降级(Graceful degradation)是指电脑，机器，电子系统或者是网络在本身大部分已经毁坏或无效的情况下还能保持有限的功能这种能力。优雅降级的目的是阻止灾难性的失败。理想情况下，有优雅降级特征的系统即使多个组件同时失效也不会引起停机。在优雅降级中，操作的效率和速度随着失效部件的增加逐渐下降。  
2.sandbox（沙盒/沙箱） 用于为一些来源不可信、具备破坏力或无法判定程序意图的程序提供试验环境。然而，沙盒中的所有改动对操作系统不会造成任何损失。通常这种技术被计算机技术人员广泛使用，尤其是计算机反病毒行业，沙盒是一个观察计算机病毒的重要环境。 影子系统 即是利用了这种技术的软件之一。  
有时沙盒也叫 沙箱 ，英文 sandbox 。在计算机领域指一种 虚拟技术 ，且多用于 计算机安全技术 。其原理是通过重定向技术，把程序生成和修改的文件定向到自身文件夹中。当某个程序试图发挥作用时，安全软件可以先让它在沙盒中运行，如果含有恶意行为，则禁止程序的进一步运行，而这不会对系统造成任何危害。  
3.watchdog：在由 单片机 构成的 微型计算机系统 中，由于单片机的工作常常会受到来自外界电磁场的干扰，造成程序的跑飞，而陷入死循环，程序的正常运行被打断，由单片机控制的系统无法继续工作，会造成整个系统的陷入停滞状态，发生不可预料的后果，所以出于对单片机运行状态进行实时监测的考虑，便产生了一种专门用于监测单片机程序运行状态的芯片，俗称" 看门狗 "。  
看门狗是恢复系统的正常运行及有效的监视管理器。  
4.fail-fast：机制是java集合(Collection)中的一种错误机制。当多个线程对同一个集合的内容进行操作时，就可能会产生fail-fast事件。例如：当某一个线程A通过iterator去遍历某集合的过程中，若该集合的内容被其他线程所改变了；那么线程A访问集合时，就会抛出ConcurrentModificationException异常，产生fail-fast事件。fail-fast是错误机制，不是容错机制。**  
  
17.对于192.168.0.0到192.168.0.255这个网络来说，以下说法中正确的是\_\_\_\_。

> A.网段内可用来作为主机IP的范围是：192.168.0.0到192.168.0.255
> 
> B.Network IP是192.168.0.255
> 
> C.Broadcast IP是192.168.0.0
> 
> D.网段内的主机可以通过网卡对网卡传递数据
> 
> E.192.168.0.1和192.168.0.2的主机需要使用Router传递数据包
> 
> F.是class B等级

/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*  
广播地址是192.168.0.255，网络IP是192.168.0.0，本网络内只是局域网的传递，用不到网络转发，最多可能用到集线器之类的东西。  
192段为C类地址，网络号有3个字节，主机号全0和全1的地址不可有做主机IP。子网之间转发无需通过路由器。  
主机号全为0，表示网络地址，全为1，表示广播地址。网段内主机交流无需路由器。192是C类地址。  
详见：[计算机网络 之 IP地址、子网掩码与默认网关][_ IP]

详址：http://blog.csdn.net/u013630349/article/details/47837211

\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/  
  
18. 略  
【解析】  
详见：[数据结构基础 图的遍历（一） 之 DFS][_ _ DFS]  
详址：http://blog.csdn.net/u013630349/article/details/46842567  
  
19.已知int a\[\]=\{1,2,3,4,5\}；int\*p\[\]=\{a,a+1,a+2,a+3\}；int \*\*q=p；表达式\*(p\[0\]+1)+\*\*(q+2)的值是\_\_\_\_。  
【解析】  
\*(p\[0\]+1)+\*\*(q+2)  
其中p\[0\]=a也就是a\[0\]的地址，p\[0\]+1=a+1就是a\[1\]的地址，\*(p\[0\]+1)就是a\[1\]的值就是2；  
\*\*q=p --> \*q=&p -->表示q保存的是p 的地址，q+2表示p\[2\]的地址，\*(q+2)表示p\[2\],\*\*(q+2)表示\*p\[2\]表示\*(a+2)就是a\[2\]的值就是3；  
所以，\*(p\[0\]+1)+\*\*(q+2)=5。  
  
20.设x、y、t均为int型变量，则执行语句：t=3; x=y=2; t=x++||++y; 后，变量t和y的值分别为\_\_\_\_。  
【解析】  
x++||++y执行后的结果是真，即1，然后赋值给t。因为是或运算，所以在判断x++时真后，后面的++y就不再执行了，所以y值没有变还是2.所以，t=1 y=2。

[Center]: /images/20220731/a4e28e5550fe4d1ab14c75179d8e7e5a.png
[Center 1]: /images/20220731/30857b222e77409fba0d266211a70e4d.png
[C_ _ _ _]: http://blog.csdn.net/u013630349/article/details/46706299
[C_]: http://blog.csdn.net/u013630349/article/details/47834803
[_ IP]: http://blog.csdn.net/u013630349/article/details/47837211
[_ _ DFS]: http://blog.csdn.net/u013630349/article/details/46842567