华为笔试题

问题：输入一个字符串，用指针求出字符串的长度。
答案：
#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;
}
问题：使用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);
#define M 100;
void main()
{char s[]=”ABCDEFGHIJKLMNOPQRSTUVWXYZ”;
char s1[]=”RST”;
char s2[]=”ggg”;
StrReplace(s,s1,s2);
printf(“%s\n”,s);
return 0;
}
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;
}
}
}
}
问题：编写一个程序实现功能：将字符串”Computer Secience”赋给一个字符数组，然后从第一个字母开始间隔的输出该串，用指针完成。
答案：
#include
#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;
}
问题：编写一个程序实现功能：将两个字符串合并为一个字符串并且输出，用指针实现。
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;
}
问题：以下函数的功能是用递归的方法计算x的n阶勒让德多项式的值。已有调用语句p（n，x）；编写函数实现功能。递归公式如下：

答案：
#include
float p(int x,int n)
{
float t,t1,t2;
if(n= =0) return 1;
else if(n= =1) return x;
else
{
t1=(2*n-1)*x*p(x,(n-1));
t2=(n-1)*p(x,(n-2));
t=(t1-t2)/n;
return t;
}
}
int main()
{
int x,n;
printf(“input two int (x and n):”);
scanf(“%d%d”,&x,&n);
printf(“%.2f\n”,p(x,n));
return 0;
}
问题：给主函数传递参数实现echo功能：
答案：
#incldue
int main(int argc,char *argv[])
{ int i=1;
while( i < argc )
{printf(“%s ”，argv[i]);
i++;
}
printf(“\n”);
return 0;
}
1. 数组比较（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
函数返回：3
2） 输入：int array1[] = {1,3,5}，int len1 = 3，int array2[] = {77,21,1,3,5,7}，int len2 = 6
函数返回：0
答案：
#include
#include
#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);
printf(“the result is %d”, result);
}
约瑟夫环是一个数学的应用问题：已知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=1;
p=(LinkList *)malloc(sizeof(LinkList));
p->num=i;
head=p;
for(i=2;i<=n;i++)
{
q=(LinkList *)malloc(sizeof(LinkList)); /*Malloc()向系统申请分配指定size个字节的内存空间。返回类型是 void* 类型。void* 表示未确定类型的指针。C,C++规定，void* 类型可以强制转换为任何其它类型的指针。*/
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; /*使p指向新的起点*/
free(s);/*free()与malloc()函数配对使用，释放malloc函数申请的动态内存*/
}
printf(“%5d\n”,p->num);
}
int main()
{
LinkList *L;
int n, m;
n=9;
m=5;
L=creat(n);
fun(L,m);
return 0;
}
手机号码合法性判断（20分）
问题描述：我国大陆运营商的手机号码标准格式为：国家码+手机号码，例如：8613912345678。特点如下：
1、 长度13位；
2、 以86的国家码打头；
3、 手机号码的每一位都是数字。
请实现手机号码合法性判断的函数要求：
1） 如果手机号码合法，返回0；
2） 如果手机号码长度不合法，返回1
3） 如果手机号码中包含非数字的字符，返回2；
4） 如果手机号码不是以86打头的，返回3；
【注】除成功的情况外，以上其他合法性判断的优先级依次降低。也就是说，如果判断出长度不合法，直接返回1即可，不需要再做其他合法性判断。
要求实现函数：int s int verifyMsisdn(char* inMsisdn)
【输入】 char* inMsisdn，表示输入的手机号码字符串。
【输出】 无
【返回】 判断的结果，类型为int。
示例
输入： inMsisdn = “869123456789“
输出： 无
返回： 1
输入： inMsisdn = “88139123456789“
输出： 无
返回： 3
输入： inMsisdn = “86139123456789“
输出： 无
返回： 0
答案：
#include
#include
#include
#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=3;
int result;
switch(ichar)
{
case 0:
pchar="8612345363789";break;
case 1:
pchar="861111111111111";break;
case 2:
pchar="86s1234536366"; break;
case 3:
pchar="1392222222222";break;
default:
break;
}
result =verifyMsisdn(pchar);
printf("result is %d\n",result);
return 0;
}
约瑟夫问题问题描述：输入一个由随机数组成的数列（数列中每个数均是大于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;
LinkList *creat(int len , int input_array[])
{
LinkList *h,*s,*p;
int i;
h=(LinkList*)malloc(sizeof(LinkList));
h->num=input_array[0];
p=h;
for(i=1;i {
s=(LinkList*)malloc(sizeof(LinkList));
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)
{
LinkList *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]);
}
printf("\n");
}
int main()
{
int input_array[]={3,1,2,4};
int len=4;
int m=7;
array_iterate(len, input_array, m);
return 0;
}
问题：比较一个数组的元素 是否为回文数组
答案：
#include
#include
void 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);
}
main()
{
char str[100] = {0};
int i;
int len;
printf("Input a string："); /*提示输入Input a string：*/
scanf("%s", str); /*scan()函数输入一个字符串：*/
huiwen(str);
return 0;
}
选秀节目打分，分为专家评委和大众评委，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 "iostream"
using namespace std;
int cal_score(int score[], int judge_type[], int n)
{
if(NULL==score||NULL==judge_type||0==n) return 0;
int sum=0;
int sum1=0,count1=0;
int sum2=0,count2=0;
for(int i=0;i{
if (judge_type[i]==1)
{
sum1=sum1+score[i];
count1++;
}
else
{
sum2=sum2+score[i];
count2++;
}
}
if(0==count2) sum=sum1/count1;
else sum=(sum1/count1)*0.6+(sum2/count2)*0.4;
return sum;
}
void main()
{
int score[3]={12,13,15};
int judge_type[3]={1,1,2};
printf("%d\n",cal_score(score, judge_type, 3) );
}
问题：给定一个数组 input[] ，如果数组长度 n 为奇数，则将数组中最大的元素放到 output[] 数组最中间的位置，如果数组长度 n 为偶数，则将数组中最大的元素放到 output[] 数组中间两个位置偏右的那个位置上，然后再按从大到小的顺序，依次在第一个位置的两边，按照一左一右的顺序，依次存放剩下的数。
例如：input[] = {3, 6, 1, 9, 7} output[] = {3, 7, 9, 6,
input[] = {3, 6, 1, 9, 7, 8} output[] = {1, 6, 8, 9, 7, 3}
函数接口 void sort(int input[], int n, int output[])
答案：
#include "iostream"
using namespace std;
void bubblesort(int data[],int n)
{
int temp=0;
for(int i=0;i{
for(int j=i+1;j {
if (data[i] {
temp=data[i];
data[i]=data[j];
data[j]=temp;
}
}
}
}

void sort(int input[], int n, int output[])
{
int *sort_input=new int[n];
for(int i=0;i{
sort_input[i]=input[i];
}
bubblesort(sort_input,n);
if(1==n%2)
{
int mid=n/2;
int k=0;
output[mid]=sort_input[k++];
for(int j=1;j<=n/2;j++)
{
output[mid-j]=sort_input[k++];
output[mid+j]=sort_input[k++];
}
}
else
{
int mid=n/2;
int k=0;
output[mid]=sort_input[k++];
for(int j=1;j{
output[mid-j]=sort_input[k++];
output[mid+j]=sort_input[k++];
}
output[0]=sort_input[k++];

}

delete sort_input;
}
void main()
{
int input1[] = {3, 6, 1, 9, 7};
int output1[5];
memset(output1,0,5*sizeof(int));
int input2[] = {3, 6, 1, 9, 7, 8} ;
int output2[6];
memset(output2,0,6*sizeof(int));
sort(input1, 5, output1);
sort(input2, 6, output2);
for(int k=0;k<5;k++)
printf("%d",output1[k]);
printf("\n");
for(k=0;k<6;k++)
printf("%d",output2[k]);
printf("\n");
}
删除字符串中所有给定的子串问题描述：在给定字符串中查找所有特定子串并删除，如果没有找到相应子串，则不作任何操作。
要求实现函数： int delete_sub_str(const char *str, const char *sub_str, char *result_str)
【输入】 str：输入的被操作字符串
sub_str：需要查找并删除的特定子字符串 【输出】 result_str：在str字符串中删除所有 sub_str子字符串后的结果
【返回】 删除的子字符串的个数
答案：
#include
#include
int delete_sub_str(const char *str, const char *sub_str, char *result_str)
{
int count=0;
int k=0,j=0;
int tem;
int n=strlen(sub_str);
while (str[k]!=’\0′)
{
tem=k;
for(int i=0;i{
if(sub_str[i]==str[k]) k++;
else
{
break;
}
}
if(i==n) count++;
else
{
result_str[j++]=str[tem];
k=tem+1;
}
}
result_str[j]='\0';
return count;
}
int main()
{
char *str="aaadbaadcd";
char *sub="aad";
char res[50]="";
int count=delete_sub_str(str,sub,res);
printf("子字符串的个数是：%d\n",count);
printf("删除子字符串后：%s\n",res);
return 0;
}
操作系统任务调度问题。操作系统任务分为系统任务和用户任务两种。其中，系统任务的优先级 < 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 "iostream"
using namespace std;
void change(int *a,int *b)
{
int temp=*a;
*a=*b;
*b=temp;
}
void bubblesort(int data[],int n,int index[])//冒泡排序并记录排序后下标
{
int temp=0;
for(int j=0;j index[j]=j;
for(int i=0;i{
for (int j=i+1;j {
if(data[i]>data[j])
{
change(&data[i],&data[j]);
change(&index[i],&index[j]);
}
}
}
}
void scheduler(int task[], int n, int system_task[], int user_task[])
{
int *sort_task=new int[n];
int *index=new int[n];
for(int i=0;i{
sort_task[i]=task[i];
}
bubblesort(sort_task,n,index);
i=0;
while(sort_task[i]<50)
{
system_task[i]=index[i];
i++;
}
system_task[i]=-1;
for(int m=0;m<=i;m++)
{
printf("%d ",system_task[m]);}
printf("\n");
int k=0;
while(sort_task[i]>50&&sort_task[i]<=255)
{
user_task[k++]=index[i++];
}
user_task[k]=-1;
for(int l=0;l<=k;l++)
{
printf("%d ",user_task[l]);}
printf("\n");
delete sort_task;
delete index;
}
void main()
{
int task[] = {0, 30, 155, 1, 80, 300, 170,40,99};
int n=sizeof(task)/sizeof(int);
int *system_task=new int[n];
int *user_task=new int[n];
scheduler(task, n, system_task, user_task);
}
简单四则运算问题描述：输入一个只包含个位数字的简单四则运算表达式字符串，计算该表达式的值
注：
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
#include “assert.h”
struct stack
{//存放后续排列的表达式，模拟栈
char str[80];
int top;
};
struct sstack
{//存放计算表达式的值，模拟栈???
int str[80];
int top;
};
int calculate(int len,char *expStr)
{
char *postexp=new char[len+1];
stack opstack;
sstack calstack;
calstack.top=-1;
opstack.top=-1;
int i=0;
int k=0;
while(expStr[i]!=’\0′)
{
if (expStr[i]>=’0′&&expStr[i]<='9')
{
postexp[k++]=expStr[i];
}
else if(expStr[i]=='+'||expStr[i]=='-')
{
while(opstack.top>=0)
{
postexp[k++]=opstack.str[opstack.top--];
}
opstack.top++;
opstack.str[opstack.top]=expStr[i];
}
else if(expStr[i]==’*'||expStr[i]==’/')
{
while(opstack.top>=0&&(opstack.str[opstack.top]==’*’
||opstack.str[opstack.top]==’/'))
{
postexp[k++]=opstack.str[opstack.top--];
}
opstack.top++;
opstack.str[opstack.top]=expStr[i];
}
i++;
}
while(opstack.top>=0)
{
postexp[k++]=opstack.str[opstack.top--];
}
int temp1=0;
int temp2=0;
for(i=0;i{
if(postexp[i]>=’0′&&postexp[i]<='9')
{
calstack.top++;
calstack.str[calstack.top]=postexp[i]-'0';
}
else if(postexp[i]=='+')
{
temp1=calstack.str[calstack.top--];
temp2=calstack.str[calstack.top];
calstack.str[calstack.top]=temp2+temp1;
}
else if(postexp[i]=='-')
{
temp1=calstack.str[calstack.top--];
temp2=calstack.str[calstack.top];
calstack.str[calstack.top]=temp2-temp1;
}
else if(postexp[i]=='*')
{
temp1=calstack.str[calstack.top--];
temp2=calstack.str[calstack.top];
calstack.str[calstack.top]=temp2*temp1;
}
else if(postexp[i]=='/')
{
temp1=calstack.str[calstack.top--];
temp2=calstack.str[calstack.top];
calstack.str[calstack.top]=temp2/temp1;
}
}
printf("%d\n",calstack.str[calstack.top]);
return calstack.str[calstack.top];
}
main()
{
char *expStr = "6+8*4-9/2";
int len=strlen(expStr);
calculate(len,expStr);
return 0;
}
德州扑克问题：一副牌中发五张扑克牌给你：让你判断数字的组成：
有以下几种情况：
1：四条：即四张一样数值的牌（牌均不论花色）2：三条带 一对
3：三条带两张不相同数值的牌
4：两对
5：顺子 包括 10，J，Q，K，A
6：什么都不是
7：只有一对
答案：
#include "stdio.h"
void sort(int data[],int n)
{
int temp=0;
for(int i=0;i{
for(int j=i+1;j {
if(data[i] {
temp=data[i];
data[i]=data[j];
data[j]=temp;
}
}
}
}
void test(int a[],int len)
{
int *b=new int[len];
int count=0;
bool temp=false;
for(int i=0;i{
b[i]=a[i];
}
sort(b,5);
for(i=0;i{
if(b[i]==b[i+1])
count++;
}
switch (count)
{
case 0:
if (b[0]-b[4]==4&&b[0]-b[3]==3&&b[0]-b[2]==2&&b[0]-b[1]==1)
{
printf("顺子");
}
else
printf("什么都不是");
break;
case 1:
printf("只有一对");
break;
case 2:
for(i=0;i<3;i++)
{
if(b[i]==b[i+2])
{
printf("三条带两张不相同数值的牌");
temp=true;
break;
}
}
if(!temp)
{
printf("两对");
}
break;
case 3:
if(b[1]==b[3])
printf("四条：即四张一样数值的牌");
else
printf("三条带一对");
break;
}
}
main()
{
int a[5]={3,3,3,3,12};
test(a,5);
return 0;
}
删除数组中的重复元素
#include
using namespace std;
int de(int a[],int n)
{
for (int i=0;i for (int j=i+1;jif (a[j]==a[i])
{
for (int k=j;k a[k]=a[k+1];
n--;
}
for ( i=0;i cout< cout< return 0;
}

int main ()
{int a[10];
int m=10;
for (int l=0;l<10;l++)
cin>>a[l];
de(a,m);
return 0;
}
链表逆序：
node *reverse(node *head)
{
node *p1,*p2,*p3;
if(head==NULL||head->next)
return head;
p1 = head,p2 = p1->next;
while(p2)
{
p3=p2->next;
p2->next=p1;
p1=p2;
p2=p3;
}
head->next = NULL;
head = p1;
return head;
}