华为校园招聘机考试题大全

2012华为校园招聘机考试题总结(厦门大学)

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

ttinclude<stdio.h>

Hinclude<stdlib.h>

与include<asscrt.h>

^include<string.h>

intdclctc_sub_str(constchar*str,constchar*sub_str,char*rcsult)

(

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)

(

memepy(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(M123abcl2de234fglhi34jl23kw,n123M,s);

printf("Thenumberofsub_stris%d\r\nM,num);

printf(MTheresultstringis%s\r\nM,s);

}

2、约瑟夫环是一个数学的应用问题：已知n个人(以编号1,2,3...n分别表示)围坐在一张圆桌周国。从编号为k的人开始报数，数

到m的那个人出列：他的下一个人又从1开始报数，数到m的那个人又出列；依比规律重复下去，直到圆桌周困的人全部出列。

#include<stdio.h>

#include<stdlib.h>

typedefstructNode

(

intnum;

structNode*next;

}LinkList;

LinkList*creat(intn)

(

LinkList*p,*q,*head;

inti=l;

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;/*使链表尾指向链表头形成循环链及*/

retuinhead;

)

voidfun(LinkList*L,intm)

(

inti;

LinkList*p,*s,*q：

P=L：

printf("出列顺序为:");

while(p->next!=p)

(

for(i=l;i<m;i++)

{q=p;

p=p->next：

)

printf(*%5(r,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<stdio.h>

#include<string.h>

inthuiwen(charstr[])

(

inti,len,k=l;

len=strlen(str);

for(i=0;i<len/2:i++)

(

if(str[i]!=str[len-i-l])

(

k=l;

break;

)

)

if(k==0)

printf(*%s不是一个回文数\n",str);

else

printf(*%s是一个回文数\rT,strj;

)

voidmain()

(

charsir口00]={0};

inti;

intlen：

printf(*Inputasiring：*);/*提示输入Inpulastring：*/

scan：(飞s”,str);/*scan()函数输入一个字符串：*/

huiwen(str);

}

4、数组比较(20分)

•问题描述：

比较两个数组，要求从数组最后一个元素开始逐个元素向前比较，如果2个数组大度不等，则只比较较短长度数组个数元素。请编程实现

上述比较，并返回比较中发现的不相等元素的个数

比如：

数组{1,3,5}和数组{77,21,1,3,5}按题述要求比较，不相等元素个数为0

数组”，3,5)和数组(77,21,1,3,5,7)按题述要求比较,不相等元素个数为3

•要求实现函数：

intarray_compare(intlenl,intarrtyl[],intlen2,intarray21])

【输入】intlenl：输入被比较数组1的元素个数；

intarray1[]：输入被比较数组1：

intlen2：输入被比较数组2的元素个数：

intarray2[]：输入被比较数组2：

【输出】无

【返回】不相等元素的个数，类型为int

•示例

1)输入：intarray1[]={1,3,5},intlenl=3,intarray2[]={77,21,1,3,5),intlen2=5

函数返回：0

2)输入：intarray1[]={1,3,5),intlenl=3,intarray2[]={77,21,1,3,5,7),intlen2=6

函数返回：3

#include<stdlib.h>

#include<stdio.h>

itinclude<slring.h>

intarraycompare(intlenl,intarray1[],intlen2,intarray2[])

(

intcount=0;

for(;lenl>=0&&len2>=0;lenl-,len2一)

(

if(arrayl[lenl-1]==array2[len2-l])

(

count++;

)

)

returncount;

}

intmain()

(

intresult=0:

intarrayl=3,5};

intlenl=3：

intarray2[]={77,12,1,3,5};

intlen2=5;

result=array_compare(lenl,array】，len2,array2);///result=array_compare(lenl,arrayl[],len2,array2口)；不能

这样

//函数形参中永远只是传得首地址，不能传数组

切记切记！！！！！！

prinif(*theresultis%d*,result);

)

5、约瑟夫问题

•问题描述：

输入一个臼随机数组成的数列(数列中每个数均是大TO的整数，长度己知)，和初始计数值%从数列首位宜开始计数，计数到m后，

将数列该位置数值替换计数值tn,并将数列该位置.数值出列，然后从下一位置.从新开始计数，直到数列所有数值出列为止。如果计数到达

数列尾段,则i反回数列首位罟维续计数.诘编程实现上述计数过程,同时输出数宿出列的顺序

比如：输入的随机数列为：3,1,2,4,初始计数值m=7,从数列首位置.开始计数(数值3所在位置.)

笫一轮计数出列数字为2,计数值更新m=2,出列后数列为3,1,4,从数值4所在位置从新开始计数

笫二轮计数出列数字为3,计数值更新m=3,出列后数列为1,4,从数值1所在位置开始计数

第三轮计数出列数字为1,计数位更新m=l,出列后数列为4,从数值4所在位置开始计数

最后一轮计数出列数字为4,计数过程完成9

输出数值出列顺序为：2,3,1,4。

•要求实现函数：

voidarray_ilerate(inllen,intinput_array[],intm,intoulput_array[])

【输入】intlen：输入数列的长度：

intinlpul_array[]：输入的初始数列

intm：初始计数值

【输出】intoutput_array[]：输出的数值出列顺序

【返回】无

,示例

输入：intinput_array[]={3,1,2,4},intlen=4,m=7

输出：output_array[]={2,3,1,4)

〃〃〃〃〃/7循环链表实现〃〃〃〃〃〃〃/〃〃〃/

#include<stdio.h>

4include<stdlib.h>

#include<string.h>

typedefstructNode

(

intnum;

structnode*next;

}node;

node*creat(intlen,intinputarray[])

(

node*h,*s,*p;

inti;

h=(node*)malloc(sizeof(node));

h->num=inputarray[0];

P=h;

for(i=l;i<len;i++)

(

s=(nodc*)malloc(sizeof(node));

s->num=input_array[iJ;

p->next=s;

P=s;

}

p->ncxt=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=l;i<m;i++)

{

q=P；

p=p->next;

)

m=p->num;

printf(*%5d*,m);

outputarray[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++)

(

prinlf(飞5d”,output_array[j]);

)

}

intmain()

(

intinput_array[]={3,1,2,4};

intlcn=4;

intn=7;

intoutput_arrayL4];

arra/_iterate(len,input_array,m,output_array);

6、手机号码合法性判断(20分)

•问题描述：

我国大陆运昔商的手机号码标准格式为：国家码।手机号码，例如：86。特点如下：

1、长度13位：

2、以86的国家码打头：

3、手机号码的每一位都是数字。

请实现手机号码合法性判断的函数要求：

1)如果手机号码合法，返回0：

2)如果手机号码长度不合法，返回1

