首页 > 其他分享> > 2020斗鱼秋招笔试记录

2020斗鱼秋招笔试记录

2019-09-01 21:01:21 作者：互联网

斗鱼秋招-算法工程师（移动开发部）

2019/8/20
单选10-多选3–判断-简答3
单选：
1，在点集拓扑学与欧几里得空间中，凸集（convex set）是一个点集合，其中每两点之间的直线点都落在该点集合中。

2，输入边长为512的图片，经过一个卷积层。Kernel为9，stride为3，padding为2，group为4，输出feature层的边长为（）
解析：输出尺寸=(输入尺寸-filter尺寸+2padding）/stride+1
参数filter：卷积核的数目
（512-9+22）/3+1=170
理论：https://blog.csdn.net/ice_actor/article/details/78648780
https://blog.csdn.net/dcrmg/article/details/79652487

3，32位与64位下各类型长度对比
https://blog.csdn.net/Sky_qing/article/details/11650497
下图为在32和64位linux系统下使用sizeof检测出的数据类型的长度。
32位平台下结果：
在这里插入图片描述

64位平台下结果：
在这里插入图片描述
4，给定一段长度为 1 的线段，任意折两次，构成三角形的概率为：1（精确到2位有效数字）
https://blog.csdn.net/nickkissbaby_/article/details/95621403

5，二叉树系列(1)已知二叉树的中序遍历和前序遍历，如何求后序遍历
在这里插入图片描述
PreOrder: GDAFEMHZ

InOrder: ADEFGHMZ

PostOrder: AEFDHZMG
6，一个完全二叉树中有330个叶子节点, 则在该二叉树中的节点个数为（）？

完全二叉树除最后一层外都是满的，所以也可以这么算：第一层1个节点，令层数为n，除最后一层外，每层的节点个数为2^(n-1)，有330个叶子节点，所以倒数第二层为第9层，有256个节点，256+x=330得x=74,所以共有1+2+4+8+16+32+64+128+256+74*2=659个节点，又因为第659个节点是右子节点，所以节点个数也可以是660。
7，https://blog.csdn.net/Sky_qing/article/details/11650497

8，一个口袋装着若干蓝球和若干红球，随机抽出两个球。第一个球是蓝球的概率为0.5；第一球是蓝球且第二个球是红球的概率为0.2。现如果已知第一个球是蓝球，则第二个球是红球的概率是多少？

P(A and B) = P(A|B)P(B) = P(B|A)P(A）
https://www.nowcoder.com/questionTerminal/7906730fb14d48078e346b2c4f59a0ec?orderByHotValue=1&mutiTagIds=802&page=1&onlyReference=false
9，# 判别式模型与生成式模型

生成式模型(Generative Model)与判别式模型(Discrimitive Model)是分类器常遇到的概念，它们的区别在于：（对于输入x，类别标签y）

生成式模型估计它们的联合概率分布P(x,y)
判别式模型估计决策函数F(X)或条件概率分布P(y|x)
生成式式模型可以根据贝叶斯公式得到判别式模型，但反过来不行

#生成式模型
4. 判别式分析
5. 朴素贝叶斯Native Bayes
6. 混合高斯型Gaussians
7. K近邻KNN
8. 隐马尔科夫模型HMM
9. 贝叶斯网络
10. sigmoid belief networks
11. 马尔科夫随机场Markov random fields
12. 深度信念网络DBN
13. 隐含狄利克雷分布简称LDA(Latent Dirichlet allocation)
14. 多专家模型（the mixture of experts model）

判别式模型
15. 线性回归linear regression
16. 逻辑回归logic regression
17. 神经网络NN
18. 支持向量机SVM
19. 高斯过程Gaussian process
20. 条件随机场CRF
21. CART(Classification and regression tree)
22. Boosting

10，，设有一个栈，元素依次进栈的顺序是A,B,C,D,E。下列不可能的出栈顺序有?
ABCDE
BCDEA
EABCD
EDCBA

https://www.nowcoder.com/questionTerminal/0922214c219c467eac855ab8a5026e8f
11，面向对象程序设计语言的三个基本特征是？( )

封装、接口和多态
继承、接口和动态
跨平台、接口和动态
封装、继承和多态
https://www.nowcoder.com/questionTerminal/25cb29811d9945e9b0bb20837b889907

多选-判断：
1，现在分析一下常见的排序算法的稳定性，每个都给出简单的理由。

(1)冒泡排序

冒泡排序就是把小的元素往前调或者把大的元素往后调。比较是相邻的两个元素比较，交换也发生在这两个元素之间。所以，如果两个元素相等，我想你是不会再无聊地把他们俩交换一下的；如果两个相等的元素没有相邻，那么即使通过前面的两两交换把两个相邻起来，这时候也不会交换，所以相同元素的前后顺序并没有改变，所以冒泡排序是一种稳定排序算法。

(2)选择排序

选择排序是给每个位置选择当前元素最小的，比如给第一个位置选择最小的，在剩余元素里面给第二个元素选择第二小的，依次类推，直到第n - 1个元素，第n个元素不用选择了，因为只剩下它一个最大的元素了。那么，在一趟选择，如果当前元素比一个元素小，而该小的元素又出现在一个和当前元素相等的元素后面，那么交换后稳定性就被破坏了。比较拗口，举个例子，序列5 8 5 2 9，我们知道第一遍选择第1个元素5会和2交换，那么原序列中2个5的相对前后顺序就被破坏了，所以选择排序不是一个稳定的排序算法。

(3)插入排序
插入排序是在一个已经有序的小序列的基础上，一次插入一个元素。当然，刚开始这个有序的小序列只有1个元素，就是第一个元素。比较是从有序序列的末尾开始，也就是想要插入的元素和已经有序的最大者开始比起，如果比它大则直接插入在其后面，否则一直往前找直到找到它该插入的位置。如果碰见一个和插入元素相等的，那么插入元素把想插入的元素放在相等元素的后面。所以，相等元素的前后顺序没有改变，从原无序序列出去的顺序就是排好序后的顺序，所以插入排序是稳定的。

(4)快速排序
快速排序有两个方向，左边的i下标一直往右走，当a[i] <= a[center_index]，其中center_index是中枢元素的数组下标，一般取为数组第0个元素。而右边的j下标一直往左走，当a[j] > a[center_index]。如果i和j都走不动了，i <= j，交换a[i]和a[j],重复上面的过程，直到i > j。交换a[j]和a[center_index]，完成一趟快速排序。在中枢元素和a[j]交换的时候，很有可能把前面的元素的稳定性打乱，比如序列为5 3 3 4 3 8 9 10 11，现在中枢元素5和3（第5个元素，下标从1开始计）交换就会把元素3的稳定性打乱，所以快速排序是一个不稳定的排序算法，不稳定发生在中枢元素和a[j] 交换的时刻。

(5)归并排序
归并排序是把序列递归地分成短序列，递归出口是短序列只有1个元素（认为直接有序）或者2个序列（1次比较和交换），然后把各个有序的段序列合并成一个有序的长序列，不断合并直到原序列全部排好序。可以发现，在1个或2个元素时，1个元素不会交换，2个元素如果大小相等也没有人故意交换，这不会破坏稳定性。那么，在短的有序序列合并的过程中，稳定是是否受到破坏？没有，合并过程中我们可以保证如果两个当前元素相等时，我们把处在前面的序列的元素保存在结果序列的前面，这样就保证了稳定性。所以，归并排序也是稳定的排序算法。

(6)基数排序
基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序，最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。基数排序基于分别排序，分别收集，所以其是稳定的排序算法。

(7)希尔排序(shell)
希尔排序是按照不同步长对元素进行插入排序，当刚开始元素很无序的时候，步长最大，所以插入排序的元素个数很少，速度很快；当元素基本有序了，步长很小，插入排序对于有序的序列效率很高。所以，希尔排序的时间复杂度会比O(n^2)好一些。由于多次插入排序，我们知道一次插入排序是稳定的，不会改变相同元素的相对顺序，但在不同的插入排序过程中，相同的元素可能在各自的插入排序中移动，最后其稳定性就会被打乱，所以shell排序是不稳定的。

(8)堆排序
我们知道堆的结构是节点i的孩子为2 * i和2 * i + 1节点，大顶堆要求父节点大于等于其2个子节点，小顶堆要求父节点小于等于其2个子节点。在一个长为n 的序列，堆排序的过程是从第n / 2开始和其子节点共3个值选择最大（大顶堆）或者最小（小顶堆），这3个元素之间的选择当然不会破坏稳定性。但当为n / 2 - 1， n / 2 - 2， … 1这些个父节点选择元素时，就会破坏稳定性。有可能第n / 2个父节点交换把后面一个元素交换过去了，而第n / 2 - 1个父节点把后面一个相同的元素没有交换，那么这2个相同的元素之间的稳定性就被破坏了。所以，堆排序不是稳定的排序算法。

综上，得出结论: 选择排序、快速排序、希尔排序、堆排序不是稳定的排序算法，而冒泡排序、插入排序、归并排序和基数排序是稳定的排序算法
https://www.cnblogs.com/codingmylife/archive/2012/10/21/2732980.html
2，静态成员变量
https://zhuanlan.zhihu.com/p/37439983
3，命题A：随机变量X和Y独立，命题B：随机变量X和Y不相关。A是B的______条件。
充分不必要
必要不充分
不充分不必要
充要

https://www.nowcoder.com/questionTerminal/cc3558a42a1d45dbbacae6ce821b67f8

4，SVM中，高斯核为什么会把原始维度映射到无穷多维？,5已知一棵树具有10个节点，且度为4，那么：
该树的高度至少是6
该树的高度至多是6
该树的高度至少是7
该树的高度至多是7

https://www.nowcoder.com/questionTerminal/6aa6013a2e9f4649b5c34fdcd52835a4

简答：
1,神经网络，激活函数，sigmoid,relu
https://blog.csdn.net/bojackhosreman/article/details/69372087

首先摆结论，因为线性模型的表达能力不够，引入激活函数是为了添加非线性因素。

2,单链表翻转，返回头结点
解法：
https://blog.csdn.net/songyunli1111/article/details/79416684

https://blog.csdn.net/u011452172/article/details/78127836
递归图解：
https://blog.csdn.net/FX677588/article/details/72357389

class ListNode:
    def __init__(self,x):
        self.val=x
        self.next=None

class Solution:
    #循环翻转单链表
    def ReverseList(self,pHead):
        if not pHead or not pHead.next:
            return pHead
        last =  None

        while pHead:
            #先用tmp保存phead的下一个节点的信息，
            #保证单链表不会因为phead节点的next的next而就此断裂
            tmp = pHead.next
            #保存完next,就可以让phead的next指向last了
            pHead.next=last

            last=pHead
            pHead=tmp

        return last


    def recurse(self,head,newhead):
        print("head.val: ",head.val)
        #递归
        if head is None:
            return
        if head.next is None:
            newhead=head

            # print("----:",newhead.val)
        else:
            newhead=self.recurse(head.next,newhead)
            print("head.next: ",head.next.val)
            # print("head: ",head.val)
            head.next.next=head
            # print("head.next:",head.next.val)
            head.next=None

        return newhead


a=Solution()
head=ListNode(1)
p1=ListNode(2)
p2=ListNode(3)
p3=ListNode(4)
p4 = ListNode(5)
head.next=p1
p1.next=p2
p2.next=p3
p3.next=p4

# p=a.ReverseList(head)

newhead=None
p=a.recurse(head,newhead)
# print("p: ",p.val)
while p:
    print(p.val)
    p=p.next
out:
head.val:  1
head.val:  2
head.val:  3
head.val:  4
head.val:  5
head.next:  5
head.next:  4
head.next:  3
head.next:  2
5
4
3
2
1

3，岛屿的个数

#深度优先搜索+访问数组+方向数组

四个方向
dfs总结：

-访问（x,y）
-将当前点放入访问数组
-深度遍历（x,y）的周围节点
-检查有效性

对于有效点然后递归

class Solution:

    def numIslands(self,grid):
        if not grid:
            return 0

        m, n = len(grid),len(grid[0])
        visited = set()
        numberOfIsland = 0
        dirs = [
            (0,1), #right
            (0,-1),#left
            (1,0),#down
            (-1,0) #up
        ]

        for i in range(m):
            for j in range(n):
                if self.check(grid,i,j,visited):
                    self.dfs(grid,i,j,visited,dirs)
                    numberOfIsland+=1
        return numberOfIsland

    def dfs(self,grid,x,y,visited,dirs):
        visited.add((x,y))
        for dx,dy in dirs:
            nx=x+dx
            ny=y+dy
            if self.check(grid,nx,ny,visited):
                self.dfs(grid,nx,ny,visited,dirs)

    def check(self,grid,x,y,visited):
        m,n = len(grid),len(grid[0])
        if x >= 0 and x <m and y >= 0 and y < n and grid[x][y] and (x,y) not in visited:
            return True
        return False


if __name__ == '__main__':
    a = Solution()
    b = [
[1,1,0,0,0],
[0,1,0,0,1],
[0,0,0,1,1],
[0,0,0,0,1]
]
    print(a.numIslands(b))

标签：head,排序,元素,next,2020,https,秋招,斗鱼,节点
来源： https://blog.csdn.net/qq_38441207/article/details/89043297