华为机试整理及本人华为面试经历.docx

华为机试整理及本人华为面试经历.docx

《华为机试整理及本人华为面试经历.docx》由会员分享，可在线阅读，更多相关《华为机试整理及本人华为面试经历.docx（71页珍藏版）》请在冰点文库上搜索。

华为机试整理及本人华为面试经历

整理了网上２０１４华为机试题，近几十个网页的资料，同时本人对每道题均进行了验证。

并且对一些题目进行了更好的修正。

希望对后来者有所帮助。

1．第一题的题目大概是输入整型数组求数组的最小数和最大数之和，例如输入1,2,3,4则输出为5，当输入只有一个数的时候，则最小数和最大数都是该数，例如只输入1，则输出为2；另外数组的长度不超过50

#include

main（）

{

intnum[50]={0};

inti,n;

printf（"请输入整型数组的长度（1~50）：

"）;

scanf（"%d",&n）;

printf（"请输入整型数组的元素：

"）;

for（i=0;i

{

scanf（"%d",&num[i]）;

}

intmin_num=num[0];

intmax_num=num[0];

for（intj=0;j

{

if（max_num

max_num=num[j];

elseif（min_num>num[j]）

min_num=num[j];

}

intsum=min_num+max_num;

printf（"数组中最大与最小值之和：

%d\n",sum）;

return0;

}

2．求两个长长整型的数据的和并输出，例如输入1233333333333333。

。

。

3111111111111111111111111.。

。

。

，则输出。

。

。

。

#include

#include

#include

main（）

{

char*num1,*num2;//两个长长整型数据

char*sum;

//inttemp;

intlen_num1,len_num2;//两个长长整型数据的长度

intlen_max,len_min;

num1=（char*）malloc（sizeof（char））;

num2=（char*）malloc（sizeof（char））;

printf（"输入两个长长整型数据：

"）;

scanf（"%s",num1）;

printf（"输入两个长长整型数据：

"）;

scanf（"%s",num2）;

len_num1=strlen（num1）;

len_num2=strlen（num2）;

len_max=（len_num1>=len_num2）?

len_num1:

len_num2;

len_min=（len_num1<=len_num2）?

len_num1:

len_num2;

intlen_max1=len_max;

sum=（char*）malloc（sizeof（char）*len_max）;

memset（sum,0x00,len_max+1）;//切忌初始化

for（;len_num1>0&&len_num2>0;len_num1--,len_num2--）

{

sum[len_max--]=（（num1[len_num1-1]-'0'）+（num2[len_num2-1]-'0'））;

}

if（len_num1>0）

{

sum[len_max--]=num1[len_num1-1]-'0';

len_num1--;

}

if（len_num2>0）

{

sum[len_max--]=num1[len_num2-1]-'0';

len_num2--;

}

for（intj=len_max1;j>=0;j--）//实现进位操作

{

//temp=sum[j]-'0';

if（sum[j]>=10）

{

sum[j-1]+=sum[j]/10;

sum[j]%=10;

}

}

char*outsum=（char*）malloc（sizeof（char）*len_max1）;

j=0;

while（sum[j]==0）//跳出头部0元素

j++;

for（intm=0;m

outsum[m]=sum[j]+'0';

outsum[m]='\0';

printf（"输出两长长整型数据之和:

%s\n",outsum）;

return0;

}

3.通过键盘输入一串小写字母（a~z）组成的字符串。

请编写一个字符串过滤程序，若字符串中出现多个相同的字符，将非首次出现的字符过滤掉。

比如字符串“abacacde”过滤结果为“abcde”。

要求实现函数：

voidstringFilter（constchar*pInputStr,longlInputLen,char*pOutputStr）;

【输入】pInputStr：

输入字符串

lInputLen：

输入字符串长度

【输出】pOutputStr：

输出字符串，空间已经开辟好，与输入字符串等长；

#include

#include

#include

voidstringFilter（constchar*p_str,longlen,char*p_outstr）

{

intarray[256]={0};

constchar*tmp=p_str;

for（intj=0;j

{

if（array[tmp[j]]==0）

*p_outstr++=tmp[j];

array[tmp[j]]++;

}

*p_outstr='\0';

}

voidmain（）

{

char*str="cccddecc";

intlen=strlen（str）;

char*outstr=（char*）malloc（len*sizeof（char））;

stringFilter（str,len,outstr）;

printf（"%s\n",outstr）;

free（outstr）;

outstr=NULL;

}

4.通过键盘输入一串小写字母（a~z）组成的字符串。

请编写一个字符串压缩程序，将字符串中连续出席的重复字母进行压缩，并输出压缩后的字符串。

