英特尔笔试题试题参考Word文档格式.docx
《英特尔笔试题试题参考Word文档格式.docx》由会员分享，可在线阅读，更多相关《英特尔笔试题试题参考Word文档格式.docx（16页珍藏版）》请在冰豆网上搜索。
S/N为10，其信噪比为10dB。
对于通过有噪声信道传输数字数据而言，信噪比非常重要，因为它设定了有噪声信道一个可达的数据传输速率上限，即对于带宽为W赫兹，信噪比为S/N的信道，其最大数据传输速率（信道容量）为：
C=W×
log2（1+S/N）（bps）
例如，对于一个带宽为3KHz，信噪比为30dB（S/N就是1000）的话音信道，无论其使用多少个电平信号发送二进制数据，其数据传输速率不可能超过30Kbps。
值得注意的是，香农定理仅仅给出了一个理论极限，实际应用中能够达到的速率要低得多。
其中一个原因是香农定理只考虑了热噪声（白噪声），而没有考虑脉冲噪声等因素。
4、以下代码运行结果是什么
intmain（）
{
inta,b,c,abc=0;
a=b=c=40;
if（c）
intabc;
abc=a*b+c;
}
printf（"
%d,%d"
abc,c）;
return0;
//040
5、给出了从纽约出发和到达洛杉矶的各种航班信息，写出找到一条从纽约到洛杉矶的最短距离的航班组合的代码。
单源最短路：
Dijkstra迪杰斯特拉n^2
BellmanFordve
SPFAO（ke），其中k为所有顶点进队的平均次数，可以证明k一般小于等于2
各点最短路：
Floyd-Warshall弗洛伊德n^3
最小生成树
Prim普里姆n^2
Kruskal克鲁斯卡尔eloge
代码如下
/*==================================================*\
|Dijkstra数组实现O（N^2）
|Dijkstra---数组实现（在此基础上可直接改为STL的Queue实现）
|lowcost[]---beg到其他点的最近距离
|path[]--beg为根展开的树，记录父亲结点
\*==================================================*/
#defineINF0x03F3F3F3F
constintN;
intpath[N],vis[N];
voidDijkstra（intcost[][N],intlowcost[N],intn,intbeg）{
inti,j,min;
memset（vis,0,sizeof（vis））;
vis[beg]=1;
for（i=0;
i<
n;
i++）{
lowcost[i]=cost[beg][i];
path[i]=beg;
}
lowcost[beg]=0;
path[beg]=-1;
//树根的标记
intpre=beg;
for（i=1;
min=INF;
for（j=0;
j<
j++）
//下面的加法可能导致溢出,INF不能取太大
if（vis[j]==0&
&
lowcost[pre]+cost[pre][j]<
lowcost[j]）{
lowcost[j]=lowcost[pre]+cost[pre][j];
path[j]=pre;
}
for（j=0;
if（vis[j]==0&
lowcost[j]<
min）{
min=lowcost[j];
pre=j;
}
vis[pre]=1;
}
|BellmanFord单源最短路O（VE）
|能在一般情况下，包括存在负权边的情况下，解决单源最短路径问题
|INIT:
edge[E][3]为边表
|CALL:
bellman（src）;
有负环返回0;
dist[i]为src到i的最短距
|可以解决差分约束系统:
需要首先构造约束图，构造不等式时>
=表示求最小值,作为最长路，<
=表示求最大值,作为最短路（v-u<
=c:
a[u][v]=c）
#definetypecint//typeofcost
consttypecinf=0x3f3f3f3f;
//maxofcost
intn,m,pre[V],edge[E][3];
typecdist[V];
intrelax（intu,intv,typecc）{
if（dist[v]>
dist[u]+c）{
dist[v]=dist[u]+c;
pre[v]=u;
return1;
return0;
intbellman（intsrc）{
inti,j;
++i）{
dist[i]=inf;
pre[i]=-1;
dist[src]=0;
boolflag;
++i）{
flag=false;
//优化
m;
++j）{
if（1==relax（edge[j][0],edge[j][1],edge[j][2]））flag=true;
}
if（!
flag）break;
for（j=0;
if（1==relax（edge[j][0],edge[j][1],edge[j][2]））
return0;
//有负圈
|SPFA（ShortestPathFasterAlgorithm）
Bellman-Ford算法的一种队列实现，减少了不必要的冗余计算。
它可以在O（kE）的时间复杂度内求出源点到其他所有点的最短路径，可以处理负边。
原理：
只有那些在前一遍松弛中改变了距离估计值的点，才可能引起他们的邻接点的距离估计值的改变。
判断负权回路：
记录每个结点进队次数，超过|V|次表示有负权。
//POJ3159Candies
constintINF=0x3F3F3F3F;
constintV=30001;
constintE=150001;
intpnt[E],cost[E],nxt[E];
inte,head[V];
intdist[V];
boolvis[V];
intmain（void）{
intn,m;
while（scanf（"
%d%d"
&
n,&
m）!
=EOF）{
inti,a,b,c;
e=0;
memset（head,-1,sizeof（head））;
for（i=0;
i<
m;
++i）
{//b-a<
=c,有向边（a,b）:
c，边的方向！
！
scanf（"
%d%d%d"
a,&
b,&
c）;
addedge（a,b,c）;
printf（"
%d\n"
SPFA（1,n））;
intrelax（intu,intv,intc）{
if（dist[v]>
dist[u]+c）{
inlinevoidaddedge（intu,intv,intc）{
pnt[e]=v;
cost[e]=c;
nxt[e]=head[u];
head[u]=e++;
intSPFA（intsrc,intn）
{//此处用堆栈实现，有些时候比队列要快
inti;
for（i=1;
=n;
++i）{//顶点1...n
vis[i]=0;
dist[i]=INF;
intQ[E],top=1;
Q[0]=src;
vis[src]=true;
while（top）{
intu,v;
u=Q[--top];
vis[u]=false;
for（i=head[u];
i!
=-1;
i=nxt[i]）{
v=pnt[i];
if（1==relax（u,v,cost[i]）&
!
vis[v]）{
Q[top++]=v;
vis[v]=true;
returndist[n];
语法：
Floyd_Washall（GraphG,intn,GraphD,GraphP）;
参数：
G：
图，用邻接矩阵表示
n：
图的顶点个数
D：
D[i,j]表示从i到j的最短距离
P：
P[i,j]表示从i到j的最短路径上j的父节点
自定义:
MaxN;
返回值：
null
注意:
此算法允许图中带有负权的弧,但不允许有路径长度为负值的回路.
源程序：
voidFloyd（intG[][MaxN],intn,intD[][MaxN],intP[][MaxN]）
{
inti,j,k;
i<
i++）
j<
j++）
{D[i][j]=G[i][j];
P[i][j]=i;
i++）{D[i][i]=0;
P[i][i]=0;
for（k=0;
k<
k++）
for（i=0;
if（D[i][j]>
D[i][k]+D[k][j]）
{D[i][j]=D[i][k]+D[k][j];
P[i][j]=P[k][j];
voidFloyd（intn,intD[][MaxN]）//G不用再输出的情况下.
|Prim求MST
cost[][]耗费矩阵（inf为无穷大）;
prim（cost,n）;
返回-1代表原图不连通;
consttypecinf=0x3f3f3f3f;
intvis[V];
typeclowc[V];
typecprim（typeccost[][V],intn）//vertex:
0~n-1
inti,j,p;
typecminc,res=0;
vis[0]=1;
i++）lowc[i]=cost[0][i];
i++）{
minc=inf;
p=-1;
if（0==vis[j]&
minc>
lowc[j]）{
minc=lowc[j];
p=j;
if（inf==minc）return-1;
//原图不连通
res+=minc;
vis[p]=1;
if（0==vis[j]&
lowc[j]>
cost[p][j]）
lowc[j]=cost[p][j];
returnres;
Kruskal算法
#include<
stdlib.h>
stdio.h>
queue>
algorithm>
string.h>
iostream>
math.h>
usingnamespacestd;
#defineMaxn1010
structEdge{
intu,v;
intw;
/*booloperator<
（constEdge&
E）{
returnw>
E.w;
}*/
}edge[1000010];
boolcmp（EdgeE1,EdgeE2）
returnE1.w>
E2.w;
intn,m;
intrank[Maxn],p[Maxn];
voidmakeset（intn）
for（inti=0;
=n;
{
rank[i]=0;
p[i]=i;
intfindset（intx）
if（x!
=p[x]）
p[x]=findset（p[x]）;
returnp[x];
voidunionset（intx,inty）
x=findset（x）;
y=findset（y）;
if（rank[x]>
rank[y]）
p[y]=x;
else
p[x]=y;
if（rank[x]==rank[y]）
rank[y]++;
/*
*
*/
intmain（intargc,char**argv）{
intt;
intT=0;
scanf（"
%d"
&
t）;
while（t--）
{
T++;
n,&
m）;
makeset（n）;
edge[i].u,&
edge[i].v,&
edge[i].w）;
sort（edge,edge+m,cmp）;
intans;
if（findset（edge[i].u）!
=findset（edge[i].v））
unionset（edge[i].u,edge[i].v）;
if（edge[i].w<
ans）ans=edge[i].w;
if（findset
（1）==findset（n））{ans=edge[i].w;
break;
printf（"
Scenario#%d:
\n"
T）;
%d\n\n"
ans）;
return（EXIT_SUCCESS）;
6、从计算机图形上截取某个物体边缘的若干个坐标，求这个物体面积，并跟判断是方形还是圆形，为啥。
7、离散卷机与DFT的区别与关系。
快速求不满足2^N长度的离散傅立叶变换的方法有哪些？
如何用fft求N*M点的离散卷机？
8、给出fir和iir的优缺点。
9、如何计算线性标量量化器的量化噪声？
需要那些假设？
10、设计一个重采样系统，说明如何anti-alias。
11、y1（n）=x（2n），y2（n）=x（n/2），问：
如果y1为周期函数，那么x是否为周期函数？
如果x为周期函数，那么y1是否为周期函数？
如果y2为周期函数，那么x是否为周期函数？
如果x为周期函数，那么y2是否为周期函数？
12、如果模拟信号的带宽为5kHz，要用8k的采样率，怎么办。
13、某个程序在一个嵌入式系统（200M的CPU，50M的SDRAM）中已经最优化了，换到另一个系统（300M的CPU，50M的SDRAM）中运行，还需要优化吗？
14、x^4+a*x^3+x^2+c*x+d最少需要做几次乘法。
15、三个float:
a,b,c问值：
（a+b）+c==（b+a）+c
（a+b）+c==（a+c）+b
16、把一个链表反向填空。
17、下面哪种排序法对12354最快？
A.quicksort
B.bublesort
C.mergesort
（,要求其它信息尽量按输入的顺序排列时很重要.这也是它比快速排序优势的地方.）
18、哪种结构平均来讲获取一个值最快？
A.binarytree
B.hashtable
C.stack
19、
structbit
{
inta:
3;
intb:
2;
intc:
};
intmain（intargc,char*argv[]）
bits;
char*c=（char*）&
s;
*c=0x99;
for（inti=7;
i>
=0;
i--）
*c&
（1<
<
i）?
1:
0）;
）;
%d%d%d\n"
s.a,s.b,s.c）;
0x99==10011001x86是小端所以，s.a==001，s.b==11，s.c==100
b和c最高位是1，都是负数。
负数在计算机里用补码表示。
补码->
-1，等到反码->
然后得到原码。
11-1==10->
10取反，得原码01，所以其数值为“-1”。
100-1==011->
011取反，得原码100，所以其数值为“-4”。
统一用这种方法求补码，或求补码的真值！
以前那种很容易错！
求-15的补码
第一步：
+15：
00001111
第二步：
逐位取反（1变成0，0变成1），然后在末尾加1。
11110001
再举一个例子验证下：
求-64的补码
+64：
01000000
11000000
逆：
二进制值：
10111111（-65的补码）
各位取反：
加1：
01000001（+65的补码）
20、挑bug，在linux下运行：
#includechar
*reverse（char*str）
intlen=0,i=0;
char*pstr=str,*ptemp,*pd;
while（*++pstr）
len++;
pstr--;
//ptemp=（char*）malloc（len+1）;
ptemp=（char*）malloc（len+1）;
pd=ptemp;
while（len--）{
*ptemp=*pstr;
ptemp++;
i++;
升级会员 