华为上机-字符串相关题目

最新推荐文章于 2025-06-08 19:51:26 发布
转载 最新推荐文章于 2025-06-08 19:51:26 发布 · 1.6k 阅读 · 3

华为校园招聘机考试题总结（软件）

 

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

#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "assert.h"
//函数：在sub字符串中删除substr子串
int DeleteSubstr(const char* str, const char* substr, char* result)
{
	if (NULL == str || NULL == substr)
	{
		return -1;
	}
	const char *p, *q;
	char *temp = result;
	int icount = 0;
	int isublen = strlen(substr);		//作为匹配的依据
	int icurlen = 0;					//当前已经匹配的长度
	p = str;
	q = substr;

	while (*p != '\0')
	{
		if (*p == *q)
		{
			icurlen++;					//当前长度加1
			q++;
			p++;
			if (icurlen == isublen)		//匹配结束
			{
				icount++;
				icurlen = 0;			//清空待用
				q = substr;				//返回头部待用
				//跳过了复制，此时temp中没有保存这个字符
			}
		}
		else
		{
			if (icurlen != 0)			//匹配未完成即发生不匹配，则进行清零
			{
				q = substr;
				while (icurlen != 0)
				{
					*temp++ = *q++;		//把前面未成功匹配的都拷贝回去
					icurlen--;
				}
					
				q = substr;
				icurlen = 0;
				p++;
			}
			else
				*temp++ = *p++;				//拷贝到结果字符串
		}

	}
	if (icurlen != 0)			//匹配未完成即发生不匹配，则进行清零
	{
		q = substr;
		while (icurlen != 0)
		{
			*temp++ = *q++;		//把前面未成功匹配的都拷贝回去
			icurlen--;
		}
	}
	temp = '\0';
	result = temp;
	return icount;
}

int delete_sub_str(const char* str, const char* sub_str, char* result)
{
	assert(str != NULL && sub_str != NULL);//assert判断后面条件是否是假，是的话结束程序  
	const char *p, *q;
	char *t, *temp;
	p = str;
	q = sub_str;
	t = result;
	int n, count = 0;
	n = strlen(q);
	temp = (char*)malloc(n + 1);
	memset(temp, 0x00, n + 1);//将tmp内存区域的前n+1个字符赋为‘\0’  
	while (*p)
	{
		memcpy(temp, p, n);//将后面的前n个字符复制给前面  
		if (strcmp(temp, q) == 0)//strcmp比较相等返回零，前者大返回1，否则返回-1  
		{
			count++;
			memset(temp, 0, 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' };
	char str[100] = { '\0' };
	char substr[100] = { '\0' };
	while (gets_s(str,100) != NULL)
	{
		int num = DeleteSubstr(str, "123", s);
		printf("The number of sub_str is %d\r\n", num);
		printf("The result string is %s\r\n", s);
		memset(s, 0, 100);
		memset(str, 0, 100);
		memset(substr, 0, 100);
	}
	return 0;
}


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

#include<stdio.h>
#include<stdlib.h>
typedefstructNode
{
int num;
structNode*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<m;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);
     return0;
}


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

#include<stdio.h>
#include<string.h>
 
 
int huiwen(char str[])
{
    int i,len,k=0;
	len=strlen(str);
    for(i=0;i<len/2;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、 数组比较（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<stdlib.h>
#include<stdio.h>
#include<string.h>
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<stdio.h>
#include<stdlib.h>
#include<string.h>
typedefstructNode
{
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<len;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<m;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、 手机号码合法性判断（20分）

l问题描述：

我国大陆运营商的手机号码标准格式为：国家码+手机号码，例如：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<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<string.h>
#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
					return2;
			}
		}
		else
		return3;
	}
	else
	return1;
	return0;
}
 
int main()
{
	char*pchar=NULL;
	unsignedchar ichar=0;
	int result;
	switch(ichar)
	{
	case0:
		pchar="8612345363789";break;
	case1:
		pchar="861111111111111";break;
	case2:
		pchar="86s1234536366";break;
	default:
		break;
	}
   result =verifyMsisdn(pchar);
    printf("result is %d\n",result);
}


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
函数返回：3

#include<stdlib.h>
#include<stdio.h>
#include<string.h>
 
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

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<stdio.h>
#include<string.h>
#include<iostream.h>
#include<conio.h>
#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<N;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<N;i++)
			scanf("%d",&score[i]);
		printf("please input the level(1:expert,2:dazhong)\n");
	for(i=0;i<N;i++)
			scanf("%d",&judge_type[i]);
	numberlast=cal_score(score,judge_type,N);
	printf("the last score is %d\n",numberlast);
	return0;
}



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<stdio.h>
#include<string.h>
#include<conio.h>
void sort(int input[],int n,int output[])
{
	int i,j;
	int k=1;
	int temp;
	int med;
	for(i=0;i<n;i++)
	for(j=0;j<n-i;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<n;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<n;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<n;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);
	return0;
}



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[])

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[]的长度，函数返回值为两个数组不同元素的个数。

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

