笔试真题刷题平台
精选近几年名企笔试真题，笔试之前刷刷真题，有备无患
删除子串，只要是原串中有相同的子串就删掉，不管有多少个，返回子串个数。
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
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);
}
约瑟夫环是一个数学的应用问题：已知n个人（以编号1，2，3...n分别表示）围坐在一张圆桌周围。从编号为k的人开始报数，数到m的那个人出列；他的下一个人又从1开始报数，数到m的那个人又出列；依此规律重复下去，直到圆桌周围的人全部出列。
#include<stdio.h>
#include<stdlib.h>
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<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);
return 0;
}
比较一个数组的元素 是否为回文数组
#include <stdio.h>
#include <string.h>
int huiwen(char str[])
{
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);
}
比较两个数组，要求从数组最后一个元素开始逐个元素向前比较，如果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);
}
输入一个由随机数组成的数列（数列中每个数均是大于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>
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<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);
}
我国大陆运营商的手机号码标准格式为：国家码+手机号码，例如：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
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);
}
比较两个数组，要求从数组最后一个元素开始逐个元素向前比较，如果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);
}
问题描述： 输入一个只包含个位数字的简单四则运算表达式字符串，计算该表达式的值
注： 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 <stdio.h>
/*
* author by wanww
* time: 2011-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<len1;i++)
{
if(array1[i]!=array2[i]) count++;
}
return count;
} else if(len1<len2) {
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<sizeof(input_array)/sizeof(int);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);
}
选秀节目打分，分为专家评委和大众评委，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);
return 0;
}
给定一个数组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);
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<stdio.h>
#include<string.h>
#include<malloc.h>
#include<iostream.h>
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<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;
}
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<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()
{
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;
}
从两个数组的最后一个元素比较两个数组中不同元素的个数，如有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<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);
}
输入一个字符串，用指针求出字符串的长度。
#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;
}
使用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++;
}
}
}
编写一个程序实现功能：将字符串”Computer Secience”赋给一个字符数组，然后从第一个字母开始间隔的输出该串，用指针完成。
#include <stdio.h>
#include <string.h>
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;
}
使用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++;
}
}
}
编写一个程序实现功能：将两个字符串合并为一个字符串并且输出，用指针实现。
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;
}
算分数的问题，去掉一个最高分一个最低分，求平均分
#include<stdio.h>
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<n;i++)
if(score[i]<min)
{
min=score[i];
minindex=i;
}
score[minindex]=0;
max=score[0];
for(i=0;i<n;i++)
if(score[i]>max)
{
max=score[i];
maxindex=i;
}
score[maxindex]=0;
for(i=0;i<n;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
对一个数组，将数组中偶数从大到小排序，奇数从小到大排序,奇数和偶数交叉着放且输出数组第一位放奇数 若奇数和偶数不等长，则把剩下的直接放到数组中。
思路：先进行奇偶判断，得到奇数和偶数数组。然后对两数组排序，进行长度判断，最后组织数据。
#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);
}
运行结果：
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
问题描述： 输入一个只包含个位数字的简单四则运算表达式字符串，计算该表达式的值
注： 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 <stdio.h>
/*
* author by wanww
* time: 2011-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<len1;i++)
{
if(array1[i]!=array2[i]) count++;
}
return count;
} else if(len1<len2) {
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<sizeof(input_array)/sizeof(int);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);
}
