华为上机笔试题

1.给定一个字符串，把字符串内的字母转换成该字

母的下一个字母，a换成b，z换成a，Z换成A，

如aBf转换成bCg，字符串内的其他字符不改变，

给定函数，编写函数

void Stringchang（const char*inpu,char*output）

其中input是输入字符串，output是输出字符串

#include

#include

void Stringchang(const char*input,char*output)

{

const char *p=input;

/*if(input==NULL)

{

printf("ERROR"); //用这种表示方式可否？

return; //用return 好不好？

} */

assert(input!=NULL);

while(*p!='\0')

{

if((*p>='a')&&(*p<='y')||(*p>='A')&&(*p<='Y') )

*output=*p+1;

else if(*p=='z'||*p=='Z')

*output=*p+1-26;

else

*output=*p;

output++;

p++;

}

*output=0;

}

void main()

{

char a[11]={"abc"}; //如何模拟空指针的情况

char b[11];

Stringchang(a,b);

printf("%s",b);

}

2.求一个整型数字中有没有相同的部分，例如

12389756123这个整型数字中相同的部分是123，

相同的部分至少应该是2位数，如果有相同部分返

回1，如果没有则返回0。函数为int same（int num）其中num是输入的整型数字

#include

using namespace std;

int same(int num) //整数值的范围：long int为-2（共

10位）到正2开头共10位；

unsigned //long int 为从0到4

的共10位数