压缩规则：

1.仅压缩连续重复出现的字符。

比如字符串"abcbc"由于无连续重复字符，压缩后的字符串还是"abcbc".

2.压缩字段的格式为"字符重复的次数+字符"。

例如：

字符串"xxxyyyyyyz"压缩后就成为"3x6yz"

要求实现函数：

voidstringZip（constchar*pInputStr,longlInputLen,char*pOutputStr）;

【输入】pInputStr：

输入字符串

lInputLen：

输入字符串长度

【输出】pOutputStr：

输出字符串，空间已经开辟好，与输入字符串等长；

#include

#include

#include

voidstringZip（constchar*p_str,longlen,char*p_outstr）

{

intcount=1;

for（inti=0;i

{

if（p_str[i]==p_str[i+1]）

{

count++;

}

else

{

if（count>1）

{

*p_outstr++=count+'0';

*p_outstr++=p_str[i];

}

else

{

*p_outstr++=p_str[i];

}

count=1;//注意其位置

}

}

*p_outstr='\0';

}

voidmain（）

{

char*str="cccddecc";

printf（"压缩之前的字符串为：

%s\n",str）;

intlen=strlen（str）;

char*outstr=（char*）malloc（len*sizeof（char））;

stringZip（str,len,outstr）;

printf（"压缩之后的字符串为：

%s\n",outstr）;

free（outstr）;

outstr=NULL;

}

5.通过键盘输入100以内正整数的加、减运算式，请编写一个程序输出运算结果字符串。

输入字符串的格式为：

“操作数1运算符操作数2”，“操作数”与“运算符”之间以一个空格隔开。

补充说明：

1.操作数为正整数，不需要考虑计算结果溢出的情况。

2.若输入算式格式错误，输出结果为“0”。

要求实现函数：

voidarithmetic（constchar*pInputStr,longlInputLen,char*pOutputStr）;

【输入】pInputStr：

输入字符串

lInputLen：

输入字符串长度

【输出】pOutputStr：

输出字符串，空间已经开辟好，与输入字符串等长；

#include

#include

#include

voidarithmetic（constchar*input,longlen,char*output）

{

chars1[10];

chars2[10];

chars3[10];

intcnt=0;

intlen_input=strlen（input）;

for（inti=0;i

{

if（input[i]==''）

cnt++;

}

if（cnt!

=2）

{

*output++='0';

*output='\0';

return;

}

sscanf（input,"%s%s%s",s1,s2,s3）;

if（strlen（s2）!

=1||（s2[0]!

='+'&&s2[0]!

='-'））

{

*output++='0';

*output='\0';

return;

}

intlen_s1=strlen（s1）;

for（i=0;i

{

if（s1[i]<'0'||s1[i]>'9'）

{

*output++='0';

*output='\0';

return;

}

}

intlen_s3=strlen（s3）;

for（i=0;i

{

if（s3[i]<'0'||s3[i]>'9'）

{

*output++='0';

*output='\0';

return;

}

}

intx=atoi（s1）;

inty=atoi（s3）;

if（s2[0]=='+'）

{

intresult=x+y;

itoa（result,output,10）;

}

elseif（s2[0]=='-'）

{

intresult=x-y;

itoa（result,output,10）;

}

else

{

*output++='0';

*output='\0';

return;

}

}

voidmain（）

{

charstr[]={"10-23"};

charoutstr[10];

intlen=strlen（str）;

arithmetic（str,len,outstr）;

printf（"%s\n",str）;

printf（"%s\n",outstr）;

}

6.一组人（n个），围成一圈，从某人开始数到第三个的人出列，再接着从下一个人开始数，最终输出最终出列的人

（约瑟夫环是一个数学的应用问题：

已知n个人（以编号1，2，3...n分别表示）围坐在一张圆桌周围。

从编号为k的人开始报数，数到m的那个人出列；他的下一个人又从1开始报数，数到m的那个人又出列；依此规律重复下去，直到圆桌周围的人全部出列。

）

#include

#include

#include

#include

typedefstructNode

{

intdata;

structNode*next;

}LinkList;

LinkList*create（intn）

{

LinkList*p,*q,*head;

inti=1;

p=（LinkList*）malloc（sizeof（LinkList））;

p->data=i;

head=p;

for（i=1;i<=n;i++）

{

q=（LinkList*）malloc（sizeof（LinkList））;

q->data=i+1;

p->next=q;

p=q;

}

p->next=head;//使链表尾连接链表头，形成循环链表

returnhead;

free（p）;

p=NULL;

free（q）;

q=NULL;

}

