华为校招机试题目个人整理_华为校招历年机试题目

2020-02-26 其他范文下载本文

华为校招机试题目个人整理由刀豆文库小编整理，希望给你工作、学习、生活带来方便，猜你可能喜欢“华为校招历年机试题目”。

2016校招机试题

第一题

输入一串用空格隔开的数字串，对于数字串的奇数位按升序排序，偶数位按降序排序示例输入：4 6 2 3 7 8 1 处理过程：

奇数位：4268升序排序结果：2468 偶数位：6371 降序排序结果：7631 结果输出：2 7 4 6 6 3 8 1 #include #include #include void sort(char input[], int n, char output[]);void main(){ char input1[]=“4 6 2 3 6 7 8 1”;char output1[16];int m=15;sort(input1,m,output1);for(int i=0;i

printf(“%c ”,output1[i]);printf(“n”);}

void sort(char input[],int n,char output[]){ int i,j,t1,t2,t=0;int *b=(int *)malloc(sizeof(int)*n);int *c=(int *)malloc(sizeof(int)*n);

b[0]=input[0]-'0';for(i=4,t1=1;i

for(j=t1-1;((input[i]-'0')=0);j--)

{

b[j+1]=b[j];

}

b[j+1]=input[i]-'0';}

c[0]=input[2]-'0';for(i=6,t2=1;i

for(j=t2-1;((input[i]-'0')>c[j])&&(j>=0);j--)

{

c[j+1]=c[j];

}

c[j+1]=input[i]-'0';}

for(i=0,j=0;i

output[i]=b[j]+'0';

output[i+1]=' ';

output[i+2]=c[j]+'0';

output[i+3]=' ';} } 2.精灵王子爱好冒险，在一次探险历程中，他进入了一个神秘的山洞。在洞穴深处，精灵王子不小心触动了洞穴内暗藏的机关，整个洞穴将很快塌陷，精灵王子必须尽快逃离洞穴。精灵王子的跑步速度为17m/s,以这样的速度可能是无法逃出洞穴的。庆幸的是精灵王子拥有闪烁法术，可在1s内移动60m，不过每次使用闪烁法术都会消耗法值10点。精灵王子的魔法值恢复的速度为4点/s，只能在原地休息状态时才能恢复。

现在已知精灵王子的魔法初值M,他所在洞穴中的位置与洞穴出口之间的距离S,距离洞穴塌陷的时间T.你的任务是写一个程序帮助精灵王子计算如何在最短时间内逃离洞穴。若能逃出，输出“Yes”,并输出逃出所用的最短时间；若不能逃出，则输出”No“，同时输出精灵王子在剩下的时间内能走的最远距离。注意字母大小写。注意精灵王子跑步，闪烁或休息活动均以秒（s）为单位。且每次活动的持续时间为整数秒。距离的单位为米（m）。

注：M,S,T均是大于等于0的整数。由输入保证取值合法性，考生不用检查。提醒：

如果输入的S为0，则说明本身已经在出口，输出应为：Yes 0 如果输入的T为0（且S不为0），则说明已经没有时间了，输出应为：No 0 输入格式： M S T 输出格式：

Yes 逃出洞穴所用时间或

No在洞穴塌陷前能逃跑的最远距离 10 #include void main(){ int M,S,T;int de1=0,de2=0;int start=T;scanf(“%d %d %d”,&M,&S,&T);if(S==0)

