2024年3月4日发(作者：恽端懿)

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

答案：

#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 %dn”, 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("%sn",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(“%sn”, str1);

return 0;

}

问题：以下函数的功能是用递归的方法计算x的n阶勒让德多项式的值。已有调用语句p（n，x）；编写函数实现功能。递归公式如下：

1Px(x)x((2n1)xP(x)(n1)P(x))/nn1n2(n0)(n1)(n1)

答案：

#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(“%.2fn”,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("%5dn",p->num);

}

int main()

{

LinkList *L;

int n, m;

n=9;

m=5;

L=creat(n);

fun(L,m);

return 0;

}

手机号码合法性判断（20分）

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

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 = “889“

输出： 无

返回： 3

输入： inMsisdn = “869“

输出： 无

返回： 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="86";break;

case 1:

pchar="8611";break;

case 2:

pchar="86s1234536366"; break;

case 3:

pchar="22";break;

default:

break;

}

result =verifyMsisdn(pchar);

printf("result is %dn",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("%5dn",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("%dn",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("子字符串的个数是：%dn",count);

printf("删除子字符串后：%sn",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;

=-1;

=-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(>=0)

{

postexp[k++]=[--];

}

++;

[]=expStr[i];

}

else if(expStr[i]=='*'||expStr[i]=='/')

{

while(>=0&&([]=='*'

||[]=='/'))

{

postexp[k++]=[--];

}

++;

[]=expStr[i];

}

i++;

}

while(>=0)

{

postexp[k++]=[--];

}

int temp1=0;

int temp2=0;

for(i=0;i

{

if(postexp[i]>='0'&&postexp[i]<='9')

{

++;

[]=postexp[i]-'0';

}

else if(postexp[i]=='+')

{

temp1=[--];

temp2=[];

[]=temp2+temp1;

}

else if(postexp[i]=='-')

{

temp1=[--];

temp2=[];

[]=temp2-temp1;

}

else if(postexp[i]=='*')

{

temp1=[--];

temp2=[];

[]=temp2*temp1;

}

else if(postexp[i]=='/')

{

temp1=[--];

temp2=[];

[]=temp2/temp1;

}

}

printf("%dn",[]);

return [];

}

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

if (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;

2024年3月4日发(作者：恽端懿)

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

答案：

#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 %dn”, 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("%sn",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(“%sn”, str1);

return 0;

}

问题：以下函数的功能是用递归的方法计算x的n阶勒让德多项式的值。已有调用语句p（n，x）；编写函数实现功能。递归公式如下：

1Px(x)x((2n1)xP(x)(n1)P(x))/nn1n2(n0)(n1)(n1)

答案：

#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(“%.2fn”,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("%5dn",p->num);

}

int main()

{

LinkList *L;

int n, m;

n=9;

m=5;

L=creat(n);

fun(L,m);

return 0;

}

手机号码合法性判断（20分）

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

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 = “889“

输出： 无

返回： 3

输入： inMsisdn = “869“

输出： 无

返回： 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="86";break;

case 1:

pchar="8611";break;

case 2:

pchar="86s1234536366"; break;

case 3:

pchar="22";break;

default:

break;

}

result =verifyMsisdn(pchar);

printf("result is %dn",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("%5dn",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("%dn",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("子字符串的个数是：%dn",count);

printf("删除子字符串后：%sn",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;

=-1;

=-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(>=0)

{

postexp[k++]=[--];

}

++;

[]=expStr[i];

}

else if(expStr[i]=='*'||expStr[i]=='/')

{

while(>=0&&([]=='*'

||[]=='/'))

{

postexp[k++]=[--];

}

++;

[]=expStr[i];

}

i++;

}

while(>=0)

{

postexp[k++]=[--];

}

int temp1=0;

int temp2=0;

for(i=0;i

{

if(postexp[i]>='0'&&postexp[i]<='9')

{

++;

[]=postexp[i]-'0';

}

else if(postexp[i]=='+')

{

temp1=[--];

temp2=[];

[]=temp2+temp1;

}

else if(postexp[i]=='-')

{

temp1=[--];

temp2=[];

[]=temp2-temp1;

}

else if(postexp[i]=='*')

{

temp1=[--];

temp2=[];

[]=temp2*temp1;

}

else if(postexp[i]=='/')

{

temp1=[--];

temp2=[];

[]=temp2/temp1;

}

}

printf("%dn",[]);

return [];

}

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

if (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;