华为校招历年机试题目

华为历年笔试题目总结

因最近要参加华为的招聘，便从网上搜集了一些华为笔试历年题目，现总结献给大家，因本人非软件出生，水平有限，仅供参考，若有误处，请海涵。

1、字符串问题

?问题描述：

把一个字符串中的除大写字母、小写字母和数字字符之外的其他字符都去掉，输出新字符串。

?要求实现函数：

void my_string(char* input, char* output)

【输入】char* input，输入的字符串

【输出】char* output，输出的字符串

【返回】无

?示例

输入：inp ut = “A*(BC&De+_fg/*”

输出：output = “ABCDefg”

输入：input = “aB+_9”

输出：output = “aB9”

程序如下：

void my_string(char* input, char* output)

{

int i,j;

i=j=0;

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

{

if((*(input+i)>='A'&&*(input+i)<='Z')||

(*(input+i)>='a'&&*(input+i)<='z')||(*(input+i)>='0'&&*(input+i)<='9'))

{

*(output+j)=*(input+i);

j++;

}

i++;

}

*(output+j+1)='\0';

}

题目描述：

输入一个字符串，将其中大写字母转换为对应小写字母之后的第五个字母，

若原始大写字母为V～Z, 则转换为对应小写字母的值减21。

其他字符不变，输出转换后的字符串。

例如，对于字母A，则转换为小写字母f；若形参是字母W，则转换为小写字母b

要求实现函数：

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

【输入】pInputStr：输入字符串

lInputLen：输入字符串长度

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

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

示例

输入：“Axs3mWss”

输出：“fxs3mbss”

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

{

int i=0;

for(i=0;i

{

if(pInputStr[i]>='A'&&pInputStr[i]<'V')

pOutputStr[i]=pInputStr[i]+'a'-'A'+5;

else if(pInputStr[i]>='V'&&pInputStr[i]<='Z')

pOutputStr[i]=pInputStr[i]+'a'-'A'-21;

else

pOutputStr[i]=pInputStr[i];

}

}

3. 单词统计

题目描述：

输入一段英文文本，用程序统计出现频率最高和最低的两个单词;

英文文本中仅出现这四类字符：空格( )、英文逗号(,)、英文句号(.)、英文大小写字母（a-z、A-Z）

单词之间的分隔符仅考虑这三种：空格( )、英文逗号(,)、英文句号(.);

仅大小写不同的单词算同一个单词；

如果两个单词出现次数相同，则在文本中首次出现的单词优先返回。

返回的单词统一用小写字母返回

例如：

输入字符串“Hello world, i said hello world to the world”，返回“world”,“i”

输入字符串“Somebody like somebody，i do not like it”，返回“somebody”，“i”

要求实现函数：

void WordStat(const char * pInputStr, char * pOutputHotWord, char * pOutputColdWord);

【输入】pInputStr：输入字符串，指向一段英文文本

【输出】pOutputHotWord：输出字符串，返回出现次数最多的单词，该指针所指存储空间已经分配好，且足够大

pOutputColdWord：输出字符串，返回出现次数最少的单词，该指针所指存储空间已经分配好，且足够大

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

示例

输入：“Hello world, i said hello world to the world”

void WordStat(const char * pInputStr, char * pOutputHotWord, char * pOutputColdWord)

{

//分割输入字符串Hello world, i said hello world to the world

struct eng_t chaifen[20];

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

while (pInputStr[i]!='\0')

{

while((pInputStr[i]!='

')&&(pInputStr[i]!=',')&&(pInputStr[i]!='.')&&(pInputStr[i]!='\0'))

{

if(pInputStr[i]>='a'&&pInputStr[i]<='z')

chaifen[j].word[k]=pInputStr[i];

else

chaifen[j].word[k]=pInputStr[i]+'a'-'A';

i++;

k++;

}

if(k>0)

{

chaifen[j].word[k]='\0';

j++;

}

k=0;

i++;

}

//统计重复次数并存入num中

k=0;

int a=0;

for(i=0;i

{

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

{

if(strcmp(chaifen[i].word,chaifen[k].word)==0)

a++;

}

chaifen[i].num=a;

a=0;

}

//查找最大值

int temp1=0,temp2=0;

for(i=0;i

{

if(chaifen[i].num>temp1)

{

temp1=chaifen[i].num;

temp2=i;

}

}

strcpy(pOutputHotWord,chaifen[temp2].word);

//查找最小值

temp1=chaifen[0].num;

for(i=0;i

{

if(chaifen[i].num

{

temp1=chaifen[i].num;

temp2=i;

}

}

strcpy(pOutputColdWord,chaifen[temp2].word);

}

/*手机号码合法性判断（20分）

问题描述：我国大陆运营商的手机号码标准格式为：

国家码+手机号码，例如：8613912345678。

特点如下：1、长度13位；2、以86的国家码打头；

3、手机号码的每一位都是数字。请实现手机号码合法性判断的函数

（注：考生无需关注手机号码的真实性，

也就是说诸如86123123456789这样的手机号码，我们也认为是合法的），

要求：1）如果手机号码合法，返回0；2）如果手机号码长度不合法，返回13）

如果手机号码中包含非数字的字符，返回2；4）如果手机号码不是以86打头的，返回3；

【注】除成功的情况外，以上其他合法性判断的优先级依次降低。也就是说，

如果判断出长度不合法，直接返回1即可，不需要再做其他合法性判断。

要求实现函数：int s int verifyMsisdn(char* inMsisdn)【输入】char* inMsisdn，

表示输入的手机号码字符串。【输出】无【返回】判断的结果，类型为int。

示例输入：inMsisdn = “869123456789“输出：无返回：1输入：

inMsisdn = “88139123456789“输出：无返回：3输入：inMsisdn = “86139123456789“

输出：无返回：

*/

#include

using namespace std;

int verifyMsisdn(char* inMsisdn)

{

int i=0;

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

i++;

if(i!=14)

return 1;

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

{

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

return 2;

}

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

return 3;

return 0;

}

/*

2. 将一个字符串的元音字母复制到另一个字符串，并排序（30分）

问题描述：有一字符串，里面可能包含英文字母（大写、小写）、数字、特殊字符，现在需要实现一函数，

将此字符串中的元音字母挑选出来，存入另一个字符串中，并对字符串中的字母进行从小到大的排序

（小写的元音字母在前，大写的元音字母在后，依次有序）。

说明：1、元音字母是a,e,i,o,u,A,E,I,O,U。

2、筛选出来的元音字母，不需要剔重；最终输出的字符串，小写元音字母排在前面，大写元音字母排在后面，依次有序。

要求实现函数：void sortV owel (char* input, char* output);

【输入】char* input，表示输入的字符串

【输出】char* output，排好序之后的元音字符串。

【返回】无示例

输入：char *input = “Abort!May Be Some Errors In Out System. “输出：char *output =“aeeeooAEIO “

*/

#include

using namespace std;

void sortVowel (char* input, char* output)

{

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

int numlong;

char temp;

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

{

if(*(input+i)=='a'||*(input+i)=='e'||*(input+i)=='i'||

*(input+i)=='o'||*(input+i)=='u'||*(input+i)=='A'||

*(input+i)=='E'||*(input+i)=='I'||*(input+i)=='O'||

*(input+i)=='U')

*(output+j++)=*(input+i);

i++;

}

numlong=j;

for(i=1;i

{

for(k=0;k

{

if(*(output+k)>*(output+k+1))

{

temp=*(output+k);

*(output+k)=*(output+k+1);

*(output+k+1)=temp;

}

}

}

for(i=0,k=0;i

{

if(*(output+k)>='A'&&*(output+k)<='Z')

k++;

}

for(i=0;i

*(output+numlong+i)= *(output+i);

for(i=0;i

*(output+i)=*(output+i+k);

*(output+numlong+1)='\0';

}

/*问题描述：

把一个字符串中的除大写字母、小写字母和数字字符之外的其他字符都去掉，输出新字符串。

要求实现函数：

void my_string(char* input, char* output)

【输入】char* input，输入的字符串

【输出】char* output，输出的字符串

【返回】无

示例

输入：input = “A*(BC&De+_fg/*”

输出：output = “ABCDefg”

输入：input = “aB+_9”

输出：output = “aB9”

*/

#include

using namespace std;

void my_string(char* input, char* output)

{

int i,j;

i=j=0;

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

{

if((*(input+i)>='A'&&*(input+i)<='Z')||

(*(input+i)>='a'&&*(input+i)<='z')||(*(input+i)>='0'&&*(input+i)<='9'))

{

*(output+j)=*(input+i);

j++;

}

i++;

}

*(output+j+1)='\0';

}

2、数组问题

/*对一个数组，将数组中偶数从大到小排序，奇数从小到大排序,

奇数和偶数交叉着放且输出数组第一位放奇数,若奇数和偶数不等长，则把剩下的直接放到数组中。

*/

#include

#include

using namespace std;

void maopaopaixu1(int *ps,int num)//从小到大

{

int i,j;

int temp;

for(i=1;i

{

for(j=0;j

{

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

{

temp=ps[j];

ps[j]=ps[j+1];

ps[j+1]=temp;

}

}

}

}

void maopaopaixu2(int *ps,int num)//从大到小{

int i,j;

int temp;

for(i=1;i

{

for(j=0;j

{

if(ps[j]

{

temp=ps[j];

ps[j]=ps[j+1];

ps[j+1]=temp;

}

}

}

}

void changnum(int *pa,int num)

{

int i;

int j=0;

int oddnum=0,evennum=0;

int *odd=(int *)malloc(num*sizeof(int));

int *even=(int *)malloc(num*sizeof(int));

for(i=0;i

{

if(pa[i]%2==1)

odd[oddnum++]=pa[i];

else

even[evennum++]=pa[i];

}

//排序

maopaopaixu2(even,evennum);

maopaopaixu1(odd,oddnum);

//奇数和偶数交叉着放且输出数组第一位放奇数

int num1;

if((evennum-oddnum)>=0)

num1=(num-(evennum-oddnum))/2;

else

num1=(num-(oddnum-evennum))/2;

for(i=0;i<2*num1;)

{

pa[i++]=odd[j];

pa[i++]=even[j];

j++;

}

if(evennum>num1)

{

for(i=2*num1;i

pa[i]=even[j++];

}

else

{

for(i=2*num1;i

pa[i]=odd[j++];

}

free(odd);

free(even);

}

?问题描述：

在掷骰子游戏中，会根据所掷数字在地图中前进几步，前进完成后需要根据当前地图位置所示的障碍进行相应操作，其中障碍表示：

1）9：无障碍

2）1：停掷一轮，即下轮所掷数字无效；

3）2：后退两步，如果已经到起点不再后退；

4）3：奖励前进一步

如果在游戏过程中，已经走到地图终点，则游戏结束。根据输入的地图数组，和5个骰子数的数组，返回最终玩家前进了多少步。

?要求实现函数：

void dice(int map_len, int* map, int* dice_val, int* output)

【输入】int map_len，地图数组的长度

int* map，地图数组，值表示障碍

int* dice_val，5个骰子数的数组

【输出】int *output，玩家共前进了多少步

【返回】无

注：玩家是从起始位置开始，即地图数组的第一位，骰子数只能是1~6 示例

1）输入：map_len = 15, map = {9,1,9,9,9,2,9,9,9,9,9,9,9,9,9}，dice_val = {1,2,1,3,1}，返回：4

2）输入：map_len = 16, map = {9,9,9,9,9,1,9,3,9,9,2,9,9,9,9,9}，dice_val = {2,1,4,1,6}，返回：15

int dice(int map_len, int* map, int* dice_val, int *output)

{

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

while(i<5||k>map_len)

{

k=k+*(dice_val+i);//走的步数

j=map[k];

if(j==1)

i++;

if(j==2)

k=k-2;

if(k<0)

k=0;

if(j==3)

k=k+1;

i++;

}

if(k>map_len)

k=map_len;

*output=k;

}

/*有一个数组a[N]如a[10]={0,1,2,3,4,5,6,7,8,9}

每隔两个数删除一个数，如0,1,2(删除),3,4,5(删除),6,7,8(删除),9,

到数组尾部回到数组头部继续删除，要求编写一个函数实现实现上述操作，

返回最后一个数的数组下标。

函数接口：int getLast(int iLen)

参数：数组初始元素个数iLen

*/

#include

using namespace std;

int getLast(int iLen)

{

int i,len;

int *s=(int *)malloc(sizeof(int)*iLen);

for(i=0;i

s[i]=i;

len=iLen;

int j=0,k;

while(len>1)

{

if(j+2>len)

j=j-len;

else

j=j+2;

for(k=j;k

{

s[k]=s[k+1];

}

len--;

}

return *s;

}

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

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

judge_type[] 里存储与score[] 数组对应的评委类别，

judge_type[i] == 1，表示专家评委，judge_type[i] == 2，

表示大众评委，n表示评委总数。

打分规则如下：专家评委和大众评委的分数先分别取一个平均分（平均分取整），

然后，总分= 专家评委平均分? *?0.6 + 大众评委* 0.4，总分取整。

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

#include

using namespace std;

int avrscore(int score[],int judge_type[],int n)

{

int i,ex_num,pu_num,ex_avr,pu_avr;

ex_num=pu_num=ex_avr=pu_avr=0;

for(i=0;i

if(judge_type[i]==1)

{

ex_avr+=score[i];

ex_num++;

}

if(judge_type[i]==2)

{

pu_avr+=score[i];

pu_num++;

}

}

if(pu_num==0)

return(ex_avr/ex_num);

else

return (int)(ex_avr/ex_num*0.6+pu_avr/pu_num*0.4);

}

/*2、给定一个数组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}

函数接口void sort(int input[[, int n, int output[])

*/

#include

using namespace std;

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

{

int i,j,temp;

for(i=1;i

{

for(j=0;j

{

if(input[j]

{

temp=input[j];

input[j]=input[j+1];

input[j+1]=temp;

}

}

output[n/2]=input[0];

for(i=1,j=1;i<=n/2;i++,j++)

{

output[n/2-i]=input[j];

j++;

output[n/2+i]=input[j];

}

}

/* 3、操作系统任务调度问题。操作系统任务分为系统任务和用户任务两种。

其中，系统任务的优先级< 50，用户任务的优先级>= 50且<= 255。

优先级大于255的为非法任务，应予以剔除。现有一任务队列task[]，

长度为n，task中的元素值表示任务的优先级，数值越小，优先级越高。

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

（数组中元素的值是任务在task[] 数组中的下标），

并且优先级高的任务排在前面，优先级相同的任务按照入队顺序排列（即先入队的任务排在前面），

数组元素为-1表示结束。例如：task[] = {0, 30, 155, 1, 80, 300, 170, 40, 99}

system_task[] = {0, 3, 1, 7, -1}??? user_task[] = {4, 8, 2, 6, -1}

*/

#include

using namespace std;

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

{

int i,a=0,b=0,j,temp;

int *user_task1=(int*)malloc(num*sizeof(int));

int *system_task1=(int*)malloc(num*sizeof(int));

for(i=0;i

{

if(task[i]<50)

{

system_task[a]=i;

*(system_task1+a)=task[i];

a++;

}

if(task[i]>=50&&task[i]<=255)

{

user_task[b]=i;

*(user_task1+b)=task[i];

b++;

}

}

for(i=1;i

{

for(j=0;j

{

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

{

temp=system_task1[j];

system_task1[j]=system_task1[j+1];

system_task1[j+1]=temp;

temp=system_task[j];

system_task[j]=system_task[j+1];

system_task[j+1]=temp;

}

}

}

system_task[a]=-1;

for(i=1;i

{

for(j=0;j

{

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

{

temp=user_task1[j];

user_task1[j]=user_task1[j+1];

user_task1[j+1]=temp;

temp=user_task[j];

user_task[j]=user_task[j+1];

user_task[j+1]=temp;

}

}

}

user_task[b]=-1;

}

从两个数组的最后一个元素比较两个数组中不同元素的个数，如有array1[5]={77,21,1,3,5}, array2[3]={1,3,5}，从array1[4]与array2[2]比较开始，到array1[2]与array[0]比较结束。这样得出它们不同的元素个数为0，若array1[6]={77,21,1,3,5,7}，那么他们不同的元素为3。

函数原型为int compare_array( int len1, int array1[], int len2, int array2[] );

其中，len1与len2分别为数组array1[]和array2[]的长度，函数返回值为两个数组不同元素的个数。

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

int compare_array(int len1, int array1[], int len2, int array2[])

{

int i;

int num=0;

for(i=0;i

{

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

num++;

}

return num;

}

3、字符计算问题

此问题是难点，我会将问题扩展之后给出更全面的答案

?问题描述：

在软件园开饭店的小明最近很郁闷，经常在进行账目核查时出错，每次的计算结果总是有偏差。小王知道后打算为小明解决这个问题，经过调查发现，问题出现在计算器上，当前的计算器计算方法大部分是：输入数据，输入运算符，再输入数据，立刻给出计算结果，然后不断循环。当计算结束时，如果出现偏差或者数据，无法回顾查看到底是哪一步出错，如果需要再次核查，还需要再全部输入一次，非常耽误时间。小王打算帮老板设计一种新的计算器，能够支持表达式的计算，由于是第一个版本，只需要支持整数的“+，-，*”和“( )”即可, 当然括号内的运算优先级高于括号外，“*”的优先级是高于“+,-”的。

注：输入的表达式字符串长度小于20。且表达式一定是合法的表达式。

?要求实现函数：

void calculate(char* input, int* rel)

【输入】char *input，待计算的表达式

【输出】int* rel，计算结果

【返回】无

?示例

1）输入：input = 5+2-10*2+5

输出：rel = -8

#define maxsize 20

struct astack

{

int top;

int maxtop;

char *data;

};

typedef struct astack*Stack;

void push(char x,Stack s)

{

if(s->top!=s->maxtop)

{

s->top++;

s->data[s->top]=x;

}

}

char pop(Stack s)

{

if(s->top!=-1)

{

s->top--;

return(s->data[(s->top)+1]);

}

}

int compare(char a,char b)

{

if(b=='+'||b=='-'||b=='*')

{ switch(a)

{

case('+'):

return 1;

case('-'):

return 1;

case('*'):

if(b=='*')

return 1;

else

return 0;

}}

else

return 0;

}

void calculate(char* input, int* rel)

{

Stack s1=(struct astack*)malloc(sizeof(struct astack));//创建s1用于储存运算符

Stack s2=(struct astack*)malloc(sizeof(struct astack));//创建s2用于临时存储

s1->data=(char *)malloc(sizeof(char)*maxsize);

s2->data=(char *)malloc(sizeof(char)*maxsize);

s1->top=-1;

s2->top=-1;

s1->maxtop=maxsize;

s2->maxtop=maxsize;

char temp=0;

char temp1,temp2;

int i=0;

int comp;

while(input[i]!='\0')//将元素压入栈中

{

if(input[i]>='0'&&input[i]<='9')//当元素是数字的时候

{

while(input[i]>='0'&&input[i]<='9')//计算数值

{

temp=(input[i]-'0')+temp*10;

i++;

}

push(temp,s2);

temp=0;

}

else if(input[i]=='(')//如果是（时候直接送入s1栈顶

{

push(input[i],s1);

i++;

}

else if(input[i]==')')//若取出的字符是“）”，则将距离S1栈栈顶最近的“

//（”之间的运算符，逐个出栈，依次送入S2栈，此时抛弃“（”

{

while((temp=pop(s1))!='(')

{

push(temp,s2);

}

i++;

temp=0;

}

else

/*若取出的字符是运算符，

则将该运算符与S1栈栈顶元素比较，

如果该运算符优先级大于S1栈栈顶运算符优先级，

则将该运算符进S1栈，否则，将S1栈的栈顶运算符弹出，

送入S2栈中，直至S1栈栈顶运算符低于（不包括等于）

该运算符优先级，则将该运算符送入S1栈。

*/

{

while(compare(input[i],s1->data[s1->top]))

{

temp=pop(s1);

push(temp,s2);

}

push(input[i],s1);

i++;

temp=0;

}

}

//将si中取出压入s2中

while(s1->top!=-1)

{

temp=pop(s1);

push(temp,s2);

}

//对s2逆序存入s1中

while(s2->top!=-1)

{

temp=pop(s2);

push(temp,s1);

}

//对s1中进行计算

while(s1->top!=-1)

{

temp=pop(s1);

if(temp!='+'&&temp!='-'&&temp!='*')

{

push(temp,s2);

}

else

{

temp1=pop(s2);

temp2=pop(s2);

if(temp=='+')

temp1=temp1+temp2;

if(temp=='-')

temp1=temp2-temp1;

if(temp=='*')

temp1=temp1*temp2;

push(temp1,s1);

}

}

*rel=s2->data[0];

}

4、链表问题

2. 逆序链表输出。

题目描述：

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

{

int value;

struct tagListNode *next;

}ListNode;

要求实现函数：