printf(“Yes 0n”);else {

}

} if(T==0)printf(“No 0n”);else { while(T){

T--;

if(M>=10)

{

M-=10;

de1+=60;

}

else

{

M+=4;

}

de2+=17;

if(de2

de2=de1;

if(de2>S)

{

printf(“Yes %dn”,start-T);

break;

}

else

{

printf(“No %dn”,de2);

break;

} }

}

2015校招机试题

第一题(60分)：

按要求分解字符串，输入两个数M，N；M代表输入的M串字符串，N代表输出的每串字符串的位数，不够补0。例如：输入2,8，“abc”，“123456789”，则输出为“abc00000”,“12345678“,”90000000” #include #include void main(){ int m,n,i,j,p=0;char str[1024];int a[10];scanf(“%d%d”,&m,&n);printf(“please input %d string:n”,m);for(i=0;i

scanf(“%s”,&str[p]);

a[i]=strlen(str+p);

p=p+a[i];

} p=0;for(i=0;i

if(a[i]

{

for(j=p;j

printf(“%c”,str[j]);

for(j=a[i];j

printf(“0”);

printf(“n”);

}

else if(a[i]==n)

{

for(j=p;j

printf(“%c”,str[j]);

printf(“n”);

}

else

{

for(j=p;j

printf(“%c”,str[j]);

printf(“n”);

for(j=n+p;j

printf(“%c”,str[j]);

for(j=0;j

printf(“0”);

printf(“n”);

}

p=p+a[i];

} } 第一题：拼音转数字

输入是一个只包含拼音的字符串，请输出对应的数字序列。转换关系如下：描述: 拼音 yi er san si wu liu qi ba jiu

阿拉伯数字 1 2 3 4 5 6 7 8 9 输入字符只包含小写字母，所有字符都可以正好匹配运行时间限制：无限制内存限制：

无限制

输入：

一行字符串，长度小于1000 输出：

一行字符（数字）串样例输入：

yiersansi 样例输出：

1234 #include #include void main(){ int i,j;char str[1000];char ch;scanf(“%s”,str);int len=strlen(str);for(i=0;i

switch(str[i])

{

case 'y':

printf(“1”);

i=i+2;

break;

case 'e':

printf(“2”);

i=i+2;

break;

case 's':

if(str[i+1]=='a')

{

printf(“3”);

i=i+3;

}

else

{

printf(“4”);

i=i+2;

}

break;

case 'w':

printf(“5”);

i=i+2;

break;

case 'l':

printf(“6”);

i=i+3;

break;

case 'q':

printf(“7”);

i=i+2;

break;

case 'b':

printf(“8”);

i=i+2;

break;

case 'j':

printf(“9”);

i=i+3;

break;

default:

break;

} } }

第二题：去除重复字符并排序

运行时间限制：无限制内容限制：

无限制输入：

字符串

输出：

去除重复字符并排序的字符串样例输入：

aabcdefff 样例输出：

abcdef #include #include #include void solve(char *str , int len){

int i,hash[256];

memset(hash,0,sizeof(hash));

for(i=0;i

{

if(0==hash[str[i]])

hash[str[i]]=1;

}

for(i=0;i

{

if(0!=hash[i])

putchar(i);

} printf(“n”);} int main(void){

int len;

char str[1000];

while(scanf(“%s” , str)!= EOF)

{

len = strlen(str);

solve(str , len);

}

return 0;} 第三题：等式变换

输入一个正整数X，在下面的等式左边的数字之间添加+号或者-号，使得等式成立。1 2 3 4 5 6 7 8 9 = X 比如：

12-34+5-67+89 = 5 1+23+4-5+6-7-8-9 = 5 请编写程序，统计满足输入整数的所有整数个数。输入：

正整数，等式右边的数字输出：

使该等式成立的个数样例输入：5 样例输出：21 #include #include

int ops[21];const char sym[3]={'+','-',' '};int result,num;

void dfs(int layer,int currentResult,int lastOp,int lastSum){ lastSum*=(layer>9)?100:10;

lastSum+=layer;

if(layer==9){

currentResult+=(lastOp)?(-1*lastSum):lastSum;

if(currentResult==result)

{

++num;

printf(“1”);

for(int i=2;i

{

if(sym[ops[i-1]]!=' ')

printf(“ %c ”, sym[ops[i-1]]);

printf(“%d”,i);

}

printf(“=%dn”,result);

}

return;} ops[layer]=2;dfs(layer+1,currentResult,lastOp,lastSum);//Continue currentResult+=(lastOp)?(-1*lastSum):lastSum;ops[layer]=0;dfs(layer+1,currentResult,0,0);//Plus ops[layer]=1;dfs(layer+1,currentResult,1,0);//Minus } void main(){ while(scanf(“%d”, &result)!=EOF){

num=0;

dfs(1,0,0,0);

printf(“%dn”,num);} }

2014校招机试题

一、题目描述（60分）：

通过键盘输入一串小写字母(a~z)组成的字符串。请编写一个字符串过滤程序，若字符串中出现多个相同的字符，将非首次出现的字符过滤掉。比如字符串“abacacde”过滤结果为“abcde”。

要求实现函数：void stringFilter(const char *pInputStr, long lInputLen, char *pOutputStr);#include #include void stringFilter(const char *pInputStr, long lInputLen, char *pOutputStr);void main(){ char str[100];char sr[100];scanf(“%s”,str);int len=strlen(str);stringFilter(str,len,sr);

printf(“%sn”,sr);} void stringFilter(const char *pInputStr, long lInputLen, char *pOutputStr){ int i,j;int m=0;char hash[256];memset(hash,0,256);for(i=0;i

if(hash[pInputStr[i]]==0)

{

hash[pInputStr[i]]=1;

pOutputStr[m]=pInputStr[i];

m++;

}

} pOutputStr[m]='';}

二、题目描述（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 #include void stringZip(const char *pInputStr,long lInputLen,char *pOutputStr);void main(){ int i,j;char str[256];char sr[256];scanf(“%s”,str);int len=strlen(str);stringZip(str,len,sr);printf(“%sn”,sr);} void stringZip(const char *pInputStr,long lInputLen,char *pOutputStr){ int i=0,j;int m,z=0;while(i

m=0;

for(j=i+1;j

{

if(pInputStr[i]==pInputStr[j])

m++;

else

break;

}

pOutputStr[z]=m+1+48;

pOutputStr[z+1]=pInputStr[i];

z=z+2;

i=i+m+1;} pOutputStr[z]='';}

三、题目描述（50分）：

通过键盘输入100以内正整数的加、减运算式，请编写一个程序输出运算结果字符串。输入字符串的格式为：“操作数1 运算符操作数2”，“操作数”与“运算符”之间以一个空格隔开。补充说明：

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

2、若输入算式格式错误，输出结果为“0”。要求实现函数：

void arithmetic(const char *pInputStr, long lInputLen, char *pOutputStr);【输入】 pInputStr：输入字符串

lInputLen：输入字符串长度

【输出】 pOutputStr：输出字符串，空间已经开辟好，与输入字符串等长；【注意】只需要完成该函数功能算法，中间不需要有任何IO的输入输出示例

输入：“4 + 7” 输出：“11” 输入：“4-7” 输出：“-3”

输入：“9 ++ 7” 输出：“0” 注：格式错误 #include #include #include void arithmetic(const char *pInputStr, long lInputLen, char *pOutputStr);void main(){ char str[256];char sr[256];//scanf(“%s”,str);gets(str);printf(“n%sn”,str);int len=strlen(str);arithmetic(str,len,sr);printf(“%sn”,sr);} void arithmetic(const char* pInputStr,long lInputLen,char* pOutputStr)

{

int i,j,num1,num2,result,num_space;

char buffer[4];

bool add,sub;

add=sub=false;

for(i=0,num_space=0;i

{

if(pInputStr[i]==' ')

++num_space;

}

if(2!=num_space)

//空格数非法

{

pOutputStr[0] = '0';

pOutputStr[1] = '';

return;

}

num1=num2=0;

for(i=0;pInputStr[i]!=' ';++i)

{

if(pInputStr[i]>='0'&&pInputStr[i]

num1=num1*10+pInputStr[i]-'0';

else

//第一个操作数中有非法字符

{

pOutputStr[0]='0';

pOutputStr[1]='';

return;

}

for(j=i+1;pInputStr[j]!=' ';++j);

if(1!=j-i-1)

//运算符长度不合法

{

pOutputStr[0]='0';

pOutputStr[1]='';

return;

}

else

//操作符的长度为1

{

if('+'!=pInputStr[i+1]&&'-'!=pInputStr[i+1])

//操作符号非法

{

pOutputStr[0]='0';

pOutputStr[1]='';

return;

}

else

{

if('+'==pInputStr[i+1])

add=true;

if('-'==pInputStr[i+1])

sub=true;

for(i=j+1;i

{

if(pInputStr[i]>='0'&&pInputStr[i]

num2=num2*10+pInputStr[i]-'0';

else

//第二个操作数中有非法字符

{

pOutputStr[0]='0';

pOutputStr[1]='';

return;

}

}//for

if(add)

result=num1+num2;

else if(sub)

result=num1-num2;

memset(buffer,0,sizeof(buffer));

//itoa(result,buffer,10);

//将整数按10进制转换为字符串

sprintf(pOutputStr,“%d”,result);

//strcpy(pOutputStr,buffer);

}//esle

}//else

}

2013校招机试题

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

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

char *temp;

int n,count=0;

n=strlen(sub_str);

temp=(char *)malloc(n+1);

memset(temp,0,n+1);

while(*str)

{

// memcpy(temp,str,n);

strncpy(temp,str,n);

if(strcmp(temp,sub_str)==0)

{

count++;

memset(temp,0,n+1);

str=str+n;

}

else

{

*result=*str;

str++;

result++;

memset(temp,0,n+1);

}

free(temp);

return count;}

void main(){

char s[100]={''};

int num=delete_sub_str(“123abc12de234fg1hi34j123k”,“123”,s);

printf(“The number of sub_str is %drn”,num);

printf(“The result string is %srn”,s);}

2、约瑟夫环是一个数学的应用问题：已知 n 个人（以编号1，2，3...n 分别表示）围坐在一张圆桌周围。从编号为 k 的人开始报数，数到 m 的那个人出列；他的下一个人又从 1 开始报数，数到m 的那个人又出列；依此规律重复下去，直到圆桌周围的人全部出列。#include #include typedef struct Node {

int num;

struct Node *next;}LinkList;

LinkList * creat(int n){

LinkList *p,*q,*head;

int i;

p=(LinkList *)malloc(sizeof(LinkList));

p->num=1;head=p;

for(i=2;i

{

q=(LinkList *)malloc(sizeof(LinkList));

q->num=i;

p->next=q;

p=q;

}

p->next=head;

/*使链表尾指向链表头形成循环链表*/

return head;}

void fun(LinkList *L,int m){

int i;

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;

free(s);

}

printf(“%5dn”,p->num);}

void main(){

LinkList *L;

int n,m;

n=9;m=5;

L=creat(n);

fun(L,m);

} 3.比较一个数组的元素

是否为回文数组 1234321 123 4 321 这个就是回文.“回文”是指正读反读都能读通的句子，它是古今中外都有的一种修辞方式和文字游戏，如“我为人人，人人为我”等。在数学中也有这样一类数字有这样的特征，成为回文数（palindrome number）。

设n是一任意自然数。若将n的各位数字反向排列所得自然数n1与n相等，则称n为一回文数。例如，若n=1234321，则称n为一回文数；但若n=1234567，则n不是回文数。注意：

1.偶数个的数字也有回文数124421 2.小数没有回文数 #include #include void main(){ int i=0,j;char str[100];gets(str);int len=strlen(str);while(i

if(str[i]==str[len-i-1])

{

i++;

}

else

break;} if(i==len/2)

printf(“The %s is huiwen arrayn”,str);else

printf(“The %s is not huiwen arrayn”,str);}

4数组比较（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 函数返回：3 #include #include int array_compare(int len1,int array1[],int len2,int array2[]);void main(){ int n;int a1[]={3,4,5};int len1=3;//int a2[]={1,2,4,5,7};int a2[]={1,2,3,4,5};int len2=5;n=array_compare(len1,a1,len2,a2);printf(“%dn”,n);} int array_compare(int len1, int array1[],int len2,int array2[]){ int i=len1-1,j=len2-1;int m=0;while(i>=0&&j>=0){

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

{

i--;

j--;

}

else

{

i--;

j--;

m++;

}

} return m;}

5、约瑟夫问题

•问题描述：

输入一个由随机数组成的数列（数列中每个数均是大于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 typedef struct Node { int num;struct Node *next;}Linklist;void array_iterate(int len,int input_array[],int m,int output_array[]);Linklist *creatL(int a[],int w);void main(){ int n=4;int array[]={3,1,2,4};int array1[4];int z=7;array_iterate(n,array,z,array1);for(int i=0;i

printf(“%d ”,array1[i]);} printf(“n”);} void array_iterate(int len,int input_array[],int m,int output_array[]){ int i,j=0,t;t=m;Linklist *head,*p,*q,*s;head=creatL(input_array,len);p=head;while(p->next!=p){

for(i=0;i

{

q=p;

p=p->next;

}

output_array[j++]=p->num;

t=p->num;

s=p;

q->next=p->next;

p=q->next;} output_array[j]=p->num;} Linklist *creatL(int a[],int w){ int i;Linklist *p,*q,*L;L=(Linklist *)malloc(sizeof(Linklist));L->num=a[0];p=L;for(i=1;i

q=(Linklist *)malloc(sizeof(Linklist));

q->num=a[i];

p->next=q;

p=q;} p->next=L;return L;}

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

问题描述：我国大陆运营商的手机号码标准格式为：国家码+手机号码，例如：86***。特点如下：

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 =“88***9“

输出：无

返回：3 输入：inMsisdn = “86***9“

输出：无

返回：0 #include #include int verifyMsisdn(char * inMsisdn);void main(){ int n;char str[100];gets(str);n=verifyMsisdn(str);printf(“%dn”,n);} int verifyMsisdn(char * inMsisdn){ int len;len=strlen(inMsisdn);if(len!=13){

return 1;} else {

for(int i=0;i

{

if((inMsisdn[i]'9'))

return 2;

}

if((inMsisdn[0]!='8')||(inMsisdn[1]!='6'))

return 3;

else

return 0;} }

7、使用C语言实现字符串中子字符串的替换描述：编写一个字符串替换函数，如函数名为 StrReplace(char* strSrc, char* strFind, char* strReplace)，strSrc为原字符串，strFind 是待替换的字符串，strReplace 为替换字符串。举个直观的例子吧，如：“ABCDEFGHIJKLMNOPQRSTUVWXYZ”这个字符串，把其中的“RST”替换为“ggg”这个字符串，结果就变成了:ABCDEFGHIJKLMNOPQgggUVWXYZ #include #include void StrReplace(char* strSrc,char* strFind,char* strReplace);void main(){ char str[]=“ABCDEFGHIJKLMN”;char str1[]=“HIJ”;char str2[]=“ggg”;StrReplace(str,str1,str2);printf(“%sn”,str);} void StrReplace(char* strSrc,char* strFind,char* strReplace){ int len1,len2,z,i,j,p;len1=strlen(strSrc);len2=strlen(strFind);

for(i=0;i

p=z=i;j=0;

while(strSrc[p++]==strFind[j++])

{

if(j==len2)

{

for(p=0;p

strSrc[p+z]=strReplace[p];

}

} } }

8.算分数的问题，去掉一个最高分一个最低分，求平均分 #include int average(int a[],int n);void main(){ int m;int b[5]={2,1,4,7,3};m=average(b,5);printf(“%dn”,m);} int average(int a[],int n){ int i,j,temp;int sum=0;for(i=0;i

for(j=0;j

{

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

{

temp=a[j];

a[j]=a[j+1];

a[j+1]=temp;

}

} } for(i=1;i

sum+=a[i];return(sum/(n-2));}

9、简单四则运算

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

1、表达式只含

+,-, *, / 四则运算符，不含括号

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

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

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

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

• 要求实现函数：int calculate(int len,char *expStr)

【输入】int len: 字符串长度；char *expStr: 表达式字符串；

【输出】无

【返回】计算结果

• 示例

1）输入：char *expStr = “1+4*5-8/3”

函数返回：19

2）输入：char *expStr = “8/3*3”

函数返回：6

#include #include int calculate(int len,char *expStr);void main(){ int n;char str[]=“1+4*5-8/3”;//char *str=“1+4*5-8/3”;//注意此处不正确，因为函数calculate中要用指针str对字符串常量进行改变，这是不能改变的，//因为指针str只能代表字符串常量的首地址，没有分配数组空间；

n=calculate(9,str);printf(“%d n”,n);} int calculate(int len,char *expStr){ //先从中缀表达式“1+4*5-8/3”转换为后缀表达式“145*+83/-”

struct

{

char opdata[200];

int top;

}opstack;//定义操作符栈

opstack.top=-1;

int i=0;//遍历字符串的下标

int t=0;//当前后缀表达式的长度

char ch=expStr[i];

while(i

//while(ch!='')

{

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]=='*'||opstack.opdata[opstack.top]=='/'))

{

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

opstack.top--;

t++;

}

opstack.top++;

opstack.opdata[opstack.top]=ch;

break;

default:

expStr[t]=ch;

t++;

break;

}

i++;

ch=expStr[i];

}

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

