2021年华为实习工程师面试题

小编:管理员 978阅读 2021.06.22

第1题：

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

#include

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

{

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

const char *p,*q;

char *t,*temp;

p = str;

q = sub_str;

t = result;

int n,count = 0;

n = strlen(q);

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

memset(temp,0x00,n+1);

while(*p)

{

memcpy(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);

return count;

}

int 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);

}

第2题：

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

#include

typedef struct Node

{

int num;

struct Node *next;

}LinkList;

LinkList *creat(int n)

{

LinkList *p,*q,*head;

int i=1;

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

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("%5d\n",p->num);

}

int main()

{

LinkList *L;

int n, m;

n=9;

m=5;

L=creat(n);

fun(L,m);

return 0;

}

第3题：

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

#include

int huiwen(char str[])

{

int i,len,k=1;

len=strlen(str);

for(i=0;i

{

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

{

k=1;

break;

}

if(k==0)

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

else

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

}

void main()

{

char str[100] = {0};

int i;

int len;

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

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

huiwen(str);

}

第4题：

比较两个数组，要求从数组最后一个元素开始逐个元素向前比较，如果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

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

{

int count=0;

for( ;len1>=0&&len2>=0 ;len1--,len2--)

{

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

{

count++;

}

return count;

}

int main()

{

int result=0;

int array1[]={1,3,5};

int len1=3;

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

int len2=5;

result=array_compare( len1, array1, len2, array2); ///result=array_compare( len1, array1[], len2, array2[]);不能这样

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

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

}

第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

typedef struct Node

{

int num;

struct node *next;

} node;

node *creat(int len , int input_array[])

{

node *h,*s,*p;

int i;

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

h->num=input_array[0];

p=h;

for(i=1;i

{

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

s->num=input_array[i];

p->next=s;

p=s;

}

p->next=h;

return (h);

}

void array_iterate(int len, int input_array[], int m)

{

node *q,*p,*s;

int i=0,j=0,k;

int output_array[4];

p=creat(len,input_array);

while(p->next!=p)

{

for(i=1;i

{

q=p;

p=p->next;

}

m=p->num;

printf("%5d",m);

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

{

printf("%5d",output_array[j]);

}

int main()

{

int input_array[]={3,1,2,4};

int len=4;

int m=7;

int output_array[4];

array_iterate(len, input_array, m, output_array);

}

第6题：

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

1、长度13位；

2、以86的国家码打头；

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

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

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

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

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

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

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

l 要求实现函数：

int verifyMsisdn(char* inMsisdn)

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

【输出】无

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

l 示例

输入： inMsisdn = “869123456789“

输出：无

返回： 1

输入： inMsisdn = “88139123456789“

输出：无

返回： 3

输入： inMsisdn = “86139123456789“

输出：无

返回： 0

#include

#define LENGTH 13

int verifyMsisdn(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

return 2 ;

}

else

return 3;

}

else

return 1;

return 0;

}

int main()

{

char *pchar=NULL;

unsigned char ichar=0;

int result;

switch(ichar)

{

case 0:

pchar="8612345363789";break;

case 1:

pchar="861111111111111";break;

case 2:

pchar="86s1234536366"; break;

default:

break;

}

result =verifyMsisdn(pchar);

printf("result is %d\n",result);

}

第7题：

比较两个数组，要求从数组最后一个元素开始逐个元素向前比较，如果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

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

{

int count=0;

for( ;len1>=0&&len2>=0 ;len1--,len2--)

{

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

{

count++;

}

return count;

}

int main()

{

int result=0;

int array1[]={1,3,5};

int len1=3;

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

int len2=5;

result=array_compare(len1, array1, len2, array2);

///result=array_compare( len1, array1[], len2, array2[]);不能这样

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

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

}

第8题：

问题描述：输入一个只包含个位数字的简单四则运算表达式字符串，计算该表达式的值
注： 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

* author by wanww

* time: 2021-09-07

using namespace std;

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

{

if(len1 == len2) {

int count = 0;

for (int i=0;i

{

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

}

return count;

} else if(len1

return array_compare(len1, array1,len1,array2+len2-len1);

} else {

return array_compare(len2,array1+len1-len2,len2,array2);

}

void array_iterate(int len, int input_array[], int m,int output_array[])

{

int * flag = new int[len];

memset(flag,0,len*4);

int hasout=0; //已经出列的数字个数

int start = 0; //开始的下标号

int j=0; //当前以报到的数字

while(true)

{

if(flag[start] == 0) //当前元素还没出列

{

j++;

if(j==m) //已经计数到m,当前start下标的元素出列

{

output_array[hasout] = input_array[start];

flag[start] = 1; //标记当前元素已经出列

hasout ++;

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

//初始化下一轮的数字

j = 0;

m = input_array[start];

}

start ++;

if(start==len) start = 0;

}

delete [] flag;

}

int calculate(int len,char *expStr)

{

struct {

char opdata[200];

int top;

}opstack;

//定义操作符栈

opstack.top = -1;

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

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

char ch = 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] =='*' || 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]='\0';

struct {

int numeric[200];

int top;

}data;

data.top = -1;

i=0;

ch = expStr[i];

while (ch!='\0')

{

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

{

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 divide\n");

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];

}

void main()

{

int array1[] = {1,3,5};

int len1 = 3;

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

int len2 = 6;

int count = array_compare(sizeof(array1)/sizeof(int),array1,sizeof(array2)/sizeof(int),array2);

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

printf("*****************************************************\n");

int input_array[] = {3,1,2,4};

int len = 4;

int m=7;

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

array_iterate(4,input_array,7,output_array);

for (int i=0;i

{

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

}

delete [] output_array;

printf("\n*****************************************************\n");

char expStr[] = "8/3*3";

int result = calculate(strlen(expStr),expStr);

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

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

}

第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

#define N 5

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

{

int expert=0;

int dazhong=0;

int zongfen=0;

int i;

int number=0;

for(i=0;i

{

if(judge_type[i]==1)

{

expert=expert+score[i];

number++;

}

else dazhong=dazhong+score[i];

}

if(number==N)

{

zongfen=(int)(expert/N);

}

else

{

expert=(int)(expert/number);

dazhong=(int)(dazhong/(N-number));

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

}

return zongfen;

}

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

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

{

int i,j;

int k=1;

int temp;

int med;

for(i=0;i

for(j=0;j

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

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

if(n%2!=0)

{

for(i=0;i

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

printf("\n");

med=(n-1)/2;

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

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

{

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

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

k=k+2;

}

else

{

for(i=0;i

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

printf("\n");

med=n/2;

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

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

{

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

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

k=k+2;

}

output[0]=input[0];

}

for(i=0;i

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

printf("\n");

}

int main()

{

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

int b[6]={0};

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

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

printf("\n");

sort(a,6,b);

return 0;

}

第11题：

操作系统任务调度问题。操作系统任务分为系统任务和用户任务两种。其中，系统任务的优先级 < 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}

函数接口 void scheduler(int task[], int n, int system_task[], int user_task[])

#include

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

{

int i;

int j=0;

int *p,*pp,*p_user,*pp_user;

int index=0;

int count,count2;

int min=0;

int k=0;

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

for(i=0;i

p[i]=0;

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

for(i=0;i

pp[i]=0;

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

for(i=0;i

p_user[i]=0;

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

for(i=0;i

pp_user[i]=0;

for(i=0;i

{

if(task[i]<50)

{

system_task[j]=task[i];

pp[j]=i;

j++;

}

count=j;

}

else if(task[i]<=255)

{

user_task[k]=task[i];

pp_user[k]=i;

k++;

}

count2=k;

}

else task[i]=task[i];

}

for(i=0;i

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

printf("\n");

for(i=0;i

{

min=system_task[0];

for(j=1;j

{

if(system_task[j]

{

min=system_task[j];

p[i]=j;

}

system_task[p[i]]=51;

}

pp[count]=-1;

for(i=0;i

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

printf("%3d\n",pp[count]);

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

for(i=0;i

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

printf("\n");

for(i=0;i

{

min=user_task[0];

for(j=1;j

{

if(user_task[j]

{

min=user_task[j];

p_user[i]=j;

}

user_task[p_user[i]]=256;

}

pp_user[count2]=-1;

for(i=0;i

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

printf("%3d\n",pp_user[count2]);

}

int main()

{

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

int system_task[9]={0};

int user_task[9]={0};

scheduler1(task,9,system_task,user_task);

return 0;

}

第12题：

从两个数组的最后一个元素比较两个数组中不同元素的个数，如有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[]的长度，函数返回值为两个数组不同元素的个数。

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

//diff_num.cpp

#include

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

{

int i,t,small,num=0;

//把两数组倒置

for(i=0;i

{

t=array1[i];

array1[i]=array1[len1-i-1];

array1[len1-i-1]=t;

}

for(i=0;i

{

t=array2[i];

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

array2[len2-i-1]=t;

}

//输出倒置后的两数组

/* for(i=0;i

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

printf("\n");

for(i=0;i

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

*/ printf("\n");

if(len1>len2)

small=len2;

else

small=len1;

num=small;

for(i=0;i

{

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

num--;

}

printf("num=%d\n",num);

return num;

}

void main()

{

int array1[5]={77,21,1,3,5},array2[3]={1,3,5};

int len1=5,len2=3;

compare_array(len1,array1,len2,array2);

}

第13题：

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

#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;

}

第14题：

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

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

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

ABCDEFGHIJKLMNOPQgggUVWXYZ

答案一：

#include

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

#define M 100;

void main()

{char s[]="ABCDEFGHIJKLMNOPQRSTUVWXYZ";

char s1[]="RST";

char s2[]="ggg";

StrReplace(s,s1,s2);

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

}

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

{

int i=0;

int j;

int n=strlen(strSrc);

int k=strlen(strFind);

for(i=0;i

{

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

{

for(j=0;j

{

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

{

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

}

else continue;

}

答案二：

#include

#define MAX 100

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

char *p;

for(; *s; s++) {

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

if(*p) *s = *(p - s1 + s2);

}

int main()

{

char s[MAX]; //s是原字符串

char s1[MAX], s2[MAX]; //s1是要替换的

//s2是替换字符串

puts("Please input the string for s:");

scanf("%s", s);

puts("Please input the string for s1:");

scanf("%s", s1);

puts("Please input the string for s2:");

scanf("%s", s2);

StrReplace(s, s1, s2);

puts("The string of s after displace is:");

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

return 0;

}

答案三：

#include

#define M 100

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

int main()

{

char s[]="ABCDEFGHIJKLMNOPQRSTUVWXYZ";

char s1[]="RST";

char s2[]="gggg";

StrReplace(s,s1,s2);

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

return 0;

}

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

{

while(*strSrc != '\0')

{

if(*strSrc == *strFind)

{

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

{

int i = strlen(strFind);

int j = strlen(strReplace);

printf("i = %d,j = %d\n",i,j);

char *q = strSrc + i;

printf("*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题：

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

#include

int main()

{

char str[]=”Computer Science”;

int flag=1;

char *p=str;

while(*p)

{

if ( flag )

{

printf(“%c”,*p);

}

flag = (flag + 1) % 2;

p++;

}

printf(“\n”);

return 0;

}

第16题：

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

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

ABCDEFGHIJKLMNOPQgggUVWXYZ

答案一：

#include

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

#define M 100;

void main()

{char s[]="ABCDEFGHIJKLMNOPQRSTUVWXYZ";

char s1[]="RST";

char s2[]="ggg";

StrReplace(s,s1,s2);

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

}

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

{

int i=0;

int j;

int n=strlen(strSrc);

int k=strlen(strFind);

for(i=0;i

{

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

{

for(j=0;j

{

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

{

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

}

else continue;

}

答案二：

#include

#define MAX 100

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

char *p;

for(; *s; s++) {

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

if(*p) *s = *(p - s1 + s2);

}

int main()

{

char s[MAX]; //s是原字符串

char s1[MAX], s2[MAX]; //s1是要替换的

//s2是替换字符串

puts("Please input the string for s:");

scanf("%s", s);

puts("Please input the string for s1:");

scanf("%s", s1);

puts("Please input the string for s2:");

scanf("%s", s2);

StrReplace(s, s1, s2);

puts("The string of s after displace is:");

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

return 0;

}

答案三：

#include

#define M 100

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

int main()

{

char s[]="ABCDEFGHIJKLMNOPQRSTUVWXYZ";

char s1[]="RST";

char s2[]="gggg";

StrReplace(s,s1,s2);

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

return 0;

}

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

{

while(*strSrc != '\0')

{

if(*strSrc == *strFind)

{

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

{

int i = strlen(strFind);

int j = strlen(strReplace);

printf("i = %d,j = %d\n",i,j);

char *q = strSrc + i;

printf("*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++;

}

第17题：

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

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

#include

int main()

{

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

char *p=str1, *q=str2;

while( *p ) p++;

while( *q )

{

*p = *q;

p++;

q++;

}

*p = ‘\0’;

printf(“%s\n”, str1);

return 0;

}

第18题：

算分数的问题，去掉一个最高分一个最低分，求平均分

#include

float avescore(float score[],int n)

{

float min=0;

float max=0;

int minindex=0;

int maxindex=0;

float sum=0;

min=score[0];

for(int i=0;i

if(score[i]

{

min=score[i];

minindex=i;

}

score[minindex]=0;

max=score[0];

for(i=0;i

if(score[i]>max)

{

max=score[i];

maxindex=i;

}

score[maxindex]=0;

for(i=0;i

sum+=score[i];

sum=sum/(n-2);

return sum;

}

void main()

{

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

float lastscore;

lastscore=avescore(score,6);

printf("the last score is :%5.2f\n",lastscore);

}

运行结果：

the last score is :85.75

第19题：

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

思路：先进行奇偶判断，得到奇数和偶数数组。然后对两数组排序，进行长度判断，最后组织数据。

#include

void jiou(int a[],int n)

{

int *p1;

int *p2;

int i,j;

int k=0;

int kk=0;

int count1=0;

int count2=0;

int temp;

int temp2;

int m=0;

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

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

for(i=0;i

{

p1[i]=0;

p2[i]=0;

}

for(i=0;i

{

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

{p2[kk++]=a[i];}

else

{p1[k++]=a[i];}

}

count1=k;

count2=kk;

for(i=0;i

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

printf("\n");

for(i=0;i

for(j=0;j

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

{temp2=p2[j];p2[j]=p2[j+1];p2[j+1]=temp2;}

for(i=0;i

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

printf("\n");

for(i=0;i

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

printf("\n");

for(i=0;i

for(j=0;j

if(p1[j]

{temp=p1[j];p1[j]=p1[j+1];p1[j+1]=temp;}

for(i=0;i

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

printf("\n");

if(count1>count2)

{

for(i=0;i

{

a[i+m]=p2[i];

a[i+1+m]=p1[i];

m=m+1;

}

for(i=0;i

a[2*count2+i]=p1[i+count2];

}

else

{

for(i=0;i

{

a[i+m]=p2[i];

a[i+1+m]=p1[i];

m=m+1;

}

for(i=0;i

a[2*count1+i]=p2[i+count1];

}

for(i=0;i

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

printf("%\n");

}

void main()

{

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

jiou(a,10);

}

运行结果：
3 15 11
3 11 15
2 14  6  2 12 14  4
14 14 12  6  4  2  2
3 14 11 14 15 12  6  4  2  2

第20题：

#include

* author by wanww

* time: 2021-09-07

using namespace std;

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

{

if(len1 == len2) {

int count = 0;

for (int i=0;i

{

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

}

return count;

} else if(len1

return array_compare(len1, array1,len1,array2+len2-len1);

} else {

return array_compare(len2,array1+len1-len2,len2,array2);

}

void array_iterate(int len, int input_array[], int m,int output_array[])

{

int * flag = new int[len];

memset(flag,0,len*4);

int hasout=0; //已经出列的数字个数

int start = 0; //开始的下标号

int j=0; //当前以报到的数字

while(true)

{

if(flag[start] == 0) //当前元素还没出列

{

j++;

if(j==m) //已经计数到m,当前start下标的元素出列

{

output_array[hasout] = input_array[start];

flag[start] = 1; //标记当前元素已经出列

hasout ++;

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

//初始化下一轮的数字

j = 0;

m = input_array[start];

}

start ++;

if(start==len) start = 0;

}

delete [] flag;

}

int calculate(int len,char *expStr)

{

struct {

char opdata[200];

int top;

}opstack;

//定义操作符栈

opstack.top = -1;

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

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

char ch = 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] =='*' || 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]='\0';

struct {

int numeric[200];

int top;

}data;

data.top = -1;

i=0;

ch = expStr[i];

while (ch!='\0')

{

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

{

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 divide\n");

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];

}

void main()

{

int array1[] = {1,3,5};

int len1 = 3;

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

int len2 = 6;

int count = array_compare(sizeof(array1)/sizeof(int),array1,sizeof(array2)/sizeof(int),array2);

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

printf("*****************************************************\n");

int input_array[] = {3,1,2,4};

int len = 4;

int m=7;

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

array_iterate(4,input_array,7,output_array);

for (int i=0;i

{

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

}

delete [] output_array;

printf("\n*****************************************************\n");

char expStr[] = "8/3*3";

int result = calculate(strlen(expStr),expStr);

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

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

}

第21题：

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

#include

#define N 5

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

{

int expert=0;

int dazhong=0;

int zongfen=0;

int i;

int number=0;

for(i=0;i

{

if(judge_type[i]==1)

{

expert=expert+score[i];

number++;

}

else dazhong=dazhong+score[i];

}

if(number==N)

{

zongfen=(int)(expert/N);

}

else

{

expert=(int)(expert/number);

dazhong=(int)(dazhong/(N-number));

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

}

return zongfen;

}

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;

}

第22题：

例如：

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

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

{

int i,j;

int k=1;

int temp;

int med;

for(i=0;i

for(j=0;j

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

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

if(n%2!=0)

{

for(i=0;i

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

printf("\n");

med=(n-1)/2;

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

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

{

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

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

k=k+2;

}

else

{

for(i=0;i

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

printf("\n");

med=n/2;

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

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

{

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

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

k=k+2;

}

output[0]=input[0];

}

for(i=0;i

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

printf("\n");

}

int main()

{

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

int b[6]={0};

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

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

printf("\n");

sort(a,6,b);

return 0;

}

第23题：

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

user_task[] = {4, 8, 2, 6, -1}

函数接口 void scheduler(int task[], int n, int system_task[], int user_task[])

#include

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

{

int i;

int j=0;

int *p,*pp,*p_user,*pp_user;

int index=0;

int count,count2;

int min=0;

int k=0;

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

for(i=0;i

p[i]=0;

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

for(i=0;i

pp[i]=0;

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

for(i=0;i

p_user[i]=0;

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

for(i=0;i

pp_user[i]=0;

for(i=0;i

{

if(task[i]<50)

{

system_task[j]=task[i];

pp[j]=i;

j++;

}

count=j;

}

else if(task[i]<=255)

{

user_task[k]=task[i];

pp_user[k]=i;

k++;

}

count2=k;

}

else task[i]=task[i];

}

for(i=0;i

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

printf("\n");

for(i=0;i

{

min=system_task[0];

for(j=1;j

{

if(system_task[j]

{

min=system_task[j];

p[i]=j;

}

system_task[p[i]]=51;

}

pp[count]=-1;

for(i=0;i

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

printf("%3d\n",pp[count]);

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

for(i=0;i

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

printf("\n");

for(i=0;i

{

min=user_task[0];

for(j=1;j

{

if(user_task[j]

{

min=user_task[j];

p_user[i]=j;

}

user_task[p_user[i]]=256;

}

pp_user[count2]=-1;

for(i=0;i

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

printf("%3d\n",pp_user[count2]);

}

int main()

{

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

int system_task[9]={0};

int user_task[9]={0};

scheduler1(task,9,system_task,user_task);

return 0;

}

全国[切换]∨

首页

找工作

找人才

找兼职

查企业

查工资

看趋势

职场知识

百科

更多>

2021年华为实习工程师面试题

小编:管理员 978阅读 2021.06.22

关联标签：

QQ客服

E-mail:market#hunt007.cn