华为最新笔试题编程题及答案.docx
《华为最新笔试题编程题及答案.docx》由会员分享，可在线阅读，更多相关《华为最新笔试题编程题及答案.docx（37页珍藏版）》请在冰点文库上搜索。
华为最新笔试题编程题及答案
问题：
输入一个字符串，用指针求出字符串的长度。
答案：
#include
intmain（）
{
charstr[20],*p;
intlength=0;
printf（“Pleaseinputastring:
”）;
gets（str）;
p=str;
while（*p++）
{
length++;
}
printf（“Thelengthofstringis%d\n”,length）;
return0;
}
问题：
使用C语言实现字符串中子字符串的替换
描述：
编写一个字符串替换函数，如函数名为StrReplace（char*strSrc,char*strFind,char*strReplace），strSrc为原字符串，strFind是待替换的字符串，strReplace为替换字符串。
举个直观的例子吧，如：
“ABCDEFGHIJKLMNOPQRSTUVWXYZ”这个字符串，把其中的“RST”替换为“ggg”这个字符串，结果就变成了：
ABCDEFGHIJKLMNOPQgggUVWXYZ
答案一：
#include
#include
voidStrReplace（char*strSrc,char*strFind,char*strReplace）;
#defineM100;
voidmain（）
{chars[]="ABCDEFGHIJKLMNOPQRSTUVWXYZ";
chars1[]="RST";
chars2[]="ggg";
StrReplace（s,s1,s2）;
printf（"%s\n",s）;
return0;
}
voidStrReplace（char*strSrc,char*strFind,char*strReplace）
{
inti=0;
intj;
intn=strlen（strSrc）;
intk=strlen（strFind）;
for（i=0;i{
if（*（strSrc+i）==*strFind）
{
for（j=0;j{
if（*（strSrc+i+j）==*（strFind+j））
{
*（strSrc+i+j）=*（strReplace+j）;
}
elsecontinue;
}
}
}
}
问题：
编写一个程序实现功能：
将字符串”ComputerSecience”赋给一个字符数组，然后从第一个字母开始间隔的输出该串，用指针完成。
答案：
#include
#include
intmain（）
{
charstr[]=”ComputerScience”;
intflag=1;
char*p=str;
while（*p）
{
if（flag）
{
printf（“%c”,*p）;
}
flag=（flag+1）%2;
p++;
}
printf（“\n”）;
return0;
}
问题：
编写一个程序实现功能：
将两个字符串合并为一个字符串并且输出，用指针实现。
charstr1[20]={“Hello”},str2[20]={“World”};
答案：
#include
intmain（）
{
charstr1[20]={“Hello”},str2[20]={“World”};
char*p=str1,*q=str2;
while（*p）p++;
while（*q）
{
*p=*q;
p++;
q++;
}
*p=‘\0’;
printf（“%s\n”,str1）;
return0;
}
问题：
以下函数的功能是用递归的方法计算x的n阶勒让德多项式的值。
已有调用语句p（n，x）；编写函数实现功能。
递归公式如下：
答案：
#include
floatp（intx,intn）
{
floatt,t1,t2;
if（n==0）return1;
elseif（n==1）returnx;
else
{
t1=（2*n-1）*x*p（x,（n-1））;
t2=（n-1）*p（x,（n-2））;
t=（t1-t2）/n;
returnt;
}
}
intmain（）
{
intx,n;
printf（“inputtwoint（xandn）:
”）;
scanf（“%d%d”,&x,&n）;
printf（“%.2f\n”,p（x,n））;
return0;
}
问题：
给主函数传递参数实现echo功能：
答案：
#incldue
intmain（intargc,char*argv[]）
{inti=1;
while（i{printf（“%s”，argv[i]）;
i++;
}
printf（“\n”）;
return0;
}
1.数组比较（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
函数返回：
3
2）输入：
int array1[] = {1,3,5}，int len1 = 3，int array2[] = {77,21,1,3,5,7}，int len2 = 6
函数返回：
0
答案：
#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）;
printf（"theresultis%d",result）;
}
约瑟夫环是一个数学的应用问题：
已知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））;/*Malloc（）向系统申请分配指定size个字节的内存空间。
返回类型是void*类型。
void*表示未确定类型的指针。
C,C++规定，void*类型可以强制转换为任何其它类型的指针。
*/
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;/*使p指向新的起点*/
free（s）;/*free（）与malloc（）函数配对使用，释放malloc函数申请的动态内存*/
}
printf（"%5d\n",p->num）;
}
intmain（）
{
LinkList*L;
intn,m;
n=9;
m=5;
L=creat（n）;
fun（L,m）;
return0;
}
手机号码合法性判断（20分）
问题描述：
我国大陆运营商的手机号码标准格式为：
国家码+手机号码，例如：
8613912345678。
特点如下：
1、长度13位；
2、以86的国家码打头；
3、手机号码的每一位都是数字。
请实现手机号码合法性判断的函数要求：
1）如果手机号码合法，返回0；
2）如果手机号码长度不合法，返回1
3）如果手机号码中包含非数字的字符，返回2；
4）如果手机号码不是以86打头的，返回3；
【注】除成功的情况外，以上其他合法性判断的优先级依次降低。
也就是说，如果判断出长度不合法，直接返回1即可，不需要再做其他合法性判断。
要求实现函数：
intsintverifyMsisdn（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;
}
}
elsereturn3;
}
elsereturn1;
return0;
}
intmain（）
{
char*pchar=NULL;
unsignedcharichar=3;
intresult;
switch（ichar）
{
case0:
pchar="8612345363789";break;
case1:
pchar="861111111111111";break;
case2:
pchar="86s1234536366";break;
case3:
pchar="1392222222222";break;
default:
break;
}
result=verifyMsisdn（pchar）;
printf（"resultis%d\n",result）;
return0;
}
约瑟夫问题问题描述：
输入一个由随机数组成的数列（数列中每个数均是大于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;
}LinkList;
LinkList*creat（intlen,intinput_array[]）
{
LinkList*h,*s,*p;
inti;
h=（LinkList*）malloc（sizeof（LinkList））;
h->num=input_array[0];
p=h;
for（i=1;i{
s=（LinkList*）malloc（sizeof（LinkList））;
s->num=input_array[i];
p->next=s;
p=s;
}
p->next=h;
return（h）;
}
voidarray_iterate（intlen,intinput_array[],intm）
{
LinkList*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]）;
}
printf（"\n"）;
}
intmain（）
{
intinput_array[]={3,1,2,4};
intlen=4;
intm=7;
array_iterate（len,input_array,m）;
return0;
}
问题：
比较一个数组的元素 是否为回文数组
答案：
#include
#include
voidhuiwen（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）;
}
main（）
{
charstr[100]={0};
inti;
intlen;
printf（"Inputastring：
"）;/*提示输入Inputastring：
*/
scanf（"%s",str）;/*scan（）函数输入一个字符串：
*/
huiwen（str）;
return0;
}
选秀节目打分，分为专家评委和大众评委，score[]数组里面存储每个评委打的分数，
judge_type[]里存储与score[]数组对应的评委类别，judge_type[i]==1，表示专家评委，
judge_type[i]==2，表示大众评委，n表示评委总数。
打分规则如下：
专家评委和大众评委
的分数先分别取一个平均分（平均分取整），然后，总分=专家评委平均分*0.6+大众
评委*0.4，总分取整。
如果没有大众评委，则总分=专家评委平均分，总分取整。
函数
最终返回选手得分。
函数接口intcal_score（intscore[],intjudge_type[],intn）
答案：
#include"iostream"
usingnamespacestd;
intcal_score（intscore[],intjudge_type[],intn）
{
if（NULL==score||NULL==judge_type||0==n）return0;
intsum=0;
intsum1=0,count1=0;
intsum2=0,count2=0;
for（inti=0;i{
if（judge_type[i]==1）
{
sum1=sum1+score[i];
count1++;
}
else
{
sum2=sum2+score[i];
count2++;
}
}
if（0==count2）sum=sum1/count1;
elsesum=（sum1/count1）*0.6+（sum2/count2）*0.4;
returnsum;
}
voidmain（）
{
intscore[3]={12,13,15};
intjudge_type[3]={1,1,2};
printf（"%d\n",cal_score（score,judge_type,3））;
}
问题：
给定一个数组input[]，如果数组长度n为奇数，则将数组中最大的元素放到output[]数组最中间的位置，如果数组长度n为偶数，则将数组中最大的元素放到output[]数组中间两个位置偏右的那个位置上，然后再按从大到小的顺序，依次在第一个位置的两边，按照一左一右的顺序，依次存放剩下的数。
例如：
input[]={3,6,1,9,7}output[]={3,7,9,6,
input[]={3,6,1,9,7,8}output[]={1,6,8,9,7,3}
函数接口voidsort（intinput[],intn,intoutput[]）
答案：
#include"iostream"
usingnamespacestd;
voidbubblesort（intdata[],intn）
{
inttemp=0;
for（inti=0;i{
for（intj=i+1;j{
if（data[i]{
temp=data[i];
data[i]=data[j];
data[j]=temp;
}
}
}
}
voidsort（intinput[],intn,intoutput[]）
{
int*sort_input=newint[n];
for（inti=0;i{
sort_input[i]=input[i];
}
bubblesort（sort_input,n）;
if（1==n%2）
{
intmid=n/2;
intk=0;
output[mid]=sort_input[k++];
for（intj=1;j<=n/2;j++）
{
output[mid-j]=sort_input[k++];
output[mid+j]=sort_input[k++];
}
}
升级会员 