{

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

opstack.top--;

t++;

}

expStr[t]='';

printf(“%sn”,expStr);

//根据后最表达式计算结果

struct

{

int numeric[200];

int top;

}data;

data.top=-1;

i=0;

ch=expStr[i];

while(ch!='')

{

if(ch>='0'&&ch

{

data.top++;

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

}

else if('+'==ch)

{

int tmp=data.numeric[data.top-1]+data.numeric[data.top];

data.top--;

data.numeric[data.top]=tmp;

}

else if('-'==ch)

{

int tmp=data.numeric[data.top-1]-data.numeric[data.top];

data.top--;

data.numeric[data.top]=tmp;

}

else if('*'==ch)

{

int tmp=data.numeric[data.top-1]*data.numeric[data.top];

data.top--;

data.numeric[data.top]=tmp;

}

else if('/'==ch)

{

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

{

printf(“cannot be zero of the dividen”);

exit(1);

}

int tmp=data.numeric[data.top-1]/data.numeric[data.top];

data.top--;

data.numeric[data.top]=tmp;

}

i++;

ch=expStr[i];

}

return data.numeric[data.top];}

10、选秀节目打分，分为专家评委和大众评委，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 int cal_score(int score[],int judge_type[],int n);void main(){ int s[5]={4,6,3,5,4};int type[5]={1,1,1,1,1};int m=cal_score(s,type,5);printf(“%dn”,m);} int cal_score(int score[],int judge_type[],int n){ int sum1=0,sum2=0;int i,j,p=0,q=0;int average;for(i=0;i

if(judge_type[i]==1)

{

p++;

sum1+=score[i];

}

else

{

q++;

sum2+=score[i];

}

} if(q==0){

average=sum1/p;} else {

average=sum1/p*0.6+sum2/q*0.4;} return average;}

11、给定一个数组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

void sort(int input[], int n, int output[]);void main(){ int input1[]={3,6,1,9,7,8};int output1[6];int m=6;sort(input1,m,output1);for(int i=0;i

printf(“%d ”,output1[i]);printf(“n”);}

//先用简单选择排序

void sort(int input[], int n, int output[]){ int i,j,min,temp;for(i=0;i

min=i;

for(j=i+1;j

{

if(input[j]