1、删除子串，只要是原串中有相同的子串就删掉，不管有多少个，返回子串个数。
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
int delete_sub_str(const char *str,constchar *sub_str,char *result)
{
assert(str!= NULL && sub_str != NULL);
constchar *p,*q;
char *t,*temp;
p= str;
q =sub_str;
t= result;
intn,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);
returncount;
}
int main()
{
chars[100] = {‘\0’};
intnum = delete_sub_str(“123abc12de234fg1hi34j123k”,”123”,s);
printf(“Thenumber of sub_str is %d\r\n”,num);
printf(“Theresult string is %s\r\n”,s);
}
2、约瑟夫环是一个数学的应用问题：已知n个人（以编号1，2，3...n分别表示）围坐在一张圆桌周围。从编号为k的人开始报数，数到m的那个人出列；他的下一个人又从1开始报数，数到m的那个人又出列；依此规律重复下去，直到圆桌周围的人全部出列。
#include<stdio.h>
#include<stdlib.h>
typedef struct Node
{
intnum;
structNode *next;
}LinkList;
LinkList *creat(int n)
{
LinkList*p,*q,*head;
inti=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)
{
inti;
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;
intn, m;
n=9;
m=5;
L=creat(n);
fun(L,m);
return0;
}
3、比较一个数组的元素是否为回文数组
#include<stdio.h>
#include<string.h>
int huiwen(charstr[])
{
int i,len,k=1;
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
• 要求实现函数：
intarray_compare(intlen1,intarray1[],intlen2,intarray2[])
【输入】 intlen1：输入被比较数组1的元素个数；
intarray1[]：输入被比较数组1；
intlen2：输入被比较数组2的元素个数；
intarray2[]：输入被比较数组2；
【输出】 无
【返回】 不相等元素的个数，类型为int
• 示例
1） 输入：intarray1[]={1,3,5}，intlen1=3，intarray2[]={77,21,1,3,5}，intlen2=5
函数返回：0
2） 输入：intarray1[]={1,3,5}，intlen1=3，intarray2[]={77,21,1,3,5,7}，intlen2=6
函数返回：３
#include<stdlib.h>
#include<stdio.h>
#include<string.h>
intarray_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。
• 要求实现函数：
voidarray_iterate(intlen,intinput_array[],intm,intoutput_array[])
【输入】 intlen：输入数列的长度；
intintput_array[]：输入的初始数列
intm：初始计数值
【输出】 intoutput_array[]：输出的数值出列顺序
【返回】 无
• 示例
输入：intinput_array[]={3,1,2,4}，intlen=4，m=7
输出：output_array[]={2,3,1,4}
循环链表实现//
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef structNode
{
int num;
struct node *next;
} node;
node *creat(intlen , 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);
}
voidarray_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要求实现函数：
intverifyMsisdn(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>
#defineLENGTH 13
intverifyMsisdn(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、数组比较（20分）
• 问题描述：
比较两个数组，要求从数组最后一个元素开始逐个元素向前比较，如果2个数组长度不等，则只比较较短长度数组个数元素。请编程实现上述比较，并返回比较中发现的不相等元素的个数
比如：
数组{1,3,5}和数组{77,21,1,3,5}按题述要求比较，不相等元素个数为0
数组{1,3,5}和数组{77,21,1,3,5,7}按题述要求比较，不相等元素个数为3
• 要求实现函数：
intarray_compare(intlen1,intarray1[],intlen2,intarray2[])
【输入】 intlen1：输入被比较数组1的元素个数；
intarray1[]：输入被比较数组1；
intlen2：输入被比较数组2的元素个数；
intarray2[]：输入被比较数组2；
【输出】 无
【返回】 不相等元素的个数，类型为int
• 示例
1） 输入：intarray1[]={1,3,5}，intlen1=3，intarray2[]={77,21,1,3,5}，intlen2=5
函数返回：0
2） 输入：intarray1[]={1,3,5}，intlen1=3，intarray2[]={77,21,1,3,5,7}，intlen2=6
函数返回：3
#include<stdlib.h>
#include<stdio.h>
#include<string.h>
intarray_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、输入字符串一定是符合题意合法的表达式，其中只包括数字字符和四则运算符字符，除此之外不含其它任何字符，不会出现计算溢出情况
• 要求实现函数：
intcalculate(intlen,char*expStr)
【输入】 intlen:字符串长度；
char*expStr:表达式字符串；
【输出】 无
【返回】 计算结果
• 示例
1） 输入：char*expStr=“1+4*5-8/3”
函数返回：19
2） 输入：char*expStr=“8/3*3”
函数返回：6
#include <stdio.h>
/*
*author by wanww
*time: 2011-09-07
*/
using namespace std;
int array_compare(int len1, intarray1[], int len2, int array2[])
{
if(len1 == len2) {
intcount = 0;
for(int i=0;i<len1;i++)
{
if(array1[i]!=array2[i])count++;
}
returncount;
}else if(len1<len2) {
returnarray_compare(len1, array1,len1,array2+len2-len1);
}else {
returnarray_compare(len2,array1+len1-len2,len2,array2);
}
}
void array_iterate(int len, intinput_array[], int m,int output_array[])
{
int* flag = new int[len];
memset(flag,0,len*4);
inthasout=0; //已经出列的数字个数
intstart = 0; //开始的下标号
intj=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 {
charopdata[200];
inttop;
}opstack;
//定义操作符栈
opstack.top= -1;
inti=0;//遍历字符串的下标
intt=0;//当前后缀表达式的长度
charch = 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 {
intnumeric[200];
inttop;
}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';
}
elseif('+' == ch)
{
inttmp = data.numeric[data.top-1] +data.numeric[data.top];
data.top--;
data.numeric[data.top]= tmp;
}
elseif('-' == ch)
{
inttmp = data.numeric[data.top-1] -data.numeric[data.top];
data.top--;
data.numeric[data.top]= tmp;
}
elseif('*' == ch)
{
inttmp = data.numeric[data.top-1] *data.numeric[data.top];
data.top--;
data.numeric[data.top]= tmp;
}
elseif('/' == ch)
{
if(data.numeric[data.top] == 0)
{
printf("cannotbe zero of the divide\n");
exit(1);
}
inttmp = data.numeric[data.top-1] / data.numeric[data.top];
data.top--;
data.numeric[data.top]= tmp;
}
i++;
ch= expStr[i];
}
returndata.numeric[data.top];
}
void main()
{
intarray1[] = {1,3,5};
intlen1 = 3;
intarray2[] = {77,21,1,3,5,7};
intlen2 = 6;
intcount = array_compare(sizeof(array1)/sizeof(int),array1,sizeof(array2)/sizeof(int),array2);
printf("%d\n",count);
printf("*****************************************************\n");
intinput_array[] = {3,1,2,4};
intlen = 4;
intm=7;
int* output_array = new int[sizeof(input_array)/sizeof(int)];
array_iterate(4,input_array,7,output_array);
for(int i=0;i<sizeof(input_array)/sizeof(int);i++)
{
printf("%d",output_array[i]);
}
delete[] output_array;
printf("\n*****************************************************\n");
charexpStr[] = "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(intscore[], 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 thelevel(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);
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<stdio.h>
#include<string.h>
#include<conio.h>
void sort(int input[], int n, intoutput[])
{
inti,j;
intk=1;
inttemp;
intmed;
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()
{
inta[6]={3,6,1,9,7,8};
intb[6]={0};
for(inti=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, intsystem_task[], int user_task[])
#include<stdio.h>
#include<string.h>
#include<malloc.h>
#include<iostream.h>
void scheduler1(int task[], int n, intsystem_task[], int user_task[])
{
inti;
intj=0;
int*p,*pp,*p_user,*pp_user;
intindex=0;
intcount,count2;
intmin=0;
intk=0;
p=(int*)malloc(sizeof(int)*n);
for(i=0;i<n;i++)
p[i]=0;
pp=(int*)malloc(sizeof(int)*n);
for(i=0;i<n;i++)
pp[i]=0;
p_user=(int*)malloc(sizeof(int)*n);
for(i=0;i<n;i++)
p_user[i]=0;
pp_user=(int*)malloc(sizeof(int)*n);
for(i=0;i<n;i++)
pp_user[i]=0;
for(i=0;i<n;i++)
{
if(task[i]<50)
{
{
system_task[j]=task[i];
pp[j]=i;
j++;
}
count=j;
}
elseif(task[i]<=255)
{
{
user_task[k]=task[i];
pp_user[k]=i;
k++;
}
count2=k;
}
elsetask[i]=task[i];
}
for(i=0;i<count;i++)
printf("%3d",system_task[i]);
printf("\n");
for(i=0;i<count;i++)
{
min=system_task[0];
for(j=1;j<count;j++)
{
if(system_task[j]<min)
{
min=system_task[j];
p[i]=j;
}
}
system_task[p[i]]=51;
}
pp[count]=-1;
for(i=0;i<count;i++)
printf("%3d",pp[p[i]]);
printf("%3d\n",pp[count]);
/***********************************************************/
for(i=0;i<count2;i++)
printf("%4d",user_task[i]);
printf("\n");
for(i=0;i<count2;i++)
{
min=user_task[0];
for(j=1;j<count2;j++)
{
if(user_task[j]<min)
{
min=user_task[j];
p_user[i]=j;
}
}
user_task[p_user[i]]=256;
}
pp_user[count2]=-1;
for(i=0;i<count2;i++)
printf("%4d",pp_user[p_user[i]]);
printf("%3d\n",pp_user[count2]);
}
int main()
{
inttask[9]={0, 30, 155, 1, 80, 300,170, 40, 99};
intsystem_task[9]={0};
intuser_task[9]={0};
scheduler1(task,9,system_task,user_task);
return0;
}
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, intarray1[], int len2, int array2[] );
其中，len1与len2分别为数组array1[]和array2[]的长度，函数返回值为两个数组不同元素的个数。
以下是上题的函数完整实现：
//diff_num.cpp
#include<stdio.h>
int compare_array(int len1,int array1[],intlen2,int array2[])
{
inti,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);
returnnum;
}
void main()
{
intarray1[5]={77,21,1,3,5},array2[3]={1,3,5};
intlen1=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 stringis %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()
{chars[]="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);
}
elsecontinue;
}
}
}
}
答案二：
#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()
{
chars[]="ABCDEFGHIJKLMNOPQRSTUVWXYZ";
chars1[]="RST";
chars2[]="gggg";
StrReplace(s,s1,s2);
printf("%s\n",s);
return0;
}
void StrReplace(char* strSrc, char*strFind, char* strReplace)
{
while(*strSrc!= '\0')
{
if(*strSrc== *strFind)
{
if(strncmp(strSrc,strFind,strlen(strFind))== 0 )
{
inti = strlen(strFind);
intj = 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()
{
charstr[]=”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语言实现字符串中子字符串的替换
描述：编写一个字符串替换函数，如函数名为 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()
{chars[]="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()
{
chars[]="ABCDEFGHIJKLMNOPQRSTUVWXYZ";
chars1[]="RST";
chars2[]="gggg";
StrReplace(s,s1,s2);
printf("%s\n",s);
return0;
}
void StrReplace(char* strSrc, char*strFind, char* strReplace)
{
while(*strSrc!= '\0')
{
if(*strSrc== *strFind)
{
if(strncmp(strSrc,strFind,strlen(strFind))== 0 )
{
inti = strlen(strFind);
intj = 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 <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;
}
18、算分数的问题，去掉一个最高分一个最低分，求平均分
1.#include<stdio.h>
2.floatavescore(floatscore[],intn)
3.{
4.floatmin=0;
5.floatmax=0;
6.intminindex=0;
7.intmaxindex=0;
8.floatsum=0;
9.min=score[0];
10.for(inti=0;i<n;i++)
11.if(score[i]<min)
12.{
13.min=score[i];
14.minindex=i;
15.}
16.score[minindex]=0;
17.max=score[0];
18.for(i=0;i<n;i++)
19.if(score[i]>max)
20.{
21.max=score[i];
22.maxindex=i;
23.}
24.score[maxindex]=0;
25.for(i=0;i<n;i++)
26.sum+=score[i];
27.sum=sum/(n-2);
28.returnsum;
29.}
30.voidmain()
31.{
32.floatscore[6]={70,80,90,98,87,86};
33.floatlastscore;
34.lastscore=avescore(score,6);
35.printf("thelastscoreis:%5.2f\n",lastscore);
36.
37.}
运行结果：
the last score is :85.75
19、对一个数组，将数组中偶数从大到小排序，奇数从小到大排序,奇数和偶数交叉着放且输出数组第一位放奇数若奇数和偶数不等长，则把剩下的直接放到数组中。
思路：先进行奇偶判断，得到奇数和偶数数组。然后对两数组排序，进行长度判断，最后组织数据。
#include<stdio.h>
1.#include<malloc.h>
2.
3.voidjiou(inta[],intn)
4.{
5.int*p1;
6.int*p2;
7.inti,j;
8.intk=0;
9.intkk=0;
10.intcount1=0;
11.intcount2=0;
12.inttemp;
13.inttemp2;
14.intm=0;
15.p1=(int*)malloc(sizeof(int)*n);
16.p2=(int*)malloc(sizeof(int)*n);
17.for(i=0;i<n;i++)
18.{
19.p1[i]=0;
20.p2[i]=0;
21.}
22.
23.for(i=0;i<n;i++)
24.{
25.
26.if((a[i]%2)!=0)
27.{p2[kk++]=a[i];}
28.else
29.{p1[k++]=a[i];}
30.}
31.count1=k;
32.count2=kk;
33.
34.for(i=0;i<count2;i++)
35.printf("%3d",p2[i]);
36.printf("\n");
37.
38.for(i=0;i<count2;i++)
39.for(j=0;j<count2-1-i;j++)
40.if(p2[j]>p2[j+1])
41.{temp2=p2[j];p2[j]=p2[j+1];p2[j+1]=temp2;}
42.for(i=0;i<count2;i++)
43.printf("%3d",p2[i]);
44.printf("\n");
45.
46.for(i=0;i<count1;i++)
47.printf("%3d",p1[i]);
48.printf("\n");
49.
50.
51.for(i=0;i<count1;i++)
52.for(j=0;j<count1-i;j++)
53.if(p1[j]<p1[j+1])
54.{temp=p1[j];p1[j]=p1[j+1];p1[j+1]=temp;}
55.for(i=0;i<count1;i++)
56.printf("%3d",p1[i]);
57.printf("\n");
58.
59.
60.
61.if(count1>count2)
62.
63.{
64.for(i=0;i<count2;i++)
65.{
66.a[i+m]=p2[i];
67.a[i+1+m]=p1[i];
68.m=m+1;
69.}
70.for(i=0;i<count1-count2;i++)
71.a[2*count2+i]=p1[i+count2];
72.
73.}
74.else
75.{
76.for(i=0;i<count1;i++)
77.{
78.a[i+m]=p2[i];
79.a[i+1+m]=p1[i];
80.m=m+1;
81.
82.}
83.for(i=0;i<count2-count1;i++)
84.a[2*count1+i]=p2[i+count1];
85.
86.}
87.for(i=0;i<n;i++)
88.printf("%3d",a[i]);
89.printf("%\n");
90.
91.}
92.voidmain()
93.{
94.inta[10]={2,3,14,6,2,15,12,14,4,11};
95.jiou(a,10);
96.
97.}
运行结果：
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
扫一扫
7万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