voiddeletefun（LinkList*L,intm）

{

LinkList*p,*q,*temp;

inti;

p=L;

while（p->next!

=p）

{

for（i=1;i

{

q=p;

p=p->next;

}

printf（"%5d",p->data）;

temp=p;

q->next=p->next;

p=p->next;

free（temp）;

}

printf（"%5d\n",p->data）;

}

intmain（）

{

intn=7,m=3;

LinkList*head1;

head1=create（n）;

deletefun（head1,m）;

return0;

}

7..输入一串字符，只包含“0-10”和“，”找出其中最小的数字和最大的数字（可能不止一个），输出最后剩余数字个数。

如输入“3,3,4,5,6,7,7”

#include

#include

#include

voidmain（）

{

charstr[100];

printf（"输入一组字符串：

\n"）;

scanf（"%s",&str）;

intlen=strlen（str）;

intarray[100];

intcount=0;

for（inti=0;i

{

if（str[i]>='0'&&str[i]<='9'）

array[count++]=str[i]-'0';

}

array[count]='\0';

intresult=count;

intmin=array[0];

intmax=array[0];

for（intj=0;j

{

if（max

max=array[j];

elseif（min>array[j]）

min=array[j];

}

for（intk=0;k

{

if（array[k]==min）

result--;

if（array[k]==max）

result--;

}

printf（"%d\n",result）;

}

8.输入一组身高在170到190之间（5个身高），比较身高差，选出身高差最小的两个身高；若身高差相同，选平均身高高的那两个身高；从小到大输出；

如输入170181173186190输出170173

#include

#include

#defineN5

intmain（）

{

intHeight[N];

intdmin;

intH1,H2;

inti,j,temp;

printf（"请输入一组身高在170到190之间的数据（共5个）:

\n"）;

for（intk=0;k

scanf（"%d",&Height[k]）;

printf（"\n"）;

for（i=0;i

for（j=1;jHeight[j];j++）

{

temp=Height[j-1];

Height[j-1]=Height[j];

Height[j]=temp;

}

H1=Height[0];

H2=Height[1];

dmin=H2-H1;

for（intm=2;m

{

if（Height[m]-Height[m-1]<=dmin）

{

H1=Height[m-1];

H2=Height[m];

dmin=Height[m]-Height[m-1];

}

}

printf（"身高差最小的两个身高为:

\n"）;

printf（"%d,%d\n",H1,H2）;

return0;

}

9.删除子串，只要是原串中有相同的子串就删掉，不管有多少个，返回子串个数。

#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）;

temp=（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;

}

voidmain（）

{

chars[100]={‘\0’};

intnum=delete_sub_str（“123abc12de234fg1hi34j123k”,”123”,s）;

printf（“Thenumberofsub_stris%d\r\n”,num）;

printf（“Theresultstringis%s\r\n”,s）;

}

10.要求编程实现上述高精度的十进制加法。

要求实现函数：

voidadd（constchar*num1,constchar*num2,char*result）

【输入】num1：

字符串形式操作数1，如果操作数为负，则num1[0]为符号位'-'

num2：

字符串形式操作数2，如果操作数为负，则num2[0]为符号位'-'

【输出】result：

保存加法计算结果字符串，如果结果为负，则result[0]为符号位。

#include

#include

#include

voidmove（char*str,intlength）//移除字母前的"-"符号

{

if（str[0]!

='-'）

return;

inti;

for（i=0;i

str[i]=str[i+1];

str[i]='\0';

}

intremove_zero（char*result,intlength）

{

intcount=0;

for（inti=length-1;i>0;i--）//从最后开始移除0，直到遇到非0数字，只对最初位置上的0不予判断

{

if（result[i]=='0'）

{

result[i]='\0';

count++;

}else

returnlength-count;

}

returnlength-count;

}

voidreverse（char*result,intlength）//将字符串倒转

{

chartemp;

for（inti=0;i<=（length-1）/2;i++）

{

temp=result[i];

result[i]=result[length-1-i];

result[length-1-i]=temp;

}

}

intreal_add（char*str1,char*str2,char*result,constboolflag）

{

intlen1=strlen（str1）;

intlen2=strlen（str2）;

intn1,n2,another=0;//another表示进位

intcur_rs=0;//表示result的当前位数

inti,j;

intcurSum;

for（i=len1-1,j=len2-1;i>=0&&j>=0;i--,j--）

{

n1=str1[i]-'0';

n2=str2[j]-'0';

curSum=n1+n2+another;

result[cur_rs++]=curSum%10+'0';

another=cu