3)如果手机号码中包含非数字的字符，返回2：

4)如果手机号码不必以86打头的，返回3：

【注】除成功的情况外，以上其他合法性判断的优先级依次降低。也就是说，如果判断出长度不合法，直接返回1即可，不需要再做其他

合法性判断。

•要求实现函数：

intverifyMsisdn(char*inMsisdn)

【输入】char*inMsisdn,表示输入的手机号码字符串。

【输出】无

【返回】判断的结果，类型为ini。

•示例

输入：inMsisdn="869123456789“

输出：无

返何：1

输入：inMsisdn="889”

输出：无

返回：3

输入：inMsisdn="869”

输出：无

返回：0

#include<stdio.h>

#include<stdlib.h>

#include<assert.h>

itinclude<string.h>

itdefineLENGTH13

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=*8611111111111ir：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

•要求实现函数：

intarraycompare(intlenl,intarreyl[],intlen2,intarray2J)

【输入】intlenl：输入被比较数组1的元素个数；

intarray1[]：输入被比较数组1：

intlen2：输入被比较数组2的元素个数：

intarray2[]：输入被比较数组2：

【输出】无

【返回】不相等元素的个数，类型为int

•示例

1)输入：intarray1[]={1,3,5},intlenl=3,intarray2[]={77,21,1,3,5},intlcn2=5

函数返回：0

2)输入：intarray1[]={1,3,5},intlenl=3,intarray2[]={77,21,1,3,5,7},intlcn2=6

函数返回：3

#include<stdlib.h>

#include<stdio.h>

ttinclude<string.h>

intarray_compare(intlenl,intarray1[],intlen2,intarray2[])

(

intcount=0;

for(;lenl>=0&&len2>=0;lenl-,len2一)

(

if(array![lenl-1]==array2[1en2-l])

(

count++;

)

}

returncount：

)

intmain()

