华为校园招聘机考试题总结厦门大学.docx
《华为校园招聘机考试题总结厦门大学.docx》由会员分享，可在线阅读，更多相关《华为校园招聘机考试题总结厦门大学.docx（51页珍藏版）》请在冰豆网上搜索。
华为校园招聘机考试题总结厦门大学
2012华为校园招聘机考试题总结（厦门大学）
1、删除子串，只要是原串中有相同的子串就删掉，不管有多少个，返回子串个数。
#include
#include
#include
#include
intdelete_sub_str（constchar*str,constchar*sub_str,char*result）
{
assert（str!
=NULL&&sub_str!
=NULL）;
constchar*p,*q;
char*t,*temp;
p=str;
q=sub_str;
t=result;
intn,count=0;
n=strlen（q）;
tmep=（char*）malloc（n+1）;
memset（temp,0x00,n+1）;
while（*p）
{
memcpy（temp,p,n）;
if（strcmp（temp,q）==0）
{
count++;
memset（temp;0x00,n+1）;
p=p+n;
}
else
{
*t=*p;
p++;
t++;
memset（temp,0x00,n+1）;
}
}
free（temp）;
returncount;
}
intmain（）
{
chars[100]={‘\0’};
intnum=delete_sub_str（“123abc12de234fg1hi34j123k”,”123”,s）;
printf（“Thenumberofsub_stris%d\r\n”,num）;
printf（“Theresultstringis%s\r\n”,s）;
}
2、约瑟夫环是一个数学的应用问题：
已知n个人（以编号1，2，3...n分别表示）围坐在一张圆桌周围。
从编号为k的人开始报数，数到m的那个人出列；他的下一个人又从1开始报数，数到m的那个人又出列；依此规律重复下去，直到圆桌周围的人全部出列。
#include
#include
typedefstructNode
{
intnum;
structNode*next;
}LinkList;
LinkList*creat（intn）
{
LinkList*p,*q,*head;
inti=1;
p=（LinkList*）malloc（sizeof（LinkList））;
p->num=i;
head=p;
for（i=2;i<=n;i++）
{
q=（LinkList*）malloc（sizeof（LinkList））;
q->num=i;
p->next=q;
p=q;
}
p->next=head;/*使链表尾指向链表头形成循环链表*/
returnhead;
}
voidfun（LinkList*L,intm）
{
inti;
LinkList*p,*s,*q;
p=L;
printf（"出列顺序为:
"）;
while（p->next!
=p）
{
for（i=1;i{q=p;
p=p->next;
}
printf（"%5d",p->num）;
s=p;
q->next=p->next;
p=p->next;
free（s）;
}
printf（"%5d\n",p->num）;
}
intmain（）
{
LinkList*L;
intn,m;
n=9;
m=5;
L=creat（n）;
fun（L,m）;
return0;
}
3、比较一个数组的元素 是否为回文数组
#include
#include
inthuiwen（charstr[]）
{
inti,len,k=1;
len=strlen（str）;
for（i=0;i{
if（str[i]!
=str[len-i-1]）
{
k=1;
break;
}
}
if（k==0）
printf（"%s不是一个回文数\n",str）;
else
printf（"%s是一个回文数\n",str）;
}
voidmain（）
{
charstr[100]={0};
inti;
intlen;
printf（"Inputastring：
"）;/*提示输入Inputastring：
*/
scanf（"%s",str）;/*scan（）函数输入一个字符串：
*/
huiwen（str）;
}
4、 数组比较（20分）
•问题描述：
比较两个数组，要求从数组最后一个元素开始逐个元素向前比较，如果2个数组长度不等，则只比较较短长度数组个数元素。
请编程实现上述比较，并返回比较中发现的不相等元素的个数
比如：
数组{1,3,5}和数组{77,21,1,3,5}按题述要求比较，不相等元素个数为0
数组{1,3,5}和数组{77,21,1,3,5,7}按题述要求比较，不相等元素个数为3
•要求实现函数：
int array_compare（int len1, int array1[], int len2, int array2[]）
【输入】int len1：
输入被比较数组1的元素个数；
int array1[]：
输入被比较数组1；
int len2：
输入被比较数组2的元素个数；
int array2[]：
输入被比较数组2；
【输出】无
【返回】不相等元素的个数，类型为int
•示例
1）输入：
int array1[] = {1,3,5}，int len1 = 3，int array2[] = {77,21,1,3,5}，int len2 = 5
函数返回：
0
2）输入：
int array1[] = {1,3,5}，int len1 = 3，int array2[] = {77,21,1,3,5,7}，int len2 = 6
函数返回：
３
#include
#include
#include
intarray_compare（intlen1,intarray1[],intlen2,intarray2[]）
{
intcount=0;
for（;len1>=0&&len2>=0;len1--,len2--）
{
if（array1[len1-1]==array2[len2-1]）
{
count++;
}
}
returncount;
}
intmain（）
{
intresult=0;
intarray1[]={1,3,5};
intlen1=3;
intarray2[]={77,12,1,3,5};
intlen2=5;
result=array_compare（len1,array1,len2,array2）;///result=array_compare（len1,array1[],len2,array2[]）;不能这样
//函数形参中永远只是传得首地址，不能传数组切记切记！
！
！
！
！
！
printf（"theresultis%d",result）;
}
5、约瑟夫问题
•问题描述：
输入一个由随机数组成的数列（数列中每个数均是大于0的整数，长度已知），和初始计数值m。
从数列首位置开始计数，计数到m后，将数列该位置数值替换计数值m，并将数列该位置数值出列，然后从下一位置从新开始计数，直到数列所有数值出列为止。
如果计数到达数列尾段，则返回数列首位置继续计数。
请编程实现上述计数过程，同时输出数值出列的顺序
比如：
输入的随机数列为：
3,1,2,4，初始计数值m=7，从数列首位置开始计数（数值3所在位置）
第一轮计数出列数字为2，计数值更新m=2，出列后数列为3,1,4，从数值4所在位置从新开始计数
第二轮计数出列数字为3，计数值更新m=3，出列后数列为1,4，从数值1所在位置开始计数
第三轮计数出列数字为1，计数值更新m=1，出列后数列为4，从数值4所在位置开始计数
最后一轮计数出列数字为4，计数过程完成。
输出数值出列顺序为：
2,3,1,4。
•要求实现函数：
void array_iterate（int len, int input_array[], int m, int output_array[]）
【输入】int len：
输入数列的长度；
int intput_array[]：
输入的初始数列
int m：
初始计数值
【输出】int output_array[]：
输出的数值出列顺序
【返回】无
•示例
输入：
int input_array[] = {3,1,2,4}，int len = 4， m=7
输出：
output_array[] = {2,3,1,4}
////////////循环链表实现//////////////////////
#include
#include
#include
typedefstructNode
{
intnum;
structnode*next;
}node;
node*creat（intlen,intinput_array[]）
{
node*h,*s,*p;
inti;
h=（node*）malloc（sizeof（node））;
h->num=input_array[0];
p=h;
for（i=1;i{
s=（node*）malloc（sizeof（node））;
s->num=input_array[i];
p->next=s;
p=s;
}
p->next=h;
return（h）;
}
voidarray_iterate（intlen,intinput_array[],intm）
{
node*q,*p,*s;
inti=0,j=0,k;
intoutput_array[4];
p=creat（len,input_array）;
while（p->next!
=p）
{
for（i=1;i{
q=p;
p=p->next;
}
m=p->num;
printf（"%5d",m）;
output_array[j++]=m;
s=p;
q->next=p->next;
p=p->next;
free（s）;
s=NULL;
}
m=p->num;
printf（"%5d\n",m）;
output_array[j]=p->num;
k=j;
for（j=0;j<=k;j++）
{
printf（"%5d",output_array[j]）;
}
}
intmain（）
{
intinput_array[]={3,1,2,4};
intlen=4;
intm=7;
intoutput_array[4];
array_iterate（len,input_array,m,output_array）;
}
6、手机号码合法性判断（20分）
●问题描述：
我国大陆运营商的手机号码标准格式为：
国家码+手机号码，例如：
8613912345678。
特点如下：
1、长度13位；
2、以86的国家码打头；
3、手机号码的每一位都是数字。
请实现手机号码合法性判断的函数要求：
1）如果手机号码合法，返回0；
2）如果手机号码长度不合法，返回1
3）如果手机号码中包含非数字的字符，返回2；
4）如果手机号码不是以86打头的，返回3；
【注】除成功的情况外，以上其他合法性判断的优先级依次降低。
也就是说，如果判断出长度不合法，直接返回1即可，不需要再做其他合法性判断。
●要求实现函数：
intverifyMsisdn（char*inMsisdn）
【输入】char*inMsisdn，表示输入的手机号码字符串。
【输出】无
【返回】判断的结果，类型为int。
●示例
输入：
inMsisdn=“869123456789“
输出：
无
返回：
1
输入：
inMsisdn=“88139123456789“
输出：
无
返回：
3
输入：
inMsisdn=“86139123456789“
输出：
无
返回：
0
#include
#include
#include
#include
#defineLENGTH13
intverifyMsisdn（char*inMsisdn）
{
char*pchar=NULL;
assert（inMsisdn!
=NULL）;
if（LENGTH==strlen（inMsisdn））
{
if（（'8'==*inMsisdn）&&（*（inMsisdn+1）=='6'））
{
while（*inMsisdn!
='\0'）
{
if（（*inMsisdn>='0'）&&（*inMsisdn<='9'））
inMsisdn++;
else
return2;
}
}
else
return3;
}
else
return1;
return0;
}
intmain（）
{
char*pchar=NULL;
unsignedcharichar=0;
intresult;
switch（ichar）
{
case0:
pchar="8612345363789";break;
case1:
pchar="861111111111111";break;
case2:
pchar="86s1234536366";break;
default:
break;
}
result=verifyMsisdn（pchar）;
printf（"resultis%d\n",result）;
}
7、 数组比较（20分）
•问题描述：
比较两个数组，要求从数组最后一个元素开始逐个元素向前比较，如果2个数组长度不等，则只比较较短长度数组个数元素。
请编程实现上述比较，并返回比较中发现的不相等元素的个数
比如：
数组{1,3,5}和数组{77,21,1,3,5}按题述要求比较，不相等元素个数为0
数组{1,3,5}和数组{77,21,1,3,5,7}按题述要求比较，不相等元素个数为3
•要求实现函数：
int array_compare（int len1, int array1[], int len2, int array2[]）
【输入】int len1：
输入被比较数组1的元素个数；
int array1[]：
输入被比较数组1；
int len2：
输入被比较数组2的元素个数；
int array2[]：
输入被比较数组2；
【输出】无
【返回】不相等元素的个数，类型为int
•示例
1）输入：
int array1[] = {1,3,5}，int len1 = 3，int array2[] = {77,21,1,3,5}，int len2 = 5
函数返回：
0
2）输入：
int array1[] = {1,3,5}，int len1 = 3，int array2[] = {77,21,1,3,5,7}，int len2 = 6
函数返回：
3
#include
#include
#include
intarray_compare（intlen1,intarray1[],intlen2,intarray2[]）
{
intcount=0;
for（;len1>=0&&len2>=0;len1--,len2--）
{
if（array1[len1-1]==array2[len2-1]）
{
count++;
}
}
returncount;
}
intmain（）
{
intresult=0;
intarray1[]={1,3,5};
intlen1=3;
intarray2[]={77,12,1,3,5};
intlen2=5;
result=array_compare（len1,array1,len2,array2）;
///result=array_compare（len1,array1[],len2,array2[]）;不能这样
//函数形参中永远只是传得首地址，不能传数组切记切记！
！
！
！
！
！
printf（"theresultis%d",result）;
}
8、简单四则运算
•问题描述：
输入一个只包含个位数字的简单四则运算表达式字符串，计算该表达式的值
注：
1、表达式只含 +, -, *, / 四则运算符，不含括号
2、表达式数值只包含个位整数（0-9），且不会出现0作为除数的情况
3、要考虑加减乘除按通常四则运算规定的计算优先级
4、除法用整数除法，即仅保留除法运算结果的整数部分。
比如8/3=2。
输入表达式保证无0作为除数情况发生
5、输入字符串一定是符合题意合法的表达式，其中只包括数字字符和四则运算符字符，除此之外不含其它任何字符，不会出现计算溢出情况
•要求实现函数：
int calculate（int len,char *expStr）
【输入】int len:
字符串长度；
char *expStr:
表达式字符串；
【输出】无
【返回】计算结果
•示例
1）输入：
char *expStr = “1+4*5-8/3”
函数返回：
19
2）输入：
char *expStr = “8/3*3”
函数返回：
6
#include
/*
*authorbywanww
*time:
2011-09-07
*/
usingnamespacestd;
intarray_compare（intlen1,intarray1[],intlen2,intarray2[]）
{
if（len1==len2）{
intcount=0;
for（inti=0;i{
if（array1[i]!
=array2[i]）count++;
}
returncount;
}elseif（len1returnarray_compare（len1,array1,len1,array2+len2-len1）;
}else{
returnarray_compare（len2,array1+len1-len2,len2,array2）;
}
}
voidarray_iterate（intlen,intinput_array[],intm,intoutput_array[]）
{
int*flag=newint[len];
memset（flag,0,len*4）;
inthasout=0;//已经出列的数字个数
intstart=0;//开始的下标号
intj=0;//当前以报到的数字
while（true）
{
if（flag[start]==0）//当前元素还没出列
{
j++;
if（j==m）//已经计数到m,当前start下标的元素出列
{
output_array[hasout]=input_array[start];
flag[start]=1;//标记当前元素已经出列
hasout++;
if（hasout==len）break;//所有的元素都已经出列，结束程序
//初始化下一轮的数字
j=0;
m=input_array[start];
}
}
start++;
if（start==len）start=0;
}
delete[]flag;
}
intcalculate（intlen,char*expStr）
{
struct{
charopdata[200];
inttop;
}opstack;
//定义操作符栈
opstack.top=-1;
inti=0;//遍历字符串的下标
intt=0;//当前后缀表达式的长度
charch=expStr[i];
while（ch!
='\0'）
{
switch（ch）
{
case'+':
case'-':
while（opstack.top!
=-1）
{
expStr[t]=opstack.opdata[opstack.top];
opstack.top--;
t++;
}
opstack.top++;
opstack.opdata[opstack.top]=ch;
break;
case'*':
case'/':
while（opstack.top!
=-1&&（opstack.opdata[opstack.top]=='*'||opstack.opdata[opstack.top]=='/'））
{
expStr[t]=opstack.opdata[opstack.top];
opstack.top--;
t++;
}
升级会员 