华为笔试题.docx - 冰点文库

资源描述

华为笔试题.docx

《华为笔试题.docx》由会员分享，可在线阅读，更多相关《华为笔试题.docx（38页珍藏版）》请在冰点文库上搜索。

华为笔试题.docx

华为笔试题

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

　　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,0×00,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

　　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;

　　}

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

　　输入字符串的格式为：

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

　　补充说明：

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

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

　　要求实现函数：

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

　　【输入】pInputStr：

输入字符串

　　lInputLen：

输入字符串长度

　　【输出】pOutputStr：

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

　　#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

　　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

　　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

　　#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

　　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,0×00,n+1）;

　　while（*p）

　　{

　　memcpy（temp,p,n）;

　　if（strcmp（temp,q）==0）

　　{

　　count++;

　　memset（temp,0×00,n+1）;

　　p=p+n;

　　}

　　else

　　{

　　*t=*p;

　　p++;

　　t++;

　　memset（temp,0×00,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

　　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=curSum/10;

　　}

　　if（j<0）

　　{

　　while（i>=0）//遍历str1剩余各位

　　{

　　n1=str1[i--]–’0′;

　　curSum=n1+another;

　　result[cur_rs++]=curSum%10+’0′;

　　another=curSum/10;

　　}

　　if（another!

=0）//如果还有进位未加上

　　result[cur_rs++]=another+’0′;

　　}

　　else

　　{

　　while（j>=0）

　　{

　　n2=str2[j--]–’0′;

　　curSum=n2+another;

　　result[cur_rs++]=curSum%10+’0′;

　　another=curSum/10;

　　}

　　if（another!

=0）

　　result[cur_rs++]=another+’0′;

　　}

　　result[cur_rs]=‘\0′;

　　cur_rs=remove_zero（result,cur_rs）;

　　if（!

flag）

　　{

　　result[cur_rs++]=‘-’;

　　result[cur_rs]=‘\0′;

　　}

　　reverse（result,strlen（result））

展开阅读全文