(

intresult=0:

intarray][]={1,3,5};

intlenl=3;

intarray2[]={77,12,1,3,5};

intIen2=5;

result=array_compare(lenl>array1,len2,array2);

///result=array_compare(lenl,array1[],len2,array2口)；不能这样

//函数形参中7k远只是传得首地址，不能传数组切记切记！！！！！！

printf(*theresultisresult);

}

8、简单四则运算

•问题描述：输入一个只包含个位数字的简单四则运算表达式字符串，计算该表达式的值

注：1、表达式只含+,*,/四则运算符，不含括号

2、表达式数值只包含个位整数(0-9),且不会出现0作为除数的情况

3、要考虑加减乘除按通常四则运算规定的计算优先级

4、除法用整数除法，即仅保留除法运算结果的整数部分。比如8/3=2。输入表达式保证无0作为除数情况发生

5、输入字符串一定是符合题意合法的表达式，其中只包拈•数字字符和四则运算符字符，除此之外不含其它任何字符，不会出现计算溢出

情况

•要求实现函数：

intcalculate(intlen,char*expStr)

【输入】intlen:字符串长度：

char*expStr:表达式字符串：

【输出】无

【返回】计算结果

,示例

1)输入：char*expStr="1+4*5-8/3"

函数返回：19

2)输入：char*expStr="8/3*3”

函数返回：6

^include<stdio.h>

/*

*authorbywanww

*time:2011-09-07

*/

usingnamespacestd;

intarraycompare(intlenl,intarray1[],intlen2,intarray2[])

(

if(lenl==len2)(

intcount=0;

for(inti=0;i<lenl;i++)

(

if(array1[i]!=array2[i])count++;

)

returncount;

}elseif(lenl<len2){

returnarray_comparc(lenl,arrayl,lenl,array2+lcn2-lcnl);

}else{

returnarray_compare(1en2,array1+1en1-1en2,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下标的元素出列

(

outputarray[hasout]=inputarray[start];

flag[start]=1:〃标记当前亓素已经用列

hasout++;

if(hasout==len)break;〃所有的元素都已经出列，结束程序

〃初始化下一轮的数字

j=0;

m=input_array[start];

}

)

start++;

if(start==len)start=0：

)

delete[]flag;

}

intcalculatc(intlen,char*cxpStr)

(

struct{

charopdata[200];

inttop;

Jopsiack;

〃定义操作符栈

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]=='Iopstack.opdala[opstack,top]=='/'))

(

expStr[t]=opstack.opdata[opstack,top];

opstack,top一：

t++;

}

opstack.top++;

opstack,opdata[opstack,topj=ch;

break;

default:

expStr[t]=ch;

t++;

break;

)

i++；

ch=expStr[i];

)

while(opstack.top!=T)〃将栈中所有的剩余的运算符出栈

(

expStr[t]=opstack,opdata[opstack,top];

opstack,top一;

t++;

)

expS:r[t]=\0*;