#include<stdio.h>
int compare_array(int len1,int array1[],int len2,int array2[])
{
	int i,t,small,num=0;
	//把两数组倒置
	for(i=0;i<len1/2;i++)
	{
		t=array1[i];
		array1[i]=array1[len1-i-1];
		array1[len1-i-1]=t;
	}
	for(i=0;i<len2/2;i++)
	{
		t=array2[i];
		array2[i]=array2[len2-i-1];
		array2[len2-i-1]=t;
	}
	//输出倒置后的两数组
	/*	for(i=0;i<len1;i++)
			printf("%d ",array1[i]);
		printf("\n");
		for(i=0;i<len2;i++)
			printf("%d ",array2[i]);
	*/	printf("\n");
	if(len1>len2)
		small=len2;
	else
		small=len1;
	num=small;
	for(i=0;i<small;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 <stdio.h>
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 <stdio.h>
#include <string.h>
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<n;i++)
        {
                if(*(strSrc+i)==*strFind)
                {
                        for(j=0;j<k;j++)
                        {
                                if(*(strSrc+i+j)==*(strFind+j))
                                {
                                        *(strSrc+i+j)=*(strReplace+j);
                                }
                                else continue;
                        }
                }
        }
}



答案二：

#include <stdio.h>
#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 <stdio.h>
#include <stdlib.h>
#include <string.h>
#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 <stdio.h>
#include <string.h>
int main()
{
	char str[]=”Computer Science”;
        int flag=1;
	char *p=str;
	while(*p)
       {
              <span style="white-space:pre">	</span>if ( flag )
    <span style="white-space:pre">		</span> { 
    	  <span style="white-space:pre">		</span>printf(“%c”,*p);
       <span style="white-space:pre">		</span>}
      <span style="white-space:pre">		</span> flag = (flag + 1) % 2;
       <span style="white-space:pre">		</span>p++;
       }
	printf(“\n”);
       return 0;
}


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

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

答案：

#include <stdio.h>
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;
}


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

float iMin = 5;
float iMax = 0;
int i;
int n;
float Num[n];   // 实际代码需要用一个比n大的值，或动态分配
float Sum ＝ 0;
float average;

for (i=0; i<n; i++)
{
    Sum += Num[i];
    if (Num[i]<iMin)  iMin = Num[i];
    if (Num[i]>iMax)  iMax = Num[i];
}
if (n>2)
{
    Sum -= iMin + iMax;
    average = Sum/(n-2);
}


运行结果：

the last score is :85.75

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

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

