商汤科技,测试岗二面凉

一面

1、解释下PCA==>手推PCA

PCA通过线性变换将原始数据变换为一组各维度线性无关的表示,可用于提取数据的主要特征分量,常用于高维数据的降维。




https://zhuanlan.zhihu.com/p/33262929

2、正交基的含义,为什么采用正交基而不是非正交

一个内积空间的正交基(orthogonal basis)是元素两两正交(两两垂直)的基。例如二维坐标轴中的任意向量都可以用(1,0)和(0,1)叫做二维空间中的一组基表示/三维空间通常取(1,0,0),(0,1,0),(0,0,1)作为标准正交基。

当特征向量两两正交时,任何两种属性都是相互独立的,其中一个的取值不会影响另一个。但是属性并非全部不相关,向西瓜的体积和重量就是正相关的,这时候若不正交有更好的效果。

3、特征向量特征值协方差的物理意义==>怎么求特征向量和特征值==>矩阵化简

特征值特征向量物理意义:
https://blog.csdn.net/dongtinghong/article/details/14216139
https://blog.csdn.net/alvinlyb/article/details/78892486
从定义出发,Ax=cx:A为矩阵,c为特征值,x为特征向量。
协方差物理意义:
协方差表示向量两两之间的相似度/向量之间的关系,协方差矩阵保存信息越多,误差越小,而特征值表示特征向量的权重,选取最大的几个特征向量即可保存更多信息

求解特征向量和特征值
特征方程是一个齐次线性方程组,求解特征值的过程其实就是求解特征方程的解



用矩阵的初等行变换,先化成下三角阵,再化为最简阵.
4、深复制、浅复制==》Python里的copy是哪种==>Python的函数定义中的形参会受改变嘛

直接复制,传递对象的引用而已,原始列表改变,被赋值的b也会做相同的改变(Python的copy)

copy浅拷贝,没有拷贝子对象,所以原始数据改变,子对象会改变

深拷贝,包含对象里面的自对象的拷贝,所以原始对象的改变不会造成深拷贝里任何子元素的改变


5、对于一个n份文件,想放入k个包,n除不尽k,要使得每个包中存放的文件个数均匀,写个程序

思路,先平均放,将多余放在前多少个
import java.util.*;
class sp{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int in = sc.nextInt();
int before = in/k;
int remainder = in%k;
ArrayList<Integer> a = new ArrayList<Integer> ();

for(int i=0; i< remainder;i++){
a.add(before +1);
}
for(int i= remainder;i < k; i++){
a.add(before);
}
for(int i: a){
System.out.println(i);
}
}}

6、对图像处理有哪些分类==>知道图像分割和图像识别嘛

图像压缩,增强和复原,匹配、描述和识别

目标分割(Target Segmentation)分类问题 or 聚类问题
(1)若Segmentation是分类(classificatio)问题,就是把每一个pixel做labeling,提出感兴趣的那一类label的像素。
(2)若Segmentation是clustering的问题,即是不知道label,但需要满足一些optimality,比如要cluster之间的correlation最小之类的。
目标识别(Target Recognition),
将分割后的内容直接进行分类处理(一般是多类问题)

目标检测(Target Detection)
根据阈值获得Bounding box  (两类问题)

7、如何调参数

网格法调参 +经验


二面
1、为什么做测试?

2、快排

快排原理:         在要排的数(比如数组A)中选择一个中心值key(比如A[0]),通过一趟排序将数组A分成两部分,其中以key为中心,key右边都比key大,key左边的都key小,然后对这两部分分别重复这个过程,直到整个有序。         整个快排的过程就简化为了一趟排序的过程,然后递归调用就行了。
一趟排序的方法:
1,定义i=0,j=A.lenght-1,i为第一个数的下标,j为最后一个数下标
2,从数组的最后一个数Aj从右往左找,找到第一小于key的数,记为Aj;
3,从数组的第一个数Ai 从左往右找,找到第一个大于key的数,记为Ai;
4,交换Ai 和Aj  5,重复这个过程,直到 i=j 6,调整key的位置,把A[i] 和key交换

import java.util.Arrays;
public class QuickSort {
public static void main(String[] args) {
int[] a = {1, 2, 4, 5, 7, 4, 5 ,3 ,9 ,0};
System.out.println(Arrays.toString(a));
quickSort(a);
System.out.println(Arrays.toString(a));       }
public static void quickSort(int[] a) {
if(a.length>0) {
quickSort(a, 0 , a.length-1);
}
}
private static void quickSort(int[] a, int low, int high) {           //1,找到递归算法的出口
if( low > high) {
return;
}           //2, 存
int i = low;
int j = high;           //3,key
int key = a[ low ];           //4,完成一趟排序
while( i< j) {               //4.1 ,从右往左找到第一个小于key的数
while( i<j &&a[j]>key ){
j--;
}               // 4.2 从左往右找到第一个大于key的数
while( i<j && a[i] <= key) {                   i++;               }               //4.3 交换
if(i<j) {                   int p = a[i];                   a[i] = a[j];                   a[j] = p;               }           }
// 4.4,调整key的位置
int p = a[i];
a[i] = a[low];
a[low] = p;           //5, 对key左边的数快排
quickSort(a, low, i-1 );           //6, 对key右边的数快排
quickSort(a, i+1, high);
}
}