struct{

intnumeric[200];

inttop:

Jdata;

data,top=-1：

i=0;

ch=expStr[i];

while(ch!=，\0")

(

if(ch>=0'&&ch<='9')

(

data.top++;

data.numeric[data.top]=ch-'O';

)

elseif('+'=ch)

inttmp=data,numeric[data,top-1]+data,numeric[data,top];

data,top一;

data,numeric[data,top]=tmp;

)

elseif('-'=ch)

|

inttmp=data,numeric[data,top1]data,numeric[data.top];

data,top—;

data,numeric[data,top]=tmp：

)

elseif(**'=ch)

(

inttmp=data,numeric[data,top-1]*data,numeric[data.:op];

data,top一;

data,numeric[data,top]=tmp;

)

elseif('/'=ch)

(

if(data,numeric[data,top]=0)

(

printf(^cannotbezeroofthedivide"」)；

exit(l);

}

inttmp=data,numeric[data,top-1]/data,numeric[data.top]：

data,top—;

data,numeric[data,top]=tmp;

)

i++;

ch=expStrEi];

}

returndata,numeric[data,top];

}

voidmain()

(

intarray1[]={1,3,5);

intlenl=3;

intarray2[]={77,21,1,3,5,7};

intlen2=6;

intcount=array_compare(sizeof(arrayl)/sizeof(int),array1,sizeof(array2)/sizeof(int),array2);

printf("与d\n",count);

printf("**********************农******************************;

intinput_array[]={3,1,2,4};

intien=4;

intn=7;

int*output_array=newint[sizeof(input_array)/sizeof(int)];

arrayiterate(4,input.array,7,outputarray);

for(inti=0:i<sizeof(inputarray)/sizeof(int);i++)

(

printf(*%<1*,output_array[i]);

)

delete口output_array：

prin:f("\n*****************************************************\n");

charexpStr[]="8/3*3”;

intresult=calculate(strlen(expStr),expStr):

printf(飞s\n”,expStr);

printfresult);

)

9、选秀节目打分，分为专家评委和大众评委，score口数组里面存储每个评委打的分数，judge_type[]里存储与score[]数组对应的

评委类别，judge_lype[i]==1,表示专家评委，judge_lype[i]=2,表示大众评委，n表示评委总数。打分规则如下：专家评委和大

众评委的分数先分别取一个平均分(平均分取整)，然点，总分=专家评委平均分*0.6+大众评委*0.4,总分取整。如果没有

大众评委，则总分=专家评委平均分，总分取整。函数最终返回选手得分。

函数接Uintcal_score(inlscore[],intjudge_type[],intn)

#include<stdio.h>

Hinclude<slring.h>

inc1udc<iostrcam.h>

ttinc1ude<conio.h>

^defineN5

intcal_score(intscore[],intjudge_type[],intn)

intexpert=0;

intdazhong=0;

intzongfen=0;

inti;

intnumber=O;

for(i=0;i<N;i++)

{

if(judge_type[i]==l)

(

expert=expert+score[i];

number++;

}

elsedazhong=dazhong+score[i]：

)

if(number==N)

(

zongfen=(int)(expert/N);

)

else

(

expert=(int)(expert/number)：

dazhong=(int)(dazhong/(N-numbe?-));

zongfen=int(0.6*cxpert+0.4*dazhong);

)

returnzongfen;

}

intmain()

(

intscore[N];

intjudgc_typc[N];

intnumberlast=0;

inti;

priruf("pleaseinputthe%dscore:\nM,N);

for(i=0;i<N;i++)

scanf&score[i]);

prin:f(，zpleaseinputthelevel(1:expert,2:dazhong)\nw);

for(i=0;i<N;i++)

scanf&judge_type[i]);

numberlast=cal_score(score,judge_type,N);

prinrf(*thelastscoreis%d\n/，,numberlast);

return0;

}

10、给定一个数组input口,如果数组长度n为奇数，则将数组中最大的元素放到output口数组最中间的位置，如果数组长度n为偶数,

则将数组中最大的元素放到output[]数组中间两个位置偏右的那个位置上，然后再按从大到小的顺序，依次在第一个位置的两边，按照

一左一右的顺序，依次存放剩下的数。

例如：input口=⑶6,1,9,7}output[]={3,7,9,6,1}：input[]=(3,6,1,9,

7,8}output[]=(1,6,8,9,7,3}

#include<stdio.h>

#include<string.h>

#include<conio.h>

voidsort(intinput[],intn,intoutput口)

inti,j;

intk=l;

inttemp;

intmed;

for(i=0;i<n;i++)

for(j=0;j<n-i;j++)

if(input[j]>input[j+l])

{temp=input[j];input[j]=input[j+l];input[j+l]=temp;}

if(n%2!=0)