{

char a[11];

int i=0,m=0,j=0;

while(num)

{

num=num/10;

i++;

j++;

}

i=0;

int k=j;

while(i

{

char temp=a[i];

a[i]=a[j-1];

a[j-1]=temp;

i++;

j--;

}

for(i=0;i

{

for(j=i+1;j

{

if(a[i]==a[j]&&a[i+1]==a[j+1])

return 1;

}

}

return 0;}

int main() //是不是用int 会好一点？

{

int a,b;

cin>>a;

b=same(a);

cout<

return 0;

}

3.求两个字符串的乘积，结果存到字符串中，例

如字符串一中存的“657891”，字符串二中存的

“521”，分别将字符串中的字符转换成整型数字，进行计算后，再转换成字符类型存储起来.

函数为void mul（char *input1，int n，char *input2, int m，char *output）

其中input1和input2是输入，n是input1的长度，

m是input2的长度。Output是输出

#include

#include

#include

using namespace std;

void mul(char *input1,int n,char *input2,int m,char *output)

{

long int num1=0,num2=0,num3=0; //char *p1=input1;char *p2=input2;

int i=0,j=0,temp;

int sign1=0,sign2=0;

assert(input1!=NULL&&input2!=NULL);

//以下程序是将input1字符串转换为数字，考虑到

了字符串中第一个字符为‘+’或者‘-’号的情况，//同时考虑到了非法输入时的处理情况。

if(*input1=='-')

{

input1++;

sign1=1;

}

if(*input1=='+')

input1++;

while(*input1!='\0')

{

assert(*input1<='9'&&*input1>='0');

num1=num1*10+(*input1-'0');

input1++;

}

if(sign1==1)

num1=-num1;

//以下程序是将input2字符串转换为数字，考虑到了字符串中第一个字符为‘+’或者‘-’号的情况，//同时考虑到了非法输入时的处理情况。

if(*input2=='-')

{

input2++;

sign2=1;

}

if(*input2=='+')

input2++;

while(*input2!='\0')

{

assert(*input2<='9'&&*input2>='0');

num2=num2*10+(*input2-'0');

input2++;

}

if(sign2==1)

num2=-num2;

//将两个数相乘

num3=num1*num2;

//考虑到结果为负数的情况,将整数转换为字符串，并且将字符串倒序

if(num3<0)

{

output[i]='-';

i++;

j++;

num3=-num3;

}

while(num3)

{

output[i]=num3%10+'0';

i++;

num3=num3/10;

}

output[i]=0;

//将字符串倒序

i--;

while(j

{

temp=output[j];

output[j]=output[i];

j++;

i--;

}

}

int main()

{

char a[10],b[10],c[10];

int anum,bnum;

cin>>a;

cin>>b;

anum=strlen(a);

bnum=strlen(b);

mul(a,anum,b,bnum,c);

cout<

return 0;

}

//用纯指针实现程序如下：

#include

#include

void mul(char *input1,int n,char *input2,int m,char *output)

{

int sum1=0,sum2=0,sum=0;

int i=0;

int sign1,sign2;

char *p=input1,*q=input2,*s=output,*r=output;

assert(input1!=NULL&&input2!=NULL);

if(*p=='+')

{

p++;

sign1=1;

}

else if(*p=='-')

{

p++;

sign1=0;

}

while(*p)

{

assert(*p<='9'&&*p>='0');

sum1=sum1*10+(*p-'0');

p++;

}

if(sign1==0)

{

sum1=-sum1;

}

//input2de chuli

if(*q=='+')

{q++;sign2=1;}

else if(*q=='-')

{q++;sign2=0;}

while(*q)

{

assert(*q<='9'&&*q>='0');

sum2=sum2*10+(*q-'0');

q++;

if(sign2==0) {sum2=-sum2;}

//两数相乘

sum=sum1*sum2;

// printf("%d",sum);

if(sum<0)

{

sum=-sum;

*s='-';

s++;

r++; //因为返回的指针开始地址是output,所以这里output不能变，只能是另外用一个指针代替他

}

while(sum)

{

*s=sum%10+'0';

sum=sum/10;

s++;

}

*s=0;

s--; //忘记s- - 了

//printf("%s\n",output);

while(r

{

char temp=*r;

*r=*s;

*s=temp;

s--;

r++;

}

//printf("%s\n",output);

}

void main()

{

char a[3]="12";

char b[3]="34";

char c[11];

mul(a,3,b,3,c);

printf("%s",c);

}

两个大数相乘：

#include

#include

#include

#define N 100

void GetDigits(int *a,char *s);

void multiply(int *a,int *b,int *c);

main()

{

char s1[N],s2[N];

int i,j,a[N],b[N],c[N*2];

printf("\n input number a: ");

scanf("%s",s1);

printf("\n input number b: ");

//把输入的字符串，按位存放到数组

GetDigits(a,s1);

GetDigits(b,s2);

multiply(a,b,c);

//找到最高位

j=N*2-1;

while(c[j]==0)

j--;

//打印计算结果

printf("\n %s * %s=",s1,s2);

for(i=j;i>=0;i--)

printf("%d",c[i]);

}

/*把字符串形式的数字按位存放到数组*/

void GetDigits(int *a, char *s)

{

int i;

char digit;

int len=strlen(s);

for(i=0;i

*(a+i)=0;

for(i=0;i

{

digit=*(s+i);

*(a+len-1-i) = digit - '0';

}

}

/*把a*b的结果存储到数组c中，按位表示*/ void multiply(int *a,int *b,int *c)

{

int i,j;

//先把结果数组设置为0

for(i=0;i

*(c+i)=0;

for(i=0;i

for(j=0;j

{

*(c+i+j)+=*(a+i) * *(b+j);

printf("%d",*(c+i+j));

}

// 处理进位

for(i=0;i

{

*(c+i+1)+=*(c+i)/10; //进位累加到高位

*(c+i)=*(c+i)%10; //该位的最后结果

}

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

#include

#include

#include

#include

int delete_sub_str(const char *str,const char *sub_str,char *result)

{

const char *p,*q; //注意最刚开始就要加const

p=str;

q=sub_str;

int count=0;

int num=strlen(sub_str);

assert(str!=NULL&&sub_str!=NULL);

while(*p!='\0') //没有想法

{

if(*p==*q)

{

for(int i=1;i

{

if(*(p+i)!=*(q+i))

break;

}

if(i==num)

{

count++;

p+=num;

}

}

else if(*p!=*q)

{

*result=*p;

p++; //这里自己写错了

result++; //这里自己写错了

}

}

*result=0;

return count;

}

void main()

{

char s[100] = {'\0'};

int num = delete_sub_str("123abc12de234fg1hi34j123k","123",s );

printf("The number of sub_str is %d\r\n",num);

printf("The result string is %s\r\n",s);

}

//用指针实现

#include

#include

int delete_sub_str(const char *str,const char *sub_str,char *result)

{

char *r;

p=str;

q=sub_str;

r=result;

int num=0,i=0,k=0;

while(*(p+i))

{

if(*(p+i)==*(q))

{

for(int j=0;*(q+j)!='\0';j++)

{

if(*(p+i+j)!=*(q+j))

break;

}

if(*(q+j)=='\0')

{

num++;

i+=j;

}

}

else

{

*(r+k)=*(p+i);

k++;

i++;

}

}

*(r+k)=0;

return num;

}

void main()

{

char s[100] = {'\0'};

int num = delete_sub_str("a123abc123de","123",s);

printf("The number of sub_str is %d\r\n",num);

printf("The result string is %s\r\n",s);

}

6、比较一个数组的元素是否为回文数组

#include

#include

#include

int huiwen(char str[])

{

char *p=str;

int i=0;

int j=strlen(str);

assert(str!=NULL);

j--;

while(i

{

if(*(p+i)!=*(p+j))

{

return 0;

}

j--;

}

return 1;

}

/*或者是用下面的方法原理是一样的

int i=0,j=0;

assert(str!=NULL);

while(str[j])

{

j++;

}

j--;

while(i

{

if(str[i]!=str[j])

return 0;

i++;

j--;

}

return 1;

*/

void main()

{

char str[100] = {0};

int i;

printf("Input a string："); /*提示输入Input a string：*/

scanf("%s", str); /*scan()函数输入一个字符串：*/

i=huiwen(str);

if(i==0)

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

else if(i==1)

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

}

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

函数返回：３

#include

#include

#include

#include

int array_compare(int len1, int array1[], int len2, int

array2[])

{

int count=0;

assert(array1!=NULL&&array2!=NULL); //如何对传输的数组判空？

while(len1!=0&&len2!=0) //做错了，写成了(len1!=-1&&len2!=-1),注意这里的len1与len2分别

是数组的长度，不是下标编号！！！

{

if(array1[len1-1]!=array2[len2-1])

count++;

len1--;

len2--;

}

return count;

}

void main()

{

int array1[7]={1,2,3,4,5,6,7};

int array2[3]={4,5,6};

int num;

num=array_compare(7,array1,3,array2);

printf("%d",num); }

8、手机号码合法性判断（20分）

●问题描述：

我国大陆运营商的手机号码标准格式为：国家码+

手机号码，例如：8613912345678。特点如下：

1、长度13位；

2、以86的国家码打头；

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

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

1）如果手机号码合法，返回0；

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

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

4）如果手机号码不是以86打头的，返回3；

【注】除成功的情况外，以上其他合法性判断的优

先级依次降低。也就是说，如果判断出长度不合法，直接返回1即可，不需要再做其他合法性判断。

●要求实现函数：

int verifyMsisdn(char* inMsisdn)

【输入】 char* inMsisdn，表示输入的手机号码

字符串。

【输出】无

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

示例

输入： inMsisdn = “869123456789“

输出：无

返回： 1

输入： inMsisdn = “88139123456789“

输出：无

返回： 3

输入： inMsisdn = “86139123456789“

输出：无

返回： 0

#include

#include

#include

#include

int verifyMsisdn(char* inMsisdn) //记住：此处比较的是和字符‘0’比较，而不是和数字0比较

{

char *p = inMsisdn;

assert(p!=NULL);

int num=strlen(p);

if(num!=13) //在面试的时候最好用宏定义表达：#define LENGTH 13

return 1;

for(int i=0;i<13;i++)

if(*(p+i)<'0'||*(p+i)>'9')

return 2;

if((*p!='8')||(*(p+1)!='6'))

return 3;

return 0;

}

void main()

{

char number[15]="8613312345678";

int sign=verifyMsisdn(number);

printf("%d\n",sign);

char number1[15]="86133123456789"; //老是忘记：不能对数组直接赋值

sign=verifyMsisdn(number1);

printf("%d\n",sign);

char number2[15]="861331234567@";

sign=verifyMsisdn(number2);

printf("%d\n",sign);

char number3[15]="8113312345679";

sign=verifyMsisdn(number3);

printf("%d\n",sign);

}

9、选秀节目打分，分为专家评委和大众评委，

score[] 数组里面存储每个评委打的分数，judge_type[] 里存储与 score[] 数组对应的评

委类别，judge_type[i] == 1，表示专家评委，judge_type[i] == 2，表示大众评委，n表示评委总数。打分规则如下：专家评委和大众评委的分数先分别取一个平均分（平均分取整），然后，总分= 专家评委平均分 * 0.6 + 大众评委 * 0.4，总分取整。如果没有大众评委，则总分 = 专家评委平均分，总分取整。函数最终返回选手得分。

函数接口 int cal_score(int score[], int judge_type[], int n)

#include

#include

#include

#include

#define N 5

//总数：total 平均数：average 记住要强制类型转换为（int）,记住不要忘记判断当大众评委//为0时的情况,自己还额外加了当专家评委为零的情况。#include

#include

#include

#include

#define N 5

int cal_score(int score[], int judge_type[], int n) //该如何判断数组为空时的情况

{

int

total1=0,total2=0,average1=0,average2=0,num1=0,nu m2=0;

int sum;

for(int i=0;i

{

if(judge_type[i]==1)

{

total1+=score[i];

num1++;

}

else if(judge_type[i]==2)

{

total2+=score[i];

num2++;

}

}

if(num1==n)

sum=(int)(total1/n); //加强制类型转换符是个好习惯！

else if(num2==n)

sum=(int)(total2/num2);

else

{

average1=(int)(total1/num1);

average2=(int)(total2/num2);

sum=(int)(0.6*average1+0.4*average2);

}

return sum;

}

int main()

{

int score[N];

int judge_type[N];

int numberlast=0;

int i;

printf("please input the %d score:\n",N);

for(i=0;i

scanf("%d",&score[i]);

printf("please input the level(1:expert,2:dazhong)\n");

for(i=0;i

scanf("%d",&judge_type[i]);

numberlast=cal_score(score,judge_type,N);

printf("the last score is %d\n",numberlast);

return 0;

}

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

右的那个位置上，然后再按从大到小的顺序，依次在第一个位置的两边，按照一左一右的顺序，依次存放剩下的数。

例如：input[] = {3, 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

#include

#include

#include

//注意这里输出数组显示，是用for循环printf，显示，而不能用cout<<数组名

void sort(int input[], int n, int output[])

{

int temp;

for(int i=0;i

for(int j=i;j

{

if(input[i]

{

temp=input[i];

input[i]=input[j];

input[j]=temp;

}

}

for(i=0;i

{

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

}

printf("\n");

if(n%2==1)

{

int mid=(n-1)/2;

for(i=1;i<=mid;i++)

{

output[mid-i]=input[2*i-1];

output[mid+i]=input[2*i];

}

}

else

{

int mid=n/2;

output[mid]=input[0];

for(i=1;i

{

output[mid-i]=input[2*i-1];

output[mid+i]=input[2*i];

}

output[0]=input[n-1];

}

for(i=0;i

{

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

}

}

void main()

{

int input[] = {3, 6, 1, 9, 7,8} ;

int output[6];

int n=6;

sort(input,n,output);

}

11、操作系统任务调度问题。操作系统任务分为系统任务和用户任务两种。其中，系统任务的优先级< 50，用户任务的优先级 >= 50且 <= 255。优先级大于255的为非法任务，应予以剔除。现有一任务队列task[]，长度为n，task中的元素值表示任务的优先级，数值越小，优先级越高。函数scheduler实现如下功能，将task[] 中的任务按照系统任务、用户任务依次存放到 system_task[] 数组和 user_task[] 数组中（数组中元素的值是任务在task[] 数组中的下标），并且优先级高的任务排在前面，数组元素为-1表示结束。

例如：task[] =

{5,4,3,2,1,100,50} system_task[] = {1,2,3,4,5，-1} user_task[] =

{50,100,-1}

（方法一：边插入边用直接插入排序的方法进行排序，不完善，此处只做了排序，并没有存入想对位置）

void scheduler1(int task[], int n, int system_task[], int user_task[])

{

int label1=0,label2=0,i,j=0,k=0;

for(i=0;i

{

if(task[i]<50)

{

if(label1==0)

system_task[0]=task[i];

label1=1;

j++;

}

else

{

int m=task[i];

int x=j;

if(task[i]

{

while(m0)

{

system_task[x]=system_task[x-1];

x--;

}

system_task[x]=m;

}

else

system_task[j]=m;

j++;

}

}

else if(task[i]<=255)

{

if(label2==0)

{

user_task[0]=task[i];

label2=1;

k++;

}

else

{

int n=task[i];

int y=k;

if(task[i]

{

while(n0)

{

user_task[y]=user_task[y-1];

y--;

}

user_task[y]=n;

}

else

user_task[k]=n;

k++;

}

}

else if(task[i]>255)

{

}

}

user_task[k]=-1;

}

void main()

{

int task[]={5,4,3,2,1,100,50};

int n=7;

int system_task[6]; //需要预留-1的位置，这里为6，不能为5，否则结果有问题

int user_task[3]; //需要预留-1的位置，这里为3，不能为2，否则结果有问题

scheduler1(task,n,system_task, user_task);

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

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

printf("\n");

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

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

}

（方法二：先分别放在对应的数组中，再排序）#include

#include

#include

#include

void scheduler1(int task[], int n, int system_task1[], int user_task1[])

{

int i,j=0,k=0,num1=0,num2=0,m;

char a[256]={'\0'};

char system_task[256]={'\0'};

char user_task[256]={'\0'};

for(i=0;i

{

if(task[i]<50)

{

system_task[j]=task[i];

m=task[i];

a[m]=i;

j++;

num1++;

}

else if(task[i]<=255)

{

user_task[k]=task[i];

m=task[i];

a[m]=i;

k++;

num2++;

}

else if(task[i]>255)

{ }

}

//下边的代码是显示分完组后的情况

printf("未排序前system_task[]为：");

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

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

printf("\n");

printf("未排序前user_task[]为：");

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

printf("\n");

//对system_task[]中的数进行排序，冒泡法

printf("排序中system_task数的变化情况");

for(i=0;i

{

for(int m=0;m

{

if(system_task[m]>system_task[m+1])

{

int temp=system_task[m];

system_task[m]=system_task[m+1];

system_task[m+1]=temp;

}

//每调换一次显示其排序结果

for(int i=0;i<5;i++)

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

printf("\n");

}

}

for(i=0;i

{

m=system_task[i];

system_task1[i]=a[m];

}

//对user_task[]中的数进行排序，冒泡法

printf("排序中user_task数的变化情况");

for(i=0;i

{

for(int n=0;n

{

if(user_task[n]>user_task[n+1])

{

int temp=user_task[n];

user_task[n]=user_task[n+1];

user_task[n+1]=temp;

}

for(int i=0;i<2;i++)

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

printf("\n");

}

}

for(i=0;i

{

m=user_task[i];

user_task1[i]=a[m];

}

system_task1[j]=-1;

user_task1[k]=-1;

}

void main()

{

int task[]={5,4,3,2,1,100,50};

int n=7;

int system_task[6];

scheduler1(task,n,system_task, user_task);

printf("系统相对位置");

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

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

printf("\n");

printf("用户相对位置");

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

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

}

12、输入一个字符串，用指针求出字符串的长度。//不要忘记P++!

#include

#include

int main()

{

char str[20], *p;

int length=0;

printf(“Please input a string: ”);

gets(str);

p=str;

while(*p++)

{

length++;

}

printf(“The length of string is %d\n”, length);

return 0;

}

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

描述：编写一个字符串替换函数，如函数名为StrReplace(char* strSrc, char* strFind, char* strReplace)，strSrc为原字符串，strFind是待替换的字符串，strReplace为替换字符串。

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

目前程序有两个问题：第一：运行结果中老是多一个1，第二：不知道如何把改变了的字符串传回去。#include

#include

#include

#include

#include

#include

void StrReplace(char* strSrc, char* strFind, char* strReplace)

{

char *p;

p=(char*)malloc(sizeof(100));

int n=strlen(strSrc);

int m=strlen(strFind);

int k=strlen(strReplace);

int sign=0,num=0;

for(int i=0;i+m*num

{

if(sign==1)

{

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

{

for(int j=0;j

{

if(*(strSrc+i+num*m+j)!=*(strFind+j))

break;

}

if(j==m)

{

for(int z=0;z

*(p+i+num*k+z)=*(strReplace+z);

num++;

i--;

}

}

else

{

*(p+i+k*num)=*(strSrc+i+m*num);

}

}

else if(sign==0)

{

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

{

for(int j=0;j

{

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

break;

}

if(j==m)

{

for(int z=0;z

*(p+i+z)=*(strReplace+z);

sign=1;

i--;

num++;

}

}

else

{

*(p+i)=*(strSrc+i);

}

}

}

*(p+i+k*num+1)='\0';

strSrc=p;

printf("%s\n",strSrc);

printf("\n");

while(*p)

{

*strSrc=*p;

strSrc++;

p++;

}

}

void main()

{

char s[]="ABCDEFG";

char s1[]="BCD";

char s2[]="gggg";

StrReplace(s,s1,s2);

printf("%s\n",s);

}

//方法二

14、编写一个程序实现功能：将字符串”Computer Secience”赋给一个字符数组，然后从第一个字母开始间隔的输出该串，用指针完成

#include

#include

void main()

{

char string[]="Computer Seciece";

printf("%s\n",string);

char *p=string;

while(*p!='\0'&&*(p+1)!='\0') //注意这里的判

断条件，如果不

加*(p+1)!='\0'会

出现不可知的

运算符

{

printf("%c",*p);

p++;

p++;

}

if(*(p+1)=='\0') //此时还要对少的那个运算符补充上

printf("%c",*p);

printf("\n");

}

15、编写一个程序实现功能：将两个字符串合并为一个字符串并且输出，用指针实现。

#include

#include

void main()

{

char str1[20]={"Hello"}, str2[20]={"World"};

char *p,*q;

p=str1;

q=str2;

while(*p)

p++; //注意不要用p=q,然后就结束了，这不是链表！

//p=q;这是我第二次自己加的，注意这里不可以加这个，因为现在就是需要把*q中的内容放在p之后

的下//一个地址中，故万万不可以加，加了之后只

能输出Hello.

while(*q)

{

*p=*q;

p++;

q++;

}

*p=0;

puts(str1);

}

17、将字符串反转，但单词不倒置。//第二次自己没做出来

#include

#include

char* reverse(char *string)

{

char *begin,*end,*pbegin;

begin=end=string;

while(*end)

end++;

end--;

while(begin

{

char temp=*begin;

*begin=*end;

*end=temp;

begin++;

end--;

}

begin=end=string;

while(*begin)

{

if(*begin!=' ')

{

while(*end!=' '&&*end!='\0')

end++;

pbegin=end;

end--;

while(begin

{

char temp=*begin;

*begin=*end;

*end=temp;

begin++;

end--;

}

begin=end=pbegin;

}

else

{

begin++;

end++;

}

}

return string;

} void main()

{

char string[]="abcd ab";

char *ptr;

ptr=reverse(string);

cout<

}

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

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

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

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

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

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

? 要求实现函数：

int calculate(int len,char *expStr)

#include

#include

int cal(int c1, char op, int c2)

{

if (op=='+') return c1+c2;

if (op=='-') return c1-c2;

if (op=='*') return c1*c2;

if (op=='/') return c1/c2;

return 0;

}

int calculate(int len, char *expStr)

{

assert(expStr);

if (len < 3) return -1;

char *p = expStr;

int c1 = p[0]-'0';

char op = p[1];

int c2 = p[2]-'0';

p += 3;

while(*p)

{

if (*p=='*' || *p=='/')

{

c2 = cal(c2, *p, p[1]-'0');

}

else

{

c1 = cal(c1, op, c2);

op = *p;

c2 = p[1]-'0';

}

p += 2;

}

return cal(c1, op, c2);

}

int main(void) {

int ret1 = calculate(3, "1+2");

int ret2 = calculate(11, "1+2*3/5-6*7"); int ret3 = calculate(11, "1+2-3/5-6*7"); printf ("values: %d, %d, %d", ret1, ret2, ret3);

return 0;

}

带有括号的：https://www.360docs.net/doc/ca12008751.html,/view/bc24dcc06137ee0 6eff91834.html

19、算分数的问题，去掉一个最高分一个最低分，求平均分(2012华为成都试题1)

方法一：先排序，再去掉一个数组的首尾元素，最后求平均分。时间复杂度为O(n^2)

#include

float avescore(float score[],int n)

{

float sum=0,aver;

for(int i=0;i

{

for(int j=0;j

{

if(score[j]>score[j+1])

{

float temp=score[j];

score[j]=score[j+1];

score[j+1]=temp;

}

}

}

for(i=1;i

{

sum+=score[i];

}

aver=sum/(n-2);

return aver;

}

void main()

{

float score[6]={70,80,90,98,87,86};

float average;

average=avescore(score,6);

printf("%5.2f\n",average);

}

方法二：直接挑选出最大值和最小值，并将原来的最大值最小值改变为0，最后求平均值，注意求平均值得时候除以的n-2,因为把最大值与最小值其变为0，只是为了方便累加和，其实他们的值并未包含在其中。时间复杂度为O（n）. #include

float avescore(float score[],int n) //有函数返回值时要记得有return

{

float sum=0,aver; //注意是float型的，不要习惯性的写int

float min,max;

int m=0,z=0; //记得要初始化为零，因为

存在当min或者max就是第一个元素的情况

min=score[0];

for(int i=1;i

{

if(min>score[i])

{

min=score[i];

m=i;

}

}

score[m]=0;

max=score[0];

for(i=1;i

{

if(max

{

max=score[i];

z=i;

}

}

score[z]=0;

for(i=0;i

{

sum+=score[i];

}

aver=sum/(n-2);

return aver;

}

void main()

{

float score[6]={70,80,90,98,87,86};

float average;

average=avescore(score,6);

printf("%5.2f\n",average);

}

20、对一个数组，将数组中偶数从大到小排序，奇数从小到大排序,奇数和偶数交叉着放且输出数组第一位放奇数，若奇数和偶数不等长，则把剩下的直接放到数组中。

(2012华为成都试题2)

函数原型：void jiou(int a[],int n)

//对于传递的为数组就不用再在后边加0了，因为这会增加数组//长度，从而产生运行错误。

#include

void jiou(int a[],int n)

{

int p[10];

int q[10];

int j=0,k=0;

for(int i=0;i

{

if(a[i]%2==0)

{

p[j]=a[i];

j++;

}

else

{

q[k]=a[i];

k++;

}

}

printf("提取的偶数序列为："); for(int l=0;l

printf("%3d",p[l]);

printf("\n");

printf("提取的奇数序列为:");

for(l=0;l

printf("%3d",q[l]);

printf("\n");

int m=j;

int r=k;

for(i=0;i

{

for(j=0;j

{

if(p[j]

{

int temp=p[j];

p[j]=p[j+1];

p[j+1]=temp;

}

}

}

printf("排序后的偶数序列为："); for(l=0;l

printf("%3d",p[l]);

printf("\n");

for(i=0;i

{

for(j=0;j

if(q[j]>q[j+1])

{

int temp=q[j];

q[j]=q[j+1];

q[j+1]=temp;

}

}

printf("排序后的奇数序列为："); for(l=0;l

printf("%3d",q[l]);

printf("\n");

/*p[m]=-1;

q[r]=-1;

j=0;k=0;

for(i=0;i

{

if(i%2==0&&q[k]!=-1)

{

a[i]=q[k];

k++;

}

else if(i%2==1&&p[j]!=-1)

{

a[i]=p[j];

j++;

}

else if(q[k]==-1&&p[j]!=-1)

{

a[i]=p[j];

j++;

}

else if(p[j]==-1&&q[k]!=-1)

{

a[i]=q[k];

k++;

}

}*/

m=0;n=0;

for(i=0;i

{

if(i%2==0&&n

{

a[i]=c[n];

n++;

}

else if(i%2==1&&m

{

a[i]=b[m];

m++;

}

else if(n==k)

{

a[i]=b[m];

m++;

}

else if(m==j)

{

a[i]=c[n];

n++;

}

}

// a[i]=0;

printf("排序后的数组为：");

for(i=0;i

{

printf("%3d",a[i]);

}

}

void main()

{

int a[10]={2,3,14,6,2,15,12,14,4,11}; jiou(a,10);

}

21、通过键盘输入一串小写字母(a~z)组成的字符串。请编写一个字符串过滤程序，若字符串中出现多个相同的字符，将非首次出现的字符过滤掉。

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

#include

#include

#include

void stringFilter(const char *pInputStr,char *pOutputStr)

{

const char *p=pInputStr;

char *q=pOutputStr,*r;

int sign=0;

int i=0;

assert(pInputStr!=NULL&&pOutputStr!=NU LL);

int a[27]={0};

while(*p)

{

assert(*p<='z'&&*p>='a');

/*if(sign==0)

{

*q=*p;

// printf("%c",*q);

q++;

p++;

sign=1;

*q='\0';

}

else

{

r=pOutputStr;

while(*r)

{

if(*r==*p)

{

p++;

break;

}

r++;

}

if(*r=='\0')

{

*q=*p;

q++;

p++;

*q='\0';

// printf("%c",*q);

}

}*/

if(a[*p-'a']==1)

{

p++;

}

else if(a[*p-'a']==0)

{

a[*p-'a']=1;

q[i]=*p;

i++;

p++;

}

}

q[i]=0;

}

void main()

{

char a[]="abcdefabc";

char b[10];

// int n=strlen(a);

stringFilter(a,b);

printf("%s",b);

}

22、通过键盘输入一串小写字母(a~z)组成的字符串。请编写一个字符串压缩程序，将字符串中连续出席的重复字母进行压缩，并输出压缩后的字符串。

压缩规则：

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

2. 压缩字段的格式为"字符重复的次数+字符"。例如：字符串"xxxyyyyyyz"压缩后就成为"3x6yz" void stringZip(const char *pInputStr, long InputLen, char *pOutputStr)

{

const char *p=pInputStr;

char *q=pOutputStr;

int i,j=0;

for(i=0;i

{

if(*(p+i)==*(p+i+1))

{

int k=1;

int num=2;

while(*(p+i+k)==*(p+i+k+1))

{

num++;

k++;

}

*(q+j)=num+'0';

*(q+j+1)=*(p+i);

j++;

i+=num;

}

else if(*(p+i)!=*(p+i+1))

{

*(q+j)=*(p+i);

j++;

i++;

}

}

*(q+j)=0;

}

void main()

{

char a[]="aabbbcde";

char b[10];

int n=strlen(a);

stringZip(a,n,b);

printf("%s",b);

}

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

输入字符串的格式为：“操作数1 运算符操作数2”，“操作数”与“运算符”之间以一个空格隔开。

#include

#include

#include

void arithmetic(const char *pInputStr, long InputLen, char *pOutputStr)

{

const char *p=pInputStr;

char *q=pOutputStr;

int i,j=0,k;

int a=0,b=0,c;

for(i=0;i

{

if(*(p+i)<='9'&&*(p+i)>='0')

{

while(*(p+i)!=' ')

{

a=a*10+*(p+i)-'0';

i++;

}

printf("the a is %d",a);

printf("\n");

if(*(p+i)==' ')

{

i++;

if(*(p+i)=='+'||*(p+i)=='-')

{

k=i;

i++;

if(*(p+i)==' ')

{

i++;

if(*(p+i)<='9'&&*(p+i)>='0')

{

while(*(p+i)!='\0')

{

b=b*10+*(p+i)-'0';

i++;

}

printf("the b is %d",b);

printf("\n");

}

}

}

}

}

else

printf("格式错误");

return ;

}

if(*(p+k)=='+')

c=a+b;

else if(*(p+k)=='-')

c=a-b;

printf("the c is %d",c);

printf("\n");

int num=0,begin=0,sign;

if(c>0)

{

while(c)

{

*q=c%10+'0';

c=c/10;

q++;

num++;

}

sign=num;

num--;

q=pOutputStr;

while(begin

{

int temp=*(q+begin);

*(q+begin)=*(q+num);

*(q+num)=temp;

begin++;

num--;

}

*(q+sign)=0;

}

if(c<0)

{

c=-c;

begin++;num=1;

*q='-';

while(c)

{

*(q+1)=c%10+'0';

c=c/10;

q++;

num++;

}

sign=num;

num--;

q=pOutputStr;

while(begin

{

int temp=*(q+begin);

*(q+begin)=*(q+num);

*(q+num)=temp;

begin++;

num--;

}

*(q+sign)=0;

}

}

void main()

{

char a[]="11 - 23";

char b[10];

int n=strlen(a);

arithmetic(a,n,b);

printf("%s",b);

}

24、一个字符串里面包含了一些位置不定的空格符，把里面所有的非空格字符找出来，把空格用…，?替换。

替换后的句子末尾必须有一个…，?存在。

例如“this is an demo”替换后应该为：

"this,is,an,demo,"

#include

#include

#include

void ReplaceString(const char *pInString,long llnput,char *pOutString) {

const char *p=pInString;

int n=llnput;

char *q=pOutString;

int j=0,i=0;

while(*(p+j))

{

if(*(p+j)!=' ')

{

*(q+i)=*(p+j);

i++;

j++;

}

else if(*(p+j)==' ')

{

*(q+i)=',';

i++;

j++;

while(*(p+j)==' ')

{

}

}

}

*(q+i)=',';

*(q+i+1)=0;

}

void main()

{

char a[]="abc def gh";

char b[20]={'\0'};

ReplaceString(a,strlen(a),b);

printf("%s",b);

}

25、字符串逆序

typedef struct tagListNode

{

int value;

struct tagListNode *next;

}ListNode;

ListNode *converse(ListNode *head)

{

ListNode *p,*q,*s;

p=head;

assert(head!=NULL&&head->next!=NULL);

q=p->next;

while(q!=NULL)

{

s=q->next;

q->next=p;

p=q;

q=s;

}

head->next=NULL;

head=p;

return head;

}

void main()

{

ListNode *head,*p,*q;

head=(ListNode

*)malloc(sizeof(ListNode));

head->value=0;

q=head;

for(int i=1;i<10;i++)

{

p=(ListNode

*)malloc(sizeof(ListNode));

p->value=i;

q->next=p;

q=p;

}

p->next=NULL;

p=head;

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

{

printf("%d",p->value);

p=p->next;

}

head=converse(head);

p=head;

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

{

printf("%d",p->value);

p=p->next;

}

}

题目一：子串分离

题目描述：

通过键盘输入任意一个字符串序列，字符串可能包含多个子串，子串以空格分隔。请编写一

个程序，自动分离出各个子串，并使用’,’将其分隔，并且在最后也补充一个’,’并将子

串存储。

如果输入“abc def gh i d”，结果将是abc,def,gh,i,d,

要求实现函数：

void DivideString(const char *pInputStr, long lInputLen, char *pOutputStr);

【输入】pInputStr：输入字符串

lInputLen：输入字符串长度

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

【注意】只需要完成该函数功能算法，中间不需要有任何IO 的输入输出

示例

输入：“abc def gh i d”

输出：“abc,def,gh,i,d,”#include

void DivideString(const char *pInputStr, long lInputLen, char *pOutputStr)

{

/* int cnt = 0;

for(int i=0;i

{

if(pInputStr[i]!=' ')

{ cnt = 0;

*pOutputStr++ = pInputStr[i];

}

else

{ cnt++;

if(cnt==1)

*pOutputStr++ = ',';

}

}

*pOutputStr++ = ',';

*pOutputStr = '\0';

*/

int cnt;

while(*pInputStr)

{

if(*pInputStr!=' ')

{ cnt = 0;

*pOutputStr++ = *pInputStr++;

}

else

{ cnt++;

pInputStr++;

if(cnt==1)

*pOutputStr++ = ',';

}

}

*pOutputStr++ = ',';

*pOutputStr = '\0';

}

void main()

{

char *str = "abc def gh i d";

int len = strlen(str);

char *outstr = (char*)malloc(len));//sizeof（std）=4 sizeof （*str）=18

//char outstr[100];

DivideString(str,len,outstr);

printf("%s",outstr);

printf("\n");

}

题目二：逆序链表输出。

题目描述：

将输入的一个单向链表，逆序后输出链表中的值。链表定义如下：

typedef struct tagListNode

{

int value;

struct tagListNode *next;

}ListNode;

要求实现函数：

void converse(ListNode **head);

【输入】head：链表头节点，空间已经开辟好

【输出】head：逆序后的链表头节点

【返回】无struct node *Reverse (struct node *head) {

struct node *p; //临时存储

struct node *p1; //存储返回结果

struct node *p2; //源结果节点一个一个取

p1 = NULL; //开始颠倒时，已颠倒的部分为空

p2 = head; //p2指向链表的头节点

while(p2 != NULL)

{

p = p2->next;

p2->next = p1;

p1 = p2;

p2 = p;

}

head = p1;

return head;

}

/*

题目描述（60分）：

通过键盘输入一串小写字母(a~z)组成的字符串。请编写一个字符串过滤程序，若字符串中出现多个

相同的字符，将非首次出现的字符过滤掉。

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

要求实现函数：

void stringFilter(const char *pInputStr, long lInputLen, char *pOutputStr);

【输入】 pInputStr：输入字符串

lInputLen：输入字符串长度

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

【注意】只需要完成该函数功能算法，中间不需要有任何IO的输入输出

示例

输入：“deefd”输出：“def”

输入：“afafafaf”输出：“af”

输入：“pppppppp”输出：“p”

*/

/* main函数已经隐藏，这里保留给用户的测试入口，在这里测试你的实现函数，可以调用printf 打印输出*/

/* 当前你可以使用其他方法测试，只要保证最终程序能正确执行即可 */

/* 该函数实现可以任意修改，但是不要改变函数原型。一定要保证编译运行不受影响*/

/* #include

void stringFilter(const char *p_str, long len, char *p_outstr)

{

int array[256]={0};

const char *tmp = p_str;

for(int j=0;j

{

if(array[tmp[j]]==0)

*p_outstr++= tmp[j];

array[tmp[j]]++;

}

*p_outstr = '\0';

}

void main()

{

char *str = "cccddecc";

int len = strlen(str);

char * outstr = (char *)malloc(len*sizeof(char));

stringFilter(str,len,outstr);

printf("%s",outstr);

free(outstr);

outstr = NULL;

}

题目描述（40分）：

通过键盘输入一串小写字母(a~z)组成的字符串。请编写一个字符串压缩程序，将字符串中连续出席的重复字母进行压缩，并输出压缩后的字符串。

压缩规则：

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

2. 压缩字段的格式为"字符重复的次数+字符"。例如：字符串"xxxyyyyyyz"压缩后就成为"3x6yz"

要求实现函数：

void stringZip(const char *pInputStr, long lInputLen, char *pOutputStr);

【输入】 pInputStr：输入字符串

lInputLen：输入字符串长度

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

【注意】只需要完成该函数功能算法，中间不需要有任何IO的输入输出

示例

输入：“cccddecc”输出：“3c2de2c”

输入：“adef”输出：“adef”

输入：“pppppppp”输出：“8p”

*/ #include

void stringZip(const char *p_str, long len, char *p_outstr)

{

int count=0;

for(int i=0;i

{

if(p_str[i]==p_str[i+1])

{

count++;

}

else

{

count++;

if(count>1)

{

*p_outstr++ = count +'0';

*p_outstr++ =p_str[i];

}

else

{

*p_outstr++ =p_str[i];

}

count = 0;

}

}

*p_outstr = '\0';

}

void main()

{

char *str = "cccddecc";

int len = strlen(str);

char * outstr = (char*)malloc(len*sizeof(char));

// char outstr[100];

stringZip(str,len,outstr);

printf("%s",outstr);

free(outstr);

outstr = NULL;

}