3、Python中可变与不可变

ython中,数值类型(int和float)、字符串str、元组tuple都是不可变类型。而列表list、字典dict、集合set是可变类型。
不可变对象,该对象所指向的内存中的值不能被改变。当改变某个变量时候,由于其所指的值不能被改变,相当于把原来的值复制一份后再改变,这会开辟一个新的地址,变量再指向这个新的地址。
可变对象,该对象所指向的内存中的值可以被改变。变量(准确的说是引用)改变后,实际上是其所指的值直接发生改变,并没有发生复制行为,也没有开辟新的出地址,通俗点说就是原地改变。
4、对于可变的list 看着程序写输出

test_list = [1, 2, 3, 4]

def f1(alist):
alist = 10
f1(test_list)
print(test_list)
[10,10,10,10]


test_list = [1, 2, 3, 4]

def f1(alist):
alist[0] = 10
f1(test_list)
print(test_list)
[10,2,3,4]

test_list = [1, 2, 3, 4]

def f1(alist):
alist.append( 10)
f1(test_list)
print(test_list)
[1,2,3,4,10]

5、sql语句 三门课总成绩大于85的学生
select S.id,S.name, SUM(S.score) total
from student S
group by S.id
having SUM(S.score)>85

6、熟悉Java的哪些数据结构==>Arraylist是数组还是链表==>为什么是可变长度

ArrayList是数组,创建ArrayList对象时,ArrayList有个带参数的构造函数,那个参数的意思就代表着ArrayList长度,默认情况是10。
当数据多了,ArrayList容不下时,这时ArrayList会增加长度,newLength = oldLength + oldLength/2;如果初始值是10,那么依次是15,22,33,49,73......,长度是增加了,那是怎样实现的呢?当数据容不下时,ArrayList会再创建一个更大的数组,数组长度为之前所说的那样,然后将之前的数据拷贝到新数组中。这就是ArrayList基于数组实现的可变长度原理。
7、面向对象==》多态==》编译时多态和运行时多态

面向对象的三大特性:封装、继承、多态。从一定角度来看,封装和继承几乎都是为多态而准备的。
多态的定义:指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。(发送消息就是函数调用)。
实现多态的技术称为:动态绑定(dynamic binding)多态存在的三个必要条件一、要有继承;二、要有重写;三、父类引用指向子类对象。
多态的好处:
1.可替换性(substitutability)。多态对已存在代码具有可替换性。例如,draw函数对圆Circle类工作,对其他任何圆形几何体,如圆环,也同样工作。
2.可扩充性(extensibility)。多态对代码具有可扩充性。增加新的子类不影响已存在类的多态性、继承性,以及其他特性的运行和***作。实际上新加子类更容易获得多态功能。例如,在实现了圆锥、半圆锥以及半球体的多态基础上,很容易增添球体类的多态性。
3.接口性(interface-ability)。多态是超类通过方法签名,向子类提供了一个共同接口,由子类来完善或者覆盖它而实现的。


编译时多态        方法重载都是编译时多态。根据实际参数的数据类型、个数和次序,Java在编译时能够确定执行重载方法中的哪一个。         方法覆盖表现出两种多态性,当对象引用本类实例时,为编译时多态,否则为运行时多态。例如,以下声明p、m引用本类实例,调用toString()方法是编译时多态。

运行时多态       意为p.toString()实际执行p所引用实例的toString(),究竟执行Person类还是Man类的方法,运行时再确定。如果Man类声明了toString()方法,则执行之;否则执行Person类的toString()方法。         程序运行时,Java从实例所属的类开始寻找匹配的方法执行,如果当前类中没有匹配的方法,则沿着继承关系逐层向上,依次在父类或各祖先类中寻找匹配方法,直到Object类。
#商汤科技##面经##秋招##测试工程师#
全部评论
商汤和大佬一起重定义了测试
4 回复
分享
发布于 2018-09-22 16:21
测试。。。
1 回复
分享
发布于 2018-09-22 15:29
小红书
校招火热招聘中
官网直投
这是测试???
点赞 回复
分享
发布于 2018-09-22 15:41
这是测试吗?一点测试的东西都不稳。。。。感觉是开发啊
点赞 回复
分享
发布于 2018-09-22 15:44
测试。。。
点赞 回复
分享
发布于 2018-09-22 15:45
不敢相信是测试。。
点赞 回复
分享
发布于 2018-09-22 16:02
。。。这不去算法吗
点赞 回复
分享
发布于 2018-09-22 16:33
本来有个面试机会,但是打算拒了,渣渣伤不起
点赞 回复
分享
发布于 2018-09-22 18:04
。。。。。。。。。。
点赞 回复
分享
发布于 2018-09-22 18:13
这是测试???
点赞 回复
分享
发布于 2018-09-25 14:55
可怕(๑ó﹏ò๑)
点赞 回复
分享
发布于 2018-10-13 17:38
这么恐怖的吗
点赞 回复
分享
发布于 2018-10-13 18:31
可怕,这是算法啊,这哪里是测试了?
点赞 回复
分享
发布于 2019-09-16 19:56
这是测试还是测开啊?
点赞 回复
分享
发布于 2019-09-26 10:35

相关推荐

5 83 评论
分享
牛客网
牛客企业服务