(

for(i=0;i<n：i++)

printf("%2d”,input[i]);

printf("\n");

med=(n-l)/2;

output[med]=input[n-l];

for(i=l:i<=med;i++)

output[med-i]=input[n-l-k];

output[med+i]=input[n-2-k];

k=k'2;

else

(

for(i=0;i<n;i++)

printf(*%2d*,input[i])：

printf(*\n*);

med=n/2:

output[med]=input[n-l]：

for(i=l;i<=med-l;i++)

(

output[med-i]=input[n-l-k';

output[med+i]=input[n-2-k^;

k=k+2;

}

output[Oj=input[0];

}

for(i=0;i<n;i++)

prinlf("先2d”,output[i]);

printf(*\n*);

}

intmain()

(

inta[6]={3,6,1,9,7,8);

intb[6]={0};

for(inti=0;i<6;i++)

printfa[i]);

printf：

sort(a,6,b);

return0;

)

11、操作系统任务调度问题。操作系统任务分为系统任务和用户任务两种。其中，系统任务的优先级<50,用户任务的优先级>=50且<=

255。优先级大于255的为非法任务，应予以剔除。现有•任务队列task[],长度为n,task中的元素值表示任务的优先级，数值越小，

优先级越高。函数scheduler实现如下功能，将task口中的任务按照系统任务、用户任务依次存放到system_task[]数组和user_task[]

数组中(数组中元素的值是任务在task口数组中的下标)，并且优先级高的任务排在前面，数组元素为T表示结束。

例如：task[]={0,30,155,1,80,300,170,40,99}system_task[]={0,3,1,7,-1)user_task[]

={4,8,2,6,-1}

函数接口voidscheduler(inttask[],intn,intsystem_task[],in:user_task[])

#include<stdio.h>

#include<string.h>

#include<malloc.h>

#include<iostream.h>

voidscheduleri(inttask[],intn,intsystemtask[],intuser_task[])

(

inti;

intj=0;

int*D.*DP.*Duser.*pp_user:

intindex=0;

intcount,count2;

intnin=0;

intk=0;

p=(int*)malloc(sizeof(int)*n);

for(i=0;i<n;i++)

p[i]=0;

pp=(inl*)malloc(sizeof(int)*n);

for(i=0;i<n;i++)

Pp[i]=0;

p_uscr=(int*)ma11oc(sizcof(int)*n);

for(i=0;i<n;i++)

p_uscr[i]=0;

pp_user=(int*)malloc(sizeof(int)*n);

for(i=0;i<n;i++)

pp_user[i]=0;

for(i=0：i<n;i++)

{

if(task[i]<50)

(

(

system_task[j]=task[i]：

pp[j]=i：

」++；

)

count=j;

)

elseif(task[i]<=255)

usertask[k]=task[i]：

ppuser[k]=i;

k++;

)

count2=k：

)

elsetask[i]=task[i];

)

for(i=0;i<count;i++)

prinlf("%3d”,system_task[i]);

printfCXn*);

for(i=0：i<count;i++)

(

min=systcm_task[O]：

for(j=l;j<count：j++)

|

if(systcm_task[j]<min)

(

min=systeni_task[j];

}

)

system_task[p[i]]=51;

)

pp[count]=-l：

for(i=0;i<count;i++)

printfpp[p[i]]);

prin:f(*%3d\n*,pptcount]);

/***********************************************************/

for(i=0;i<count2;i++)

printf("%4d”,usertask[i]);

printf(*\n*);

for(i=0;i<count2;i++)

(

min=usertaskfO];

for(j=l;j<count2;j++)

{

if(user_task[j]<min)

(

inin=user_task[j];

p_user[i]=j;

}

)

user_task[p_user[i]]=256;

)

pp_user[count2]=-l;

for(i=0;i<counl2;i++)

printfpp_uscr[p_uscr[i]]);

printf(飞3d\n”,ppuscr[count2]);

}

intmain()

inttask[9]={0,30,155,1,80,300,170,40,99};

intsystem_task[9]={0}：

intuser_task[9]={0};

scheduler!(task,9,system_task,user_task);

return0;

)

