神州算法工程师面试

❶ 嵌入式工程师面试中常出现的算法

嵌入式工程师面试中常出现的算法

嵌入式系统是以应用为中心，以计算机技术为基础，并且软硬件可裁剪，适用于应用系统对功能、可靠性、成本、体积、功耗有严格要求的专用计算机系统。下面我为大家整理了关于嵌入式工程师面试中经常出现的算法文章，希望对你有所帮助。

二分查找的代码.

int bfind(int* a,int len,int val)

{

int m = len/2;

int l = 0;

int r = len;

while(l!=m && r!= m)

{

if(a[m] > val)

{

r = m;

m = (m+l)/2;

}

else if(a[m] < val)

{

l = m;

m = (m+r)/2;

}

else

return m;

}

return -1; //没有找到

}

写出在母串中查找子串出现次数的代码.

int count1(char* str,char* s)

{

char* s1;

char* s2;

int count = 0;

while(*str!='')

{

s1 = str;

s2 = s;

while(*s2 == *s1&&(*s2!='')&&(*s1!='0'))

{

s2++;

s1++;

}

if(*s2 == '')

count++;

str++;

}

return count;

}

查找第一个匹配子串位置,如果返回的是s1长度len1表示没有找到

size_t find(char* s1,char* s2)

{

size_t i=0;

size_t len1 = strlen(s1)

size_t len2 = strlen(s2);

if(len1-len2<0) return len1;

for(;i {

size_t m = i;

for(size_t j=0;j {

if(s1[m]!=s2[j])

break;

m++;

}

if(j==len)

break;

}

return i }

写出快速排序或者某种排序算法代码

快速排序:

int partition(int* a,int l,int r)

{

int i=l-1,j=r,v=a[r];

while(1)

{

while(a[++i] while(a[--j]>v) if(j<=i) break;

if(i>=j)

break;

swap(a[i],a[j]);

}

swap(a[i],a[r]);

return i;

}

void qsort(int* a,int l,int r)

{

if(l>=r) return;

int i = partition(a,l,r);

qsort(a,l,i-1);

qsort(a,i+1,r);

}

冒泡排序:

void buble(int *a,int n)

{

for(int i=0;i {

for(int j=1;j {

if(a[j] {

int temp=a[j];

a[j] = a[j-1];

a[j-1] = temp;

}

}

}

}

插入排序：

void insertsort(int* a,int n)

{

int key;

for(int j=1;j {

key = a[j];

for(int i=j-1;i>=0&&a[i]>key;i--)

{

a[i+1] = a[i];

}

a[i+1] = key;

}

}

出现次数相当频繁

实现strcmp函数

int strcmp11(char* l,char* r)

{

assert(l!=0&&r!=0);

while(*l == *r &&*l != '') l++,r++;

if(*l > *r)

return 1;

else if(*l == *r)

return 0;

return -1;

}

实现字符串翻转

void reserve(char* str)

{

assert(str != NULL);

char * p1 = str;

char * p2 = str-1;

while(*++p2); //一般要求不能使用strlen

p2 -= 1;

while(p1 {

char c = *p1;

*p1++ = *p2;

*p2-- = c;

}

}

将一个单链表逆序

struct list_node

{

list_node(int a,list_node* b):data(a),next(b) //这个为了测试方便

{}

int data;

list_node* next;

};

void reserve(list_node* phead)

{

list_node* p = phead->next;

if(p == NULL || p->next == NULL) return; //只有头节点或一个节点

list_node* p1=p->next;

p->next=NULL;

while(p1!=NULL)

{

p = p1->next;

p1->next = phead->next;

phead->next = p1;

p1 = p;

}

}

测试程序：

list lt;

lt.phead = new list_node(0,0);

lt.phead->next = new list_node(1,0);

lt.phead->next->next = new list_node(2,0);

lt.phead->next->next->next = new list_node(3,0);

lt.reserve();

list_node * p = lt.phead;

while(p)

{

coutnext;

}

循环链表的节点对换和删除。

//双向循环

list_node* earse(list_node* node)

{

// if(node == rear) return node->next; //对于头节点可判断也可不判断。最好加上

list_node* next = node->next;

next->prev = node->prev;

node->prev->next = next;

delete node;

retrun next;

}

//单项循环

list_node* earse(list_node* node)

{

// if(node == rear) return node->next; //对于头节点可判断也可不判断。最好加上

list_node* p = rear;

while(p->next != node) p=p->next;

p->next = node->next;

delete node;

retrun p->next;

}

将一个数字字符串转换为数字."1234" -->1234

int atoii(char* s)

{

assert(s!=NULL);

int num = 0;

int temp;

while(*s>'0' && *s<'9')

{

num *= 10;

num += *s-'0';

s++;

}

return num;

}

出现次数相当频繁

.实现任意长度的整数相加或者相乘功能。

void bigadd(char* num,char* str,int len)

{

for(int i=len;i>0;i--)

{

num[i] += str[i];

int j = i;

while(num[j]>=10)

{

num[j--] -= 10;

num[j] += 1;

}

}

}

.写函数完成内存的拷贝

void* memcpy( void *dst, const void *src, unsigned int len )

{

register char *d;

register char *s;

if (len == 0)

return dst;

if ( dst > src ) //考虑覆盖情况

{

d = (char *)dst + len - 1;

s = (char *)src + len - 1;

while ( len >= 4 ) //循环展开，提高执行效率

{

*d-- = *s--;

*d-- = *s--;

*d-- = *s--;

*d-- = *s--;

len -= 4;

}

while ( len-- )

{

*d-- = *s--;

}

}

else if ( dst < src )

{

d = (char *)dst;

s = (char *)src;

while ( len >= 4 )

{

*d++ = *s++;

*d++ = *s++;

*d++ = *s++;

*d++ = *s++;

len -= 4;

}

while ( len-- )

{

*d++ = *s++;

}

}

return dst;

}

出现次数相当频繁

编写类String的构造函数、析构函数和赋值函数，已知类String的原型为：

class String

{

public:

String(const char *str = NULL); // 普通构造函数

String(const String &other); // 拷贝构造函数

~ String(void); // 析构函数

String & operate =(const String &other); // 赋值函数

private:

char *m_data; // 用于保存字符串

};

解答：

//普通构造函数

String::String(const char *str)

{

if(str==NULL)

{

m_data = new char[1]; // 得分点：对空字符串自动申请存放结束标志''的`空

//加分点：对m_data加NULL 判断

*m_data = '';

}

else

{

int length = strlen(str);

m_data = new char[length+1]; // 若能加 NULL 判断则更好

strcpy(m_data, str);

}

}

// String的析构函数

String::~String(void)

{

delete [] m_data; // 或delete m_data;

}

//拷贝构造函数

String::String(const String &other) // 得分点：输入参数为const型

{

int length = strlen(other.m_data);

m_data = new char[length+1]; //加分点：对m_data加NULL 判断

strcpy(m_data, other.m_data);

}

//赋值函数

String & String::operate =(const String &other) // 得分点：输入参数为const型

{

if(this == &other) //得分点：检查自赋值

return *this;

delete [] m_data; //得分点：释放原有的内存资源

int length = strlen( other.m_data );

m_data = new char[length+1]; //加分点：对m_data加NULL 判断

strcpy( m_data, other.m_data );

return *this; //得分点：返回本对象的引用

}

剖析：

能够准确无误地编写出String类的构造函数、拷贝构造函数、赋值函数和析构函数的面试者至少已经具备了C++基本功的60%以上!

在这个类中包括了指针类成员变量m_data，当类中包括指针类成员变量时，一定要重载其拷贝构造函数、赋值函数和析构函数，这既是对C++程序员的基本要求，也是《EffectiveC++》中特别强调的条款。

实现strcpy

char * strcpy( char *strDest, const char *strSrc )

{

assert( (strDest != NULL) && (strSrc != NULL) );

char *address = strDest;

while( (*strDest++ = * strSrc++) != ‘’ );

return address;

}

编写一个函数，作用是把一个char组成的字符串循环右移n个。比如原来是“abcdefghi”如果n=2，移位后应该是“hiabcdefgh”

函数头是这样的：

//pStr是指向以''结尾的字符串的指针

//steps是要求移动的n

void LoopMove ( char * pStr, int steps )

{

//请填充...

}

解答：

正确解答1：

void LoopMove ( char *pStr, int steps )

{

int n = strlen( pStr ) - steps;

char tmp[MAX_LEN];

strcpy ( tmp, pStr + n );

strcpy ( tmp + steps, pStr);

*( tmp + strlen ( pStr ) ) = '';

strcpy( pStr, tmp );

}

正确解答2：

void LoopMove ( char *pStr, int steps )

{

int n = strlen( pStr ) - steps;

char tmp[MAX_LEN];

memcpy( tmp, pStr + n, steps );

memcpy(pStr + steps, pStr, n );

memcpy(pStr, tmp, steps );

}

;

❷ 计算机视觉算法工程师常见面试题1

参考： https://www.hu.com/column/c_1170719557072326656

反卷积也称为转置卷积，如果用矩阵乘法实现卷积操作，将卷积核平铺为矩阵，则转置卷积在正向计算时左乘这个矩阵的转置WT，在反向传播是左乘W，与卷积操作刚好相反，需要注意的是，反卷积不是卷积的逆运算。
[知乎问题+caffe实现]

实现上采样；近似重构输入图像，卷积层可视化。

只要激活函数选择得当，神经元的数量足够，至少有一个隐含层的神经网络可以 逼近闭区间上任意一个连续函数到任意指定的精度。

判别模型，直接输出类别标签，或者输出类后验概率p(y|x)
[ https://www.hu.com/question/268906476]
[ https://zhuanlan.hu.com/p/40024110]
[ https://zhuanlan.hu.com/p/159189617]

BN是在 batch这个维度上进行归一化，GN是计算channel方向每个group的均值方差.

检测结果与 Ground Truth 的交集比上它们的并集，即为检测的准确率 IoU

内存/显存占用；模型收敛速度等

Hessian矩阵是n*n， 在高维情况下这个矩阵非常大，计算和存储都是问题。

mini-batch太小会导致收敛变慢，太大容易陷入sharp minima，泛化性不好。

可以把dropout看成是 一种ensemble方法，每次做完dropout相当于从原网络中找到一个更瘦的网络。

pooling操作虽然能增大感受野，但是会丢失一些信息。空洞卷积在卷积核中插入权重为0的值，因此每次卷积中会skip掉一些像素点；

空洞卷积增大了卷积输出每个点的感受野，并且不像pooling会丢失信息，在图像需要全局信息或者需要较长sequence依赖的语音序列问题上有着较广泛的应用。

表达式为：

使用BN的原因是网络训练中每一层不断改变的参数会导致后续每一层输入的分布发生变化，而学习的过程又要使每一层去适应输入的分布，因此不得不降低网络的学习率，并且要小心得初始化（internal covariant shift）
如果仅通过归一化方法使得数据具有零均值和单位方差，则会降低层的表达能力（如使用Sigmoid函数时，只使用线性区域）
BN的具体过程（注意第三个公式中分母要加上epsilon）

最好的解释是通过1 * 1卷积核能实现多个channel间的解耦合，解耦cross-channel correlation和spatial correlation。
【但是因为解耦不彻底，因此后续有了mobile net的组卷积方式和shuffle net组卷积方式】

由于 1×1 并不会改变 height 和 width，改变通道的第一个最直观的结果，就是可以将原本的数据量进行增加或者减少。改变的只是 height × width × channels 中的 channels 这一个维度的大小而已。

1*1卷积核，可以在保持feature map尺度不变的（即不损失分辨率）的前提下大幅增加非线性特性（利用后接的非线性激活函数），把网络做的很deep。

备注：一个filter对应卷积后得到一个feature map，不同的filter(不同的weight和bias)，卷积以后得到不同的feature map，提取不同的特征，得到对应的specialized neuron。

例子：使用1x1卷积核，实现降维和升维的操作其实就是channel间信息的线性组合变化，3x3，64channels的卷积核后面添加一个1x1，28channels的卷积核，就变成了3x3，28channels的卷积核，原来的64个channels就可以理解为跨通道线性组合变成了28channels，这就是通道间的信息交互

注意：只是在channel维度上做线性组合，W和H上是共享权值的sliding window

并不能说明这个模型无效导致模型不收敛的原因可能有

A. 在实际场景下，应尽量使用ADAM，避免使用SGD
B. 同样的初始学习率情况下，ADAM的收敛速度总是快于SGD方法
C. 相同超参数数量情况下，比起自适应的学习率调整方式，SGD加手动调节通常会取得更好效果
D. 同样的初始学习率情况下，ADAM比SGD容易过拟合

A.保证每一层的感受野不变，网络深度加深，使得网络的精度更高
B.使得每一层的感受野增大，学习小特征的能力变大
C.有效提取高层语义信息，且对高层语义进行加工，有效提高网络准确度
D.利用该结构有效减轻网络的权重

A.计算简单
B.非线性
C.具有饱和区
D.几乎处处可微
【relu函数在0处是不可微的。】

A.Adam的收敛速度比RMSprop慢
B.相比于SGD或RMSprop等优化器，Adam的收敛效果是最好的
C.对于轻量级神经网络，使用Adam比使用RMSprop更合适
D.相比于Adam或RMSprop等优化器，SGD的收敛效果是最好的
【SGD通常训练时间更长，容易陷入鞍点，但是在好的初始化和学习率调度方案的情况下，结果更可靠。如果在意更快的收敛，并且需要训练较深较复杂的网络时，推荐使用学习率自适应的优化方法。】

A.使用ReLU做为激活函数，可有效地防止梯度爆炸
B.使用Sigmoid做为激活函数，较容易出现梯度消失
C.使用Batch Normalization层，可有效的防止梯度爆炸
D.使用参数weight decay，在一程度上可防止模型过拟合

对结果存疑。认为二者皆可防止。

A.SGD
B.FTRL
C.RMSProp
D.L-BFGS

L-BFGS（Limited-memory BFGS，内存受限拟牛顿法）方法：
所有的数据都会参与训练，算法融入方差归一化和均值归一化。大数据集训练DNN，容易参数量过大 (牛顿法的进化版本，寻找更好的优化方向，减少迭代轮数）从LBFGS算法的流程来看，其整个的核心的就是如何快速计算一个Hesse的近似：重点一是近似，所以有了LBFGS算法中使用前m个近似下降方向进行迭代的计算过程；重点二是快速，这个体现在不用保存Hesse矩阵上，只需要使用一个保存后的一阶导数序列就可以完成，因此不需要大量的存储，从而节省了计算资源；重点三，是在推导中使用秩二校正构造了一个正定矩阵，即便这个矩阵不是最优的下降方向，但至少可以保证函数下降。
FTRL(Follow-the-regularized-Leader)是一种适用于处理超大规模数据的,含大量稀疏特征的在线学习的常见优化算法，方便实用，而且效果很好，常用于更新在线的CTR预估模型；FTRL在处理带非光滑正则项（如L1正则）的凸优化问题上表现非常出色，不仅可以通过L1正则控制模型的稀疏度，而且收敛速度快；

A.LSTM在一定程度上解决了传统RNN梯度消失或梯度爆炸的问题
B.CNN相比于全连接的优势之一是模型复杂度低，缓解过拟合
C.只要参数设置合理，深度学习的效果至少应优于随机算法
D.随机梯度下降法可以缓解网络训练过程中陷入鞍点的问题

实际上，现在有很多针对小目标的措施和改良，如下：

最常见的是Upsample来Rezie网络输入图像的大小；

用dilated/astrous等这类特殊的卷积来提高检测器对分辨率的敏感度；（空洞卷积是针对图像语义分割问题中下采样会降低图像分辨率、丢失信息而提出的一种卷积思路。利用添加空洞扩大感受野，让原本3 x3的卷积核，在相同参数量和计算量下拥有5x5（dilated rate =2）或者更大的感受野，从而无需下采样。在保持参数个数不变的情况下增大了卷积核的感受野）

有比较直接的在浅层和深层的Feature Map上直接各自独立做预测的，这个就是我们常说的尺度问题。

用FPN这种把浅层特征和深层特征融合的，或者最后在预测的时候，用浅层特征和深层特征一起预测；

SNIP（Scale Normalization for Image Pyramids）主要思路：

在训练和反向传播更新参数时，只考虑那些在指定的尺度范围内的目标，由此提出了一种特别的多尺度训练方法。

❸ 都快2021年了，算法岗位应该怎样准备面试

说到算法岗位，现在网上的第一反应可能就是内卷，算法岗位也号称是内卷最严重的岗位。针对这个问题，其实之前我也有写过相关的文章。这个岗位竞争激烈不假，但我个人觉得称作内卷有些过了。就我个人的感觉，这几年的一个大趋势是从迷茫走向清晰。

早在2015年我在阿里妈妈实习的时候，那个时候我觉得其实对于算法工程师这个岗位的招聘要求甚至包括工作内容其实业内是没有一个统一的标准的。可以认为包括各大公司其实对这个岗位具体的工作内容以及需要的候选人的能力要求都不太一致，不同的面试官有不同的风格，也有不同的标准。

我举几个例子，第一个例子是我当初实习面试的时候，因为是本科生，的确对机器学习这个领域了解非常非常少，可以说是几乎没有。但是我依然通过了，通过的原因也很简单，因为有acm的获奖背景，面试的过程当中主要也都是一些算法题，都还算是答得不错。但是在交叉面试的时候，一位另一个部门的总监就问我有没有这块的经验？我很明确地说了，没有，但是我愿意学。

接着他告诉我，算法工程师的工作内容主要和机器学习相关，因此机器学习是基本的。当时我就觉得我凉了，然而很意外地是还是通过了面试。

核心能力

由于我已经很久没有接触校招了，所以也很难说校招面试应该怎么样准备，只能说说如果是我来招聘，我会喜欢什么样的学生。也可以理解成我理解的一个合格优秀的算法工程师应该有的能力。

模型理解

算法工程师和模型打交道，那么理解模型是必须的。其实不用说每一个模型都精通，这没有必要，面试的时候问的模型也不一定用得到。但更多地是看重这个人在学习的时候的习惯，他是浅尝辄止呢，还是会刨根究底，究竟能够学到怎样的地步。

在实际的工作当中我们可能会面临各种各样的情况，比如说新加了特征但是没有效果，比如升级了模型效果反而变差了等等，这些情况都是有可能发生的。当我们遇到这些情况之后，需要我们根据已知的信息来推理和猜测导致的原因从而针对性的采取相应的手段。因此这就需要我们对当前的模型有比较深入地了解，否则推导原因做出改进也就无从谈起。

所以面试的时候问起哪个模型都不重要，重要的是你能不能体现出你有过深入的研究和理解。

数据分析

算法工程师一直和数据打交道，那么分析数据、清洗数据、做数据的能力也必不可少。说起来简单的数据分析，这当中其实牵扯很多，简单来说至少有两个关键点。

第一个关键点是处理数据的能力，比如SQL、hive、spark、MapRece这些常用的数据处理的工具会不会，会多少？是一个都不会呢，还是至少会一点。由于各个公司的技术栈不同，一般不会抱着候选人必须刚好会和我们一样的期待去招人，但是候选人如果一无所知肯定也是不行的。由于学生时代其实很少接触这种实践的内容，很多人对这些都一无所知，如果你会一两个，其实就是加分项。

第二个关键点是对数据的理解力，举个简单的例子，比如说现在的样本训练了模型之后效果不好，我们要分析它的原因，你该怎么下手？这个问题日常当中经常遇到，也非常考验算法工程师对数据的分析能力以及他的经验。数据是水，模型是船，我们要把船驶向远方，只懂船只构造是不行的，还需要对水文、天象也有了解。这样才能从数据当中捕捉到trick，对一些现象有更深入的看法和理解。

工程能力

虽然是算法工程师，但是并不代表工程能力不重要，相反工程能力也很重要。当然这往往不会成为招聘的硬性指标， 比如考察你之前做过什么工程项目之类的。但是会在你的代码测试环节有所体现，你的代码风格，你的编码能力都是你面试的考察点之一。

并不只是在面试当中如此，在实际工作当中，工程能力也很关键。往小了说可以开发一些工具、脚本方便自己或者是团队当中其他人的日常工作，往大了说，你也可以成为团队当中的开发担当，负责其团队当中最工程的工作。比如说复现一篇paper，或者是从头撸一个模型。这其实也是一种差异化竞争的手段，你合理地负担起别人负担不了的工作，那么自然就会成为你的业绩。

时代在变化，行业在发展，如今的校招会问些什么早已经和当年不同了。但不管怎么说，这个岗位以及面试官对于人才的核心诉求几乎是没有变过的，我们从核心出发去构建简历、准备面试，相信一定可以有所收获。

❹ autox面试难度

autox面试难度一般。

autox（控制算法工程师）面试是一对一技术面，面试是一个部门主管，面试开始先确认身份，然后让自我介绍，然后开始对着简历问问题，项目、技能等，然后聊岗位了解情况，期望薪资、工作城市、最后开始对着简历问问题，第一个让解释项目结果，用到的软件工具及各自的作用。也不算很难，一般难度。

面试简介：

面试是通过书面、面谈或线上交流（视频、电话）的形式来考察一个人的工作能力与综合素质，通过面试可以初步判断应聘者是否可以融入自己的团队。在特定场景下，以面试官对应聘者的交谈与观察为主要手段，由表及里测评应聘者的知识、能力、经验和综合素质等有关素质的考试活动。

面试是公司挑选职工的一种重要方法。面试给公司和应聘者提供了进行双向交流的机会，能使公司和应聘者之间相互了解，从而双方都可更准确做出聘用与否、受聘与否的决定。

以上内容参考网络-面试