#include<stdio.h>
#include<malloc.h>


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<n;i++)
	{
		p1[i]=0;
		p2[i]=0;
	}


	for(i=0;i<n;i++)
	{
		if((a[i]%2)!=0)
			p2[kk++]=a[i];
		else
			p1[k++]=a[i];
	}
	count1=k;
	count2=kk;


	for(i=0;i<count2;i++)
		printf("%3d",p2[i]);
	printf("\n");


	for(i=0;i<count2;i++)
		for(j=0;j<count2-1-i;j++)
			if(p2[j]>p2[j+1])
			{
				temp2=p2[j];
				p2[j]=p2[j+1];
				p2[j+1]=temp2;
			}
	for(i=0;i<count2;i++)
		printf("%3d",p2[i]);
	printf("\n");


	for(i=0;i<count1;i++)
		printf("%3d",p1[i]);
	printf("\n");




	for(i=0;i<count1;i++)
		for(j=0;j<count1-i;j++)
			if(p1[j]<p1[j+1])
			{
				temp=p1[j];
				p1[j]=p1[j+1];
				p1[j+1]=temp;
			}
	for(i=0;i<count1;i++)
		printf("%3d",p1[i]);
	printf("\n");






	if(count1>count2)
	{
		for(i=0;i<count2;i++)
		{
		    a[i+m]=p2[i];
		    a[i+1+m]=p1[i];
		    m=m+1;
		}
		for(i=0;i<count1-count2;i++)
		     a[2*count2+i]=p1[i+count2];


		}
		else
		{
			for(i=0;i<count1;i++)
			{
		        a[i+m]=p2[i];
		        a[i+1+m]=p1[i];
		        m=m+1;


			}
			for(i=0;i<count2-count1;i++)
		        a[2*count1+i]=p2[i+count1];


		}
		for(i=0;i<n;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);
}