12、从两个数组的最后一个元素比较两个数组中不同元素的个数，如有arrayl[5]={77,21,1,3,5},array2[3]={1,3,5},从arrayl[个

与array2[2]比较开始,到arrayl[2]与array[0]比较结束。这样得出它们不同的元素个数为0,若arrayl[6]={77,21,1,3,5,7},那么他

们不同的元素为3。

函数原型为intcompare_array(intlenl,intarrayl[],intlen2,in:array2[]);

其中，lenl与len2分别％数组arrayl口和aray2□的长度，函数返回值为两个数组不同元素的个数。

以下是上题的函数完整实现：

//diff_num.cpp

#include<stdio.h>

intcomparearray(intlenl,intarrayl[],intlen2,intarray2[])

(

inti,t,sma11,num=0;

//把两数组倒置

for(i=0;i<lenl/2;i++)

(

t=arrayl[i];

arrayHi]=array1Llenl-i-1J;

arrayl[lenl-i-l]=t;

)

for(i=0;i<len2/2;i++)

{

t=array2[i];

array2[i]=array2[1en2-i-1];

array2[len2-i-l]=t:

)

//输出倒置后的两数组

/*for(i=0;i<lenl;i++)

printf*,arrayl[i]);

printf;

for(i=0;i<len2;i++)

printf(*%d*,array2[i]);

*/printf(*\n*)：

if(lenl>len2)

small=len2;

else

small=lenl;

num=small：

for(i=0;i<small;i++)

(

if(array1[i]=array2[i])

num——：

}

prinif("num=%d\n”,num)：

returnnum;

)

voidmain()

(

intarray1[5]=(77,21,1,3,5},array2[3]=(1,3,5);

intlenl=5,len2=3;

compare_array(lenl,array1,len2,array2);

)

13、输入一个字符串，用指针求出字符串的长度。

答案：

#include<sldio.h>

intnain()

(

charslr[20],*p;

intlcngth=O;

printf(44Plcaseinputastring:");

gets(str);

p=str;

while(*p++)

length++;

)

printf(°Thelengthofstringis%d\n",length);

return0:

}

14、使用C语言实现字符串中子字符串的替换

描述:编写一个字符串替换函数,如函数名为StrReplace(char*strSrc,char*strFind,char*strReplace),strSrc为原字符串»strFind

是待替换的字符串，strReplace为皆换字符串。

举个直观的例子吧，如："ABCDEFGHIJKLVNOPQRSTUVWXYZ”这个字符串，把其中的“RST”替换为“ggg”这个字符串，结果就变成了：

ABCDEFGHIJKLMNOPQgggUVWXYZ

答案一：

#include<stdio.h>

^include<string.h>

voidStrReplace(char*strSrc,char*strfind,char*strReplace);

上defineM100：

voidmain()

(chars[]=*ABCDEFGUIJKIA(NOPQRSTUVWXYZ/，;

charsi[]=*RST*;

char$2[]="ggg";

StrReplace(s,si,s2)：

printf(*%s\nw,s);

}

voidStrReplace(char*strSrc,char*strFind,char*strReplace)

(

inti=0;

intj;

intn=strlen(strSrc);

intk=strlcn(strFind);

for(i=0;i<n;i++)

(

if(*(strSrc+i)==*strFind)

(

for(j=0:j<k;j++)

(

if(*(strSrc+i+j)==*(strFind+j))

(

*(strSrc+i+j)=*(strReplace+j);

}

elsecontinue;

}

)

)

)

答案二：

#include<stdio.h>

ttdefineMAX100

StrReplace(char*s,char*sl,char*s2){

char*p;

for(：*s;s++){

for(p=si;*p&&*p!=*s;p++);

if(*p)*s=*(p-si+s2):

)

)

intmain()

(

chars[MAX];〃s是原字符串

charsi[MAX],s2[MAX];是要替换的

〃s2是替换字符串

putsCPleaseinputthestringfors:");

scanf(*%s*»s);

putsCPleaseinputthestringforsi:*);

scanf(飞s”,si);

puts(*Ploascinputthestringfors2:*);

scanf(飞s”,s2);

StrReplace(s,si,s2);

putsCThestringofsafterdisplaceis:*);

printf(飞s\n”,s);

return0：

)

答案三：

4include<stdio.h>

^include<stdlib.h>

4include<string.h>

4defineM100

voidStrReplace(char*strSrc,char*strF'ind,char*strReplace);

intmain()

(

chars□="ABCDEFGHIJKLMNOPQRSTUVWXYZ”：

charsi[]=*RST*;

chars2[]=*gggg*;

StrReplace(s,si,s2);

printf(“5s\n",s)：

return0：

)

voidStrReplace(char*strSrc,char*sltTind,char*strReplace)

(

while(*strSrc!='\0')

(

if(*strSrc==*strFind)

{

if(strncmp(strSrc,strFind,strlen(strFind))==0)

(

inti=strlen(strFind);

intj=strlen(strReplace);

printfCi=%d,j=%d\nw,i,j);

char*q=strSrc+i;

printf(w*q=%s\n”,q);

while((*strSrc++=*strReplace++)!='\0');

printf(*strSrc-1=为s\n",strSrc-1);

printf(**q=%s\n*,q);

while((*strSrc++=*q++)!=*\0*);

}

else

(

strSrc++;

}

)

else

(

strSrc++;

)

)

}

15、编写一个程序实现功能：将字符串"ComputerSecience”