运行结果：
31511
31115
2146212144
1414126422
314111415126422
【免费题库】华为OD机试C卷 - 字符串拼接（Java 代码＋解析）
m0_66793065的博客
04-22 3356
题目描述 给定 M（0 < M ≤ 30）个字符（a-z），从中取出任意字符（每个字符只能用一次）拼接成长度为 N（0 < N ≤ 5）的字符串， 要求相同的字符不能相邻，计算出给定的字符列表能拼接出多少种满足条件的字符串， 输入非法或者无法拼接出满足条件的字符串则返回0。 ## 输入描述 给定的字符列表和结果字符串长度，中间使用空格(" ")拼接 ## 输出描述 满足条件的字符串个数 ## 用例 输入 abc 1 输出 3 说明 给定的字符为a,b,c，结果字符串长度为1，可以拼接成a,b,c，
【华为上机真题】字符串比较
Muti-Agent
11-25 1651
【华为上机真题】字符串比较
华为机试---字符集合
bigthinker的博客
06-16 3359
题目描述 输入一个字符串，求出该字符串包含的字符集合 输入描述: 每组数据输入一个字符串，字符串最大长度为100，且只包含字母，不可能为空串，区分大小写。 输出描述: 每组数据一行，按字符串原有的字符顺序，输出字符集合，即重复出现并靠后的字母不输出。 输入例子: abcqweracb 输出例子: abcqwer import java.util.Ha
再来两道华为字符串上机题目
LiuxBoy的专栏
09-17 1208
1、输入一个字符串，删除重复前面的字符，其余字符按原样顺序输出.  * 例如：  * 输入：input: "acbdfdffZZet";  * 输出：output:"acbdfZet";  * 实现函数：String(String input) String delString(String input){               String output = ""; //声明
西北大学上机题——字符串处理系列
weixin_45295612的博客
04-21 810
西北大学上机题——字符串处理系列 题目一：字母a的个数 题目描述： 输入一段英文字符，统计其中有多少个a字母 输入描述： 输入一段英文字符数不超过80个字符 输出描述： 输出这段英文字符中字母a的个数 样例输入： fave cad ecd ygaijj 样例输出： 3 #include<iostream> using namespace std; int main() { char ...
兰州大学上机题——字符串压缩
weixin_45295612的博客
04-13 314
兰州大学上机题——字符串压缩 题目描述： 字符串压缩，比如xxxxxdddfff，输出x5d3f3 算法思路： 设置一个索引，一个计数器，依次将当前的字符和前一个进行比较，如果相同，则计数器自增，索引后移；如果不同，将当前的字符加入到压缩字符中，并加入计数器的数字，然后计数器重置。 #include<iostream> #include<string> using name...
字符串题目
周周的博客
03-13 408
1179 give my text backTo prepare for the English exam Little Ho collected many digital reading materials. Unfortunately the materials are messed up by a malware.It is known that the original text cont...
【华为OD机试】真题E卷-字符串拼接（Python）
u014481728的博客
01-29 1124
给定M(0
华为OD 机考 2025B卷 - 字符串计数匹配 (C++ & Python & JAVA & JS & GO)
最新发布
qq_45776114的博客
06-08 601
华为OD 上机考试 2025 B卷 字符串计数匹配 提供Java、C++、Python、Go、JavaScript源码实现，并提供完整思路讲解
2024华为od机试e卷【字符串拼接】Python 实现
MISAYAONE的博客
09-19 1087
给定 M 个字符( a-z ) ，从中取出任意字符(每个字符只能用一次)拼接成长度为 N 的字符串，要求相同的字符不能相邻。计算出给定的字符列表能拼接出多少种满足条件的字符串，输入非法或者无法拼接出满足条件的字符串则返回 0 。
字符串习题
qq_36172410的博客
06-05 454
给定两个字符串S和T 你每次可以在S的某个字符c后面添加一个字符d，要保证c!=d 问有没有可能把S变成T 1<=|S|<=|T|<=1e5 首先S必须要是T的子序列，且S1=T1 因为字符不同的限制，所以S开头连续相同的字符数要不小于T开头的连续相同的字符数 如果满足以上条件，那么一定可以得到T 时间复杂度O（n） #include<iostream> ...
华为上机题字符串的处理
chenkaibsw的专栏
03-10 1638
1.题目描述•连续输入字符串，请按长度为8拆分每个字符串后输出到新的字符串数组；•长度不是8整数倍的字符串请在后面补数字0，空字符串不处理示例1输入abc 123456789输出abc00000 12345678 90000000基本思路：将字符串个数对8整除，得到的余数如果为零，说明字符串刚好是8的整数（即刚好按长度为8拆分），如果不为零，可以通过补零，将剩下的不足8为的余数添加到8位。代码实...
[Strings]一些字符串题目
srand(time(0))
05-09 1585
字符串
字符串机试题
boguesfei的博客
04-10 416
import java.util.Scanner; import java.util.Stack; public class Main /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub ...
字符串题目汇总
秀秀的奇妙旅行
03-27 770
剑指Offer(二)：替换空格 剑指Offer（四十三）：左旋转字符串 剑指Offer（四十四）：翻转单词顺序序列 剑指Offer（三十四）：第一个只出现一次的字符 剑指Offer（五十三）：表示数值的字符串 ...
字符串面试题
yuer的博客
06-26 980
字符串面试题的特点： 1. 广泛性 字符串可以看做字符类型的数组，与数组排序，查找，调整有关。 很多其他类型的面试题可以看做字符串类型的面试题。 2.需要掌握的概念 回文 子串（连续） 子序列（不连续） 前缀树（Trie树） 后缀树和后缀数组 匹配 字典序 3. 需要掌握的操作 与数组有关的操作：增删改查 字符的替换 字符串的旋转 字符串题目的常见类
字符串基础练习题80+道（原文及代码见文尾链接）
pythonbeatman的博客
03-24 2098
Python 字符串基础练习题80+道 GitHub-python字符串练习
字符串经典题
快乐江湖的博客
03-23 1327
文章目录LeetCode917：仅仅反转字母LeetCode387：字符串中第一个唯一字符牛客：最后一个单词的长度LeetCode125：验证回文串LeetCode415:大数运算之加法(重要)LeetCode43：大数运算之乘法牛客：字符串转换为整数[LeetCode 541：字符串部分区间反转](https://leetcode-cn.com/problems/reverse-string-ii/)LeetCode557：反转字符串中的单词 LeetCode917：仅仅反转字母 思路很简单，前后扫描即
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值