模块一
1. 统计各年龄段人数。
N个年龄通过调用随机函数获取，编写函数把 0~9 岁年龄段的人数放入数组下标[0]中，把10~19岁年龄段的人数放入数组下标[1]中，以此类推，把 100~120岁年龄段的人数放入数组下标[10]中。
#include<stdio.h>
#include<time.h>
#include<stdlib.h>
int statistics[11];
int get_random_age()
{
int d=rand()%121;
return d;
}
int main()
{
srand(time(NULL));
int n;
scanf("%d",&n);
for(int i=1;i<=n;++i)
{
int age=get_random_age();
age/=10;
if(age>=11) age=10;
statistics[age]++;
}
for(int i=0;i<=10;++i) printf("%d ",statistics[i]);
return 0;
}
2. 求素数。
编写一个函数，将大于整数m且紧靠m的k个素数存入数组中，在命令行输入 m和k。如输入17和 5，输出19，23，29，31，37。
#include<stdio.h>
bool is_prime(int x)//编写函数is_prime，判断一个数字是否是质数
{
for(int i=2;i<=x/i;++i)
//把条件写成i<=x/i而不是i*i<=x，是防止i*i爆int类型
//把条件写成i<=x/i而不是i<=sqrt(x)，是为了加快程序的运行速度
if(x%i==0) return 0;
return 1;//如果所有的i都不是x的因子，那么说明他是一个质数
}
int main()
{
int st,cnt;
scanf("%d%d",&st,&cnt);
for(int i=st+1;cnt;++i)//尝试判断数字i是否是质数
{
if(is_prime(i))//如果是质数，打印，再把cnt输出的总字符数-1
{
printf("%d ",i);
--cnt;
}
}
return 0;//程序结束，别忘了返回0
}
3. 求最大公约数和最小公倍数。
输入两个正整数 m和 n，求其最大公约数和最小公倍数。
#include<stdio.h>
int gcd(int a,int b)
{
return b?gcd(b,a%b):a;//使用辗转相除法计算最大公因数
}
int lcm(int a,int b)
{
return a/gcd(a,b)*b;//这里写成a/gcd(a,b)*b而不是a*b/gcd(a,b)是为了防止爆int
}
int main()
{
int a,b;
scanf("%d%d",&a,&b);//读入两个数字，计算最大公因数和最小公倍数
printf("%d %d",gcd(a,b),lcm(a,b));//调用函数，输出结果
return 0;
}
4. 四则运算。
帮助某小学数学老师出试卷。随机生成2个800以内的正整数或零，随机计算+、-、*或/，答案也必须是 800 以内的正整数或零。共出 50道题目，不能出现重复题目（2+3和3+2算不同的题目），并将题目写入文件。
//@右手fang 2024-07-27
//程序设计语言实习 4四则运算
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include<string.h>
const int MAX=800;
int num1[810],num2[810],idx=0;//定义num1，num2，sign数组，用于输出判重
char sign[810];
int get_random()//获取0-800的随机数
{
int random=rand()%(MAX+1);
return random;
}
char get_sign()
{
int random=rand()%4;//通过1-4这样的随机数，来获取随机的+-*/
switch(random)
{
case 0:return '+';//如果为0则为+
case 1:return '-';//如果为1则为-
case 2:return '*';//如果为2则为*
case 3:return '/';//如果为3则为/
}
}
void get_problem(FILE *fp)
{
int tmp1=get_random();//获取第一个数字
int tmp2=get_random();//获取第二个数字
char tmp_sign=get_sign();//获取随机的符号
int ans;//计算结果
if(tmp_sign=='+') ans=tmp1+tmp2;
else if(tmp_sign=='-') ans=tmp1-tmp2;
else if(tmp_sign=='*') ans=tmp1*tmp2;
else
{
int tmp=tmp1/tmp2;
if(1.0*tmp1/tmp2-tmp<=0.0001) ans=tmp;//判断是否整除，使用浮点数和整型相除的差判断是否整除
else
{
get_problem(fp);//如果发现没有整除，那么递归重新获取一个题目
return;
}
}
if(ans>MAX||ans<0)
{
get_problem(fp);//如果发现所求出的数字不在范围内，则递归重新获取一个题目
return;
}
for(int i=1;i<=idx;++i)
{
if(tmp1==num1[i]&&tmp2==num2[i]&&tmp_sign==sign[i])
{
get_problem(fp);//如果发现随机生成的题目和原先生成的题目完全一致，则重新生成一个题目
return;
}
}
++idx;//这是一个符合要求的新题目，那么编号+1
num1[idx]=tmp1;
num2[idx]=tmp2;
sign[idx]=tmp_sign;
fprintf(fp, "%d:%d%c%d=%d\n",idx,tmp1,tmp_sign,tmp2,ans);//将题目写入文件
return;
}
int main()
{
srand(time(NULL));//生成随机数的种子
FILE *fp=fopen("4_operations","w+");//打开一个文件
for(int i=1;i<=50;++i) get_problem(fp);//每一次执行get_problem()函数，获取一个题目
fclose("4_operations");//关闭文件
return 0;
}
//这段代码是会生成乘法的，但是因为随机数生成的乘法，结果在800以内的过少，可能需要放大输出量才能看到乘法
//这段代码也是会生成除法的，但是需要前一个数字是后一个数字的概率很低，所以需要放大输出量
5. 算术运算。
输入一个算术表达式字符串，得到最后结果。算术运算符包括+、-、*、/，注意小括号可改变优先级。例如输入“(2+3)*4”得到20。
#include<stdio.h>
#include<string.h>
const int N=1e5+10;
int num[N],t1=-1,t2=-1,ls;
char op[N],s[N];//栈num存操作数，栈op存操作符，t1和t2分别为栈顶指针
int hash(char ch){
if(ch=='+'||ch=='-') return 1;
else return 2;
}
void cal(int num[N],char op[N])
{
int b=num[t1--];
int a=num[t1--];
char theta=op[t2--];
if(theta=='+') num[++t1]=a+b;
else if(theta=='-') num[++t1]=a-b;
else if(theta=='*') num[++t1]=a*b;
else num[++t1]=a/b;
}
int main(){
scanf("%s",s);
int ls=strlen(s);
for(int i=0;i<ls;i++)
{
char c=s[i];
if((c-'0'>=0)&&(c-'0'<=9))
{
int j=i,t=0;
while(j<ls&&(s[j]-'0'>=0)&&(s[j]-'0'<=9)) t=10*t+s[j++]-'0';
num[++t1]=t;
i=j-1;
}
else if(c=='(') op[++t2]=c;
else if(c==')')
{
while(t2>=0)
{
if(op[t2]!='(') cal(num,op);
else
{
t2--;
break;
}
}
}
else
{
while(t2>=0&&op[t2]!='('&&hash(c)<=hash(op[t2])) cal(num,op);
op[++t2]=c;
}
}
while(t2>=0) cal(num,op);
printf("%d",num[0]);
return 0;
}
6. 玫瑰花数。
如果一个四位数等于它的每一位数的4次方之和，则称为玫瑰花数，比如：1634=1^4+6^4+3^4+4^4，编程输出所有的玫瑰花数。
#include<stdio.h>
int get_pow(int x)//计算一个数字的四次方
{
x*=x;
return x*x;
}
int get_left(int a,int b,int c,int d)//将数字的每一位数的四次方数相加
{
return get_pow(a)+get_pow(b)+get_pow(c)+get_pow(d);
}
int get_right(int a,int b,int c,int d)//将四位数字直接组合
{
return a*1000+b*100+c*10+d;
}
int main()
{
for(int a=1;a<=9;++a)//a从1开始，确保了这个数字一定是一个四位数，如果从0开始的话，这个数字有可能会生成出一个三位数
{
for(int b=0;b<=9;++b)
{
for(int c=0;c<=9;++c)
{
for(int d=0;d<=9;++d)
{
int left=get_left(a,b,c,d);
int right=get_right(a,b,c,d);//这里将数字进行了组合
if(left==right) printf("%d ",left);//比较两个数字的大小，如果相同，那么就将这个数字输出
}
}
}
}
return 0;
}
7. 借书组合问题。
张三有五本新书，要分别借给 A、B和C三位同学，如果每人每次只能借一本，则可以有多少种不同的借法，并输出所有借法。
#include<stdio.h>
int a,b,c;
int equal(int a,int b,int c)
{
if(a==b||a==c||b==c) return 0;
else return 1;
}
int main()
{
for(int i=1;i<=5;++i)
{
for(int j=1;j<=5;++j)
{
for(int k=1;k<=5;++k)
{
if(equal(i,j,k)) printf("%d %d %d\n",i,j,k);
}
}
}
return 0;
}
8. 猜数字游戏。
游戏随机生成 1个各位互不相同的四位数，接受用户输入 1个各位互不相同的四位数，根据用户输入输出“mAnB”的结果。其中 A表示数字和位置都正确，B表示数字正确，位置不正确。1个数字最多可以猜 10次，如果 10次全猜错给出正确答案。例如随机数为“1234”，用户输入为“1435”，显示“2A1B”。
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include<string.h>
struct N
{
int a,b;
};
int get_random()
{
while(1)
{
int ans=1000+rand()%9000;
int tmp=ans;
int a=ans%10;
int b=(ans/10)%10;
int c=(ans/100)%10;
int d=(ans/1000);
if(a==b||a==c||a==d||b==c||b==d||c==d) continue;
else return ans;
}
}
struct N check(int ans,int input)
{
int t1[4];
int t2[4];
for(int i=3;i>=0;--i)
{
t1[i]=ans%10;
t2[i]=input%10;
ans/=10;
input/=10;
}
int res1=0,res2=0;
for(int i=0;i<4;++i) res1+=(t1[i]==t2[i]);
int num[10];
memset(num,0,sizeof num);
for(int i=0;i<4;++i) num[t1[i]]++;
for(int i=0;i<4;++i) if(num[t2[i]]==1) res2++;
struct N res={res1,res2-res1};
return res;
}
int main()
{
srand(time(NULL));
int ans=get_random();
for(int i=1;i<=10;++i)
{
int input;
scanf("%d",&input);
struct N out=check(ans,input);
if(out.a==4)
{
printf("success\n");
return 0;
}
printf("%dA%dB\n",out.a,out.b);
}
printf("answer:%d",ans);
return 0;
}
9. 完数问题。
一个数如果恰好等于它的因子之和，这个数就称为“完数”。例如 6=1＋2＋3。编程找出1000 以内的所有完数。
#include<stdio.h>
int cnt(int x)
{
int res=1,i;//res初始化为1是因为，1一定是小于x的x的因子，但是x/1==x不是，需要特判
for(i=2;i<x/i;++i)
if(x%i==0) res+=i+x/i;
if(i*i==x) res+=i;//特判i是因为，i的平方如果正好是x，那么会被加两遍，所以需要特判
return res;//返回结果
}
int main()
{
for(int i=2;i<=1000;++i)//已知2不是完数，遍历剩余的2-1000所有的数字，进行搜索
if(cnt(i)==i) printf("%d ",i);//输出结果
return 0;
}
10. 进制转换。
输入一个十进制数 N，将它转换成 R 进制数（2<=R<=16，R<>10）。
#include<math.h>
#include<stdio.h>
char num[37];
int main()
{
for(int i=0;i<=9;++i) num[i]='0'+i;
for(int i=0;i<=25;++i) num[i+10]='A'+i;
int n,r,small;
scanf("%d%d",&n,&r);
small=r;
while(n>r) r*=r;
int zero=0;
while(r!=0)
{
if(n/r!=0) zero=1;
if(zero==1) printf("%c",num[n/r]);
n%=r;
r/=small;
}
return 0;
}
11. 第二小整数。
求 n 个整数中倒数第二小的数。每一个整数都独立看成一个数，如有三个数分别是1，1，3，那么，第二小的数就是 1。
#include<stdio.h>
const int INF=0x3f3f3f3f;
int s1=INF,s2=INF,n;
int main()
{
scanf("%d",&n);
for(int i=1;i<=n;++i)
{
int in;
scanf("%d",&in);
if(in<s1) {s2=s1;s1=in;}
else if(in<s2) s2=in;
}
printf("%d",s2);
return 0;
}
12. 取球问题。
口袋里有红、黄、蓝、白、黑 5 种颜色的球若干个。每次从口袋中取出 3 个不同颜色的球，问有多少种取法。
#include<stdio.h>
int equal(int a,int b,int c)
{
if(a==b||a==c||b==c) return 0;
else return 1;
}
int main()
{
int ans=0;
for(int i=1;i<=5;++i)
for(int j=1;j<=5;++j)
for(int k=1;k<=5;++k)
++ans;
printf("%d",ans);
return 0;
}
模块二
13. 编写合并整数数组的函数。
数组 a[M]中有 m个元素（m<M），数组 b[N]中有 n个元素（n<N），且m+n≤M，将a、b两个数组按存放的整数升序排序并合并放入数组 a中。
#include<stdio.h>
const int N=110;
int n,m,a[N],b[N],merge[2*N];//定义数组a，b，用于存放归并之前的值，merge用于存放归并以后的值
void swap(int *x, int *y)//定义swap函数用于交换两个值，使用指针传入地址
{
int tmp = *x;
*x = *y;
*y = tmp;
}
void sort(int q[],int l,int r)//定义快速排序函数sort
{
if(l>=r) return;//递归的终止条件：l>=r
int i=l-1,j=r+1,x=q[l+r>>1];//x是快速排序的基准值
while (i<j)//移动双指针，让基准值左边全部小于x，右边全部大于x
{
do i++; while(q[i]<x);
do j--; while(q[j]>x);
if(i<j) swap(&q[i],&q[j]);//交换
}
sort(q,l,j);//递归进行下一层排序
sort(q,j+1,r);
}
int main()
{
scanf("%d%d",&n,&m);//输入元素个数
for(int i=0;i<m;++i) scanf("%d",&a[i]);//输入数组a的值
for(int i=0;i<n;++i) scanf("%d",&b[i]);//输入数组b的值
sort(a,0,m-1);//对a数组排序
sort(b,0,n-1);//对b数组排序
int x=0,y=0,idx=0;//归并前的准备
while(x<m&&y<n)//在其中一个走到底之前，归并a，b到merge中
{
if(a[x]<b[y]) merge[idx++]=a[x++];
else merge[idx++]=b[y++];
}
while(x<m) merge[idx++]=a[x++];//归并剩下的a数组元素到merge中
while(y<n) merge[idx++]=b[y++];//归并剩下的b数组元素到merge中
for(int i=0;i<idx;++i) printf("%d ",merge[i]);//输出归并以后的结果
return 0;
}
14. 两个一元多项式相加。
输入 2个多项式，例如 A17(x)=7+3x+9x8+5x17和 B8(x)=8x+22x7-9x8，得到C17(x)=7+11x+22x7+5x17。
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef struct PolyNode
{
int factor;//系数
int power;//指数
struct PolyNode *next;
//next指针，指向下一个结点
}PolyNode, *PolyList;
//创建结点类型和结点指针类型
void insertTerm(PolyList *L, int factor, int power)
{
PolyNode *newNode = (PolyNode *)malloc(sizeof(PolyNode));
//创建一个新的结点
newNode->factor = factor;
//传入新结点的系数
newNode->power = power;
//传入新结点的指数
newNode->next = NULL;
//新建的结点没有下一个指针位置
if (*L==NULL||(*L)->power<power)
//如果说发现需要插入的链表为空，或者是新插入的这个结点的次数高于原有的最高次数
{
newNode->next=*L;
//那么直接将该结点插入头节点即可
*L=newNode;
//修改头指针的位置
}
else
{
PolyNode *p=*L;
//新建一个p指针，用于遍历链表
while(p->next&&p->next->power>power) p=p->next;
//扫描链表，直到次数相等或者次数刚好大于这个点
if (p->power == power)
//如果恰巧停下来的时候，次数相等，那么合并
{
p->factor+=factor;
//将系数直接相加
free(newNode);
//释放这个已经合并同类项的点
if (p->factor == 0)
//如果次数干好为0，那么把合并以后的点也直接释放掉
{
PolyNode *temp = p->next;
//删除操作，先保存后面一个结点的指针，先连接后删除
free(p);
*L = temp;
}
}
else
{
newNode->next = p->next;
//否则，将新的结点插入链表
p->next = newNode;
}
}
}
void print(PolyList L)
//这个函数用于输出表达式
{
if (L == NULL)
//如果表达式保存的链表为空，说明表达式不存在，直接输出0即可
{
printf("0\n");
return;
}
PolyNode *p = L;
//声明一个指针类型p，用于遍历链表
while (p)
{
if (p->factor>0&&p!=L) printf("+");
//在非头节点的情况底下，如果系数大于0，那么需要输出正号
if (p->power==0) printf("%d",p->factor);
//如果次数正号为0，那么直接输出系数即可
else if(p->power==1&&p->factor==1) printf("x");
//如果系数和次数都恰好为1，那么直接输出x
else if(p->power==1&&p->factor==-1) printf("-x");
//如果次数为1，系数为-1，那么直接输出-x
else if(p->power==1&&p->factor!=1&&p->factor!=-1)
printf("%dx",p->factor);
//如果次数恰好为1，系数无特殊输出系数和x
else if(p->factor==1) printf("x%d", p->power);
//如果系数恰好为1，且次数无特殊，那么输出x和次数
else if(p->factor==-1) printf("-x%d",p->power);
//如果系数为-1，次数无特殊，那么输出-x和次数
else printf("%dx%d", p->factor, p->power);
//否则，输出系数、x、次数
p = p->next;
//遍历下一个结点
}
printf("\n");
//输出换行，输出完成
}
PolyList addPoly(PolyList A, PolyList B)
//新建加法运算
{
PolyList result=NULL;
//首先先清空答案result链表
PolyNode *pa=A,*pb=B;
//创建两个指针类型变量pa，pb，用于遍历两个链表
while (pa&&pb)
//如果在pa和pb都没有走到头掉情况底下，需要比较两个链表的次数
{
if (pa->power>pb->power)
//如果说a链表的次数大于b链表的次数，那么需要先计算a链表里值
{
insertTerm(&result,pa->factor,pa->power);
//调用insert函数将a链表中pa指向的系数和次数插入result链表中
pa=pa->next;
//pa走向下一个结点
}
else if(pa->power<pb->power)
//同样，如果说b链表的次数大于a链表的次数，那么需要先计算b链表里值
{
insertTerm(&result,pb->factor,pb->power);
//调用insert函数将b链表中pb指向的系数和次数插入result链表中
pb=pb->next;
//pb走向下一个结点
}
else
//最后只剩下了两者次数相等的情况
{
int sum=pa->factor+pb->factor;
//这种情况下，把两个系数相加即可
if(sum!=0) insertTerm(&result,sum,pa->power);
//如果说相加得到的结果为0，也没有必要自己给自己找麻烦，直接跳过插入操作
//如果相加得到的结果不为0，那么直接将这样一个系数和次数插入到result链表当中
pa=pa->next;
pb=pb->next;
//两个指针移向下位
}
}
while (pa)
//收尾，如果pb已经走到了链表的表尾，将pa走到底就行了
{
insertTerm(&result,pa->factor,pa->power);
pa=pa->next;
}
while (pb)
//收尾，如果pa已经走到了链表的表尾，将pb走到底就行了
{
insertTerm(&result,pb->factor,pb->power);
pb=pb->next;
}
return result;
//把答案返回给主调函数
}
PolyList subPoly(PolyList A,PolyList B)
//这是一个减法的过程，实现原理和上面是类似的
{
PolyList result=NULL;
//首先定义一个结果链表，这个链表原始是空的，因为里面什么也没有
PolyNode *pa=A,*pb=B;
//定义两个用于循环的指针pa和pb
while (pa&&pb)
//如果指向两个链表的指针都没有走到表尾
{
if (pa->power>pb->power)
//如果pa指向的结点的次数高于pb指向结点的次数
{
insertTerm(&result,pa->factor,pa->power);
//将pa的结点直接插入链表中即可
pa = pa->next;
//pa走向下一个结点
}
else if (pa->power<pb->power)
//相反的，如果pb指向的结点的次数高于pa指向的结点的次数
{
insertTerm(&result,-pb->factor,pb->power);
//那么pb指向的结点，取相反数以后插入result链表中即可
//注意，这里和上面的加法不一样，因为b是被减数，所以需要取负数
pb = pb->next;
//pb走向下一个结点
}
else
//最后只剩下了一种情况，就是两者的次数恰好相等
{
int ans=pa->factor-pb->factor;
//那么将两者的系数相减
if(ans!=0) insertTerm(&result,ans,pa->power);
//如果两者系数相减正号为0，也没必要白费功夫了，直接跳过即可
//将结点插入result当中
pa=pa->next;
pb=pb->next;
//pa，pb均可以走向下一个结点
}
}
while (pa)//收尾工作
{
insertTerm(&result,pa->factor,pa->power);
pa = pa->next;
//将pa剩下的结点全部插入到result中
}
while (pb)
{
insertTerm(&result,-pb->factor,pb->power);
pb=pb->next;
//将pb剩下的结点全部插入道result中
}
return result;
//将结果返回给主调函数
}
void add(PolyList *L)
//这是一个读入字符串分离字符建立链表的字符串操作函数
{
char ch[100];
//本程序可以接受的最大表达式长度为100
scanf("%s",&ch);
//将字符串读入程序中
int factor=0,sign=1,power=0;
//定义三个变量，factor用于指示系数
//sign用于指示符号
//power用于指示次数
for(int i=0;i<strlen(ch);++i)
//依次遍历整个字符串
{
if(ch[i]=='-')
//如果遇到了负号，将系数取相反数
{
sign=-1;
continue;
}
else if(ch[i]=='+') continue;
//如果遇到了加号，说明不需要处理
else if(ch[i]=='x')
//如果遇到了x，那就说明遇到了系数和次数的分界点
{
if(factor==0) factor=1;
//如果系数为0，那就说明x前面什么都没有，那系数就是1
for(++i;ch[i]!='+'&&ch[i]!='-';++i)
//通过一个循环读取次数
{
power*=10;
power+=ch[i]-'0';
}
if(power==0&&(ch[i]=='+'||ch[i]=='-')) power=1;
//如果还没读就结束了，说明次数也是1
insertTerm(L,sign*factor,power);
//将这个结点插入道链表当中
--i;
//多读了一个符号位，说不定后面需要特殊处理，返回去重新处理
power=0;factor=0;sign=1;//将标志还原
}
else
{
factor*=10;
factor+=ch[i]-'0';
//这两个代码用来读取系数
}
}
if(factor!=0) insertTerm(L,factor*sign,0);
//收尾工作，如果最后没有读到x，那就说明存在0次方项，将0次方项插入链表
}
int main()
{
PolyList A=NULL;//新建两个链表
PolyList B=NULL;
add(&A);//读入A
add(&B);
PolyList C = addPoly(A,B);//C是答案，AB相加
printf("A+B:");
print(C);
C=subPoly(A,B);//C是答案，AB相减
printf("A-B:");
print(C);
return 0;//程序运行结束
}
15. 数组插入问题。
生成一个 10 元素构成的一维数组，数组元素由用户随机输入。要求：先按照升序排列并输出。再输入一个数，按照升序的规律将其插入并输出。
#include<stdio.h>
int arr[11];
void swap(int *x, int *y)//定义swap函数用于交换两个值，使用指针传入地址
{
int tmp = *x;
*x = *y;
*y = tmp;
}
void sort(int q[],int l,int r)//定义快速排序函数sort
{
if(l>=r) return;//递归的终止条件：l>=r
int i=l-1,j=r+1,x=q[l+r>>1];//x是快速排序的基准值
while (i<j)//移动双指针，让基准值左边全部小于x，右边全部大于x
{
do i++; while(q[i]<x);
do j--; while(q[j]>x);
if(i<j) swap(&q[i],&q[j]);//交换
}
sort(q,l,j);//递归进行下一层排序
sort(q,j+1,r);
}
int main()
{
for(int i=0;i<10;++i) scanf("%d",&arr[i]);
sort(arr,0,9);
for(int i=0;i<10;++i) printf("%d ",arr[i]);
printf("\n");
scanf("%d",&arr[10]);
sort(arr,0,10);
for(int i=0;i<11;++i) printf("%d ",arr[i]);
return 0;
}
16. 转方阵。
对一个方阵转置，就是把原来的行号变列号，原来的列号变行号。例如，图 1的方阵转置后变为图 2,；但如果是对该方阵顺时针旋转（不是转置），却是如图 3。请编写一个函数，实现一个方阵顺时针旋转。注：方阵是一个N*N 的矩阵。
#include<stdio.h>
const int N=1010;
int map[N][N],n;
void swap(int *a,int *b)
{
int tmp=*a;
*a=*b;
*b=tmp;
}
int main()
{
scanf("%d",&n);
for(int j=1;j<=n;++j)
for(int i=1;i<=n;++i)
scanf("%d",&map[i][j]);
for(int i=1;i<=n;++i)
for(int j=1;2*j<=n;++j)
swap(&map[i][j],&map[i][n-j+1]);
for(int i=1;i<=n;++i)
{
for(int j=1;j<=n;++j) printf("%d ",map[i][j]);
printf("\n");
}
return 0;
}
17. 链表操作。
建立单向 int链表，连续输入 5个结点创建链表，并实现在原链表中插入数字、删除数字、查找数字的功能。
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
struct Node
{
int v;
struct Node *next;
};
struct Node *st;
void add_to_back(int x) {
struct Node *p = st;
while(p->next != NULL) p = p->next;
struct Node *new_node = malloc(sizeof(struct Node));
new_node->v = x;
new_node->next = NULL;
p->next = new_node;
}
void insert(int x,int y)
{
struct Node *p=st;
while(p->next !=NULL&&p->v!=x) p=p->next;
struct Node *new_node=malloc(sizeof(struct Node));
new_node->next=p->next;
p->next=new_node;
new_node->v=y;
}
void delete(int x)
{
struct Node *p1=st;
struct Node *p2=NULL;
while(p1->next !=NULL&&p1->v!=x)
{
p2=p1;
p1=p1->next;
}
p2->next=p1->next;
free(p1);
}
int main()
{
st = malloc(sizeof(struct Node));
st->next = NULL;
for(int i = 0; i < 5; ++i)
{
int a;
scanf("%d", &a);
add_to_back(a);
}
int input;
do
{
printf("输入0退出\n");
printf("输入1，在输入x,y,代表在链表的x节点后面插入元素y\n");
printf("输入2，再输入x，代表删除掉链表中第一个值为x的元素\n");
scanf("%d",&input);
if(input==0) break;
else if(input==1)
{
int x,y;
scanf("%d%d",&x,&y);
insert(x,y);
}
else
{
int x;
scanf("%d",&x);
delete(x);
}
}while(input!=0);
struct Node *p = st->next;
while(p != NULL)
{
printf("%d ", p->v);
p = p->next;
}
printf("\n");
return 0;
}
18. 链表合并。
编写创建链表函数，链表中的结点包括学号（int）和成绩（int）。创建 a、b两个链表后，再将这两个链表合并，按学号升序排序（设学号都不相同）。
#include <stdio.h>
#include <stdlib.h>
int n1, n2;
struct Node
{
int id,score;
struct Node *next;
};
struct Node *st1, *st2;
void add_to_end(struct Node *start, int id, int score)
{
struct Node *new_node = malloc(sizeof(struct Node));
struct Node *p = start;
while (p->next != NULL) p = p->next;
new_node->id = id;
new_node->score = score;
new_node->next = NULL;
p->next = new_node;
}
struct Node* merge_and_sort(struct Node *a, struct Node *b)
{
struct Node dummy;
dummy.next = NULL;
struct Node *tail = &dummy;
while (a != NULL && b != NULL)
{
if (a->id < b->id)
{
tail->next = a;
a = a->next;
}
else
{
tail->next = b;
b = b->next;
}
tail = tail->next;
}
if (a != NULL) tail->next = a;
else tail->next = b;
return dummy.next;
}
void print_list(struct Node *head)
{
struct Node *p = head;
while (p != NULL)
{
printf("id: %d score: %d\n", p->id, p->score);
p = p->next;
}
}
int main()
{
st1 = malloc(sizeof(struct Node));
st2 = malloc(sizeof(struct Node));
st1->next = st2->next = NULL;
scanf("%d", &n1);
scanf("%d", &n2);
for (int i = 1; i <= n1; ++i)
{
int id, score;
scanf("%d %d", &id, &score);
add_to_end(st1, id, score);
}
for (int i = 1; i <= n2; ++i)
{
int id, score;
scanf("%d %d", &id, &score);
add_to_end(st2, id, score);
}
struct Node *merged_list = merge_and_sort(st1->next, st2->next);
print_list(merged_list);
return 0;
}
模块三：
19. 统计频率。
读入一个文件，文件中包含字母，数字，空格，标点符号等。请统计文件中的字
母，数字，空格和其他符号的数目，在屏幕上显示。
#include<stdio.h>
#include<stdlib.h>
#include<ctype.h>//引入字符类型判断头文件
int digit,others,alpha,blank;//初始化每一个桶
int main()
{
FILE *fp=fopen("input","r");//以只读形式打开一个文件
char input;//读取字符
while((input=fgetc(fp))!=EOF)//逐个读取字符，直到文件结束
{
if(isdigit(input)) {++digit;continue;}//数字
if(isalpha(input)) {++alpha;continue;}//字母
if(input==' ') {++blank;continue;}//空格
++others;//其他
}
printf("%d %d %d %d",alpha,digit,blank,others);//输出统计个数
fclose(fp);//关闭文件
return 0;
}
20. 字符串次数问题。
编写函数统计给定字符串在文中出现的次数，如文件中内容为 asd asasdfgasd as zx67 asd mklo，给定字符串为 as，则函数返回文件名和给定字符串由命令行输入得到。
#include<stdio.h>
#include<string.h>
char file[110],read[1010],ob[110];
int main()
{
scanf("%s %s",file,ob);
FILE *fp=fopen(file,"r");
int ans=0;
while(fscanf(fp,"%s",read)!=-1)
{
for(int i=0;i<strlen(read);++i)
{
for(int j=0;j<strlen(ob)&&i+j<strlen(read);++j)
{
//printf("%d %d\n",i,j);
if(read[i+j]!=ob[j]) break;
if(j+1==strlen(ob)) ans++;
}
}
}
fclose(fp);
printf("%d",ans);
return 0;
}
21. 统计字母个数。
读取文件中的字符串，统计从“a”到“z”26 个字母各自出现的次数，并将结果放入数组中。如文件中有字符abcdefgabcdeabc，输出33322110000000000000000000。
#include<stdio.h>
int alpha[26];
int main()
{
FILE *fp=fopen("input","r+");
char input;
while((input=fgetc(fp))!=EOF)
{
if(input==' ') continue;
++alpha[input-'a'];
}
for(int i=0;i<26;++i) printf("%d",alpha[i]);
fclose(fp);
return 0;
}
22.统计单词。
要求用命令行读取一个英文文章（比如：文件newspap.txt），文章内有数字、空格、标点符号等。请统计出该文章中单词的个数，并按字典顺序排序存入文件新文件中。注意单词只有全部由字母组成才被计数。
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
#define MAX_WORD_LENGTH 100
#define ALPHABET_SIZE 26
// Trie Node
struct TrieNode {
struct TrieNode *children[ALPHABET_SIZE];
int isEndOfWord; // Count occurrences of words ending at this node
};
// Function to create a new Trie node
struct TrieNode *createNode() {
struct TrieNode *newNode = (struct TrieNode *)malloc(sizeof(struct TrieNode));
newNode->isEndOfWord = 0;
for (int i = 0; i < ALPHABET_SIZE; i++)
newNode->children[i] = NULL;
return newNode;
}
// Insert a word into the Trie
void insert(struct TrieNode *root, const char *word) {
struct TrieNode *pCrawl = root;
while (*word) {
if (isalpha(*word)) {
int index = tolower(*word) - 'a';
if (!pCrawl->children[index])
pCrawl->children[index] = createNode();
pCrawl = pCrawl->children[index];
}
word++;
}
pCrawl->isEndOfWord++;
}
// Recursively collect words from the Trie in sorted order
void collectWords(struct TrieNode *root, char *buffer, int depth, FILE *output) {
if (root->isEndOfWord > 0) {
buffer[depth] = '\0';
fprintf(output, "%s %d\n", buffer, root->isEndOfWord);
}
for (int i = 0; i < ALPHABET_SIZE; i++) {
if (root->children[i]) {
buffer[depth] = i + 'a';
collectWords(root->children[i], buffer, depth + 1, output);
}
}
}
// Free the Trie
void freeTrie(struct TrieNode *root) {
for (int i = 0; i < ALPHABET_SIZE; i++) {
if (root->children[i])
freeTrie(root->children[i]);
}
free(root);
}
int main(int argc, char *argv[]) {
if (argc != 3) {
fprintf(stderr, "Usage: %s <input_file> <output_file>\n", argv[0]);
return 1;
}
FILE *input = fopen(argv[1], "r");
if (!input) {
perror("Error opening input file");
return 1;
}
FILE *output = fopen(argv[2], "w");
if (!output) {
perror("Error opening output file");
fclose(input);
return 1;
}
struct TrieNode *root = createNode();
char word[MAX_WORD_LENGTH];
int index = 0;
char ch;
while ((ch = fgetc(input)) != EOF) {
if (isalpha(ch)) {
word[index++] = tolower(ch);
} else {
if (index > 0) {
word[index] = '\0';
insert(root, word);
index = 0;
}
}
}
// Insert the last word if there is any
if (index > 0) {
word[index] = '\0';
insert(root, word);
}
char buffer[MAX_WORD_LENGTH];
collectWords(root, buffer, 0, output);
fclose(input);
fclose(output);
freeTrie(root);
return 0;
}
23.单词复数。
某单词本（文件）中有若干行单词单数形式，请在该单词后面给出单词复数形式，即单词本中每一行是“单数 复数”形式。注：如果单词以 s、x、z、ch、或 sh结尾，单词加es；如果单词以 y结尾，并且 y前面是一个辅音，将 y改为ies；对其他单词，后面加 s。
24.猜首都。
先自己书写一个 answer.txt 文件，在其中存放 10个国家及其首都。从该文件中随机读取出一个国家，让玩家回答出该国家的首都是什么。如回答正确则给予鼓励（如“GoodJob！”），并提示是否继续。如连续 3 次都回答错误，则公布正确答案，并提示是否继续。回答完 5道题目，给予鼓励并退出游戏。玩家输入首都时的单词不考虑大小写、空格的问题（如答案是“Beijing”，玩家输入“Bei Jing”算正确答案）。
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
char str[1000];
int count[26] = {0};
int i, index;
int main()
{
FILE *file = fopen("input", "r");
if (file == NULL)
{
printf("Error opening file\n");
return 1;
}
fgets(str, 1000, file);
fclose(file);
for (i = 0; i < strlen(str); i++) {
if (str[i] >= 'a' && str[i] <= 'z') {
index = str[i] - 'a';
count[index]++;
}
}
for (i = 0; i < 26; i++) printf("%d", count[i]);
return 0;
}
25.删除字符。
从源文件中读取字符，编写函数将指定字符从文件中删除，结果写入目标文件中，文件中的字母不区分大小写。源文件文件名、目标文件文件名、指定字符均从命令行得到。如源文件中内容为 source.txt，指定字符为 n，目标文件中内容为 output.txt。注意需要用命令行输入参数。
26.字符串压缩。
利用字符重复出现的次数，编写一种方法，实现基本的字符串压缩功能。比如，字符串 aabcccccaaa 会变为 a2b1c5a3。若“压缩”后的字符串没有变短，则返回原先的字符串。可以假设字符串中只包含大小写英文字母（a至z）。
模块四：
27. 分数比较问题。
比较两个分数的大小。
#include<stdio.h>
struct D//定义一个分数的结构体
{
int a,b;//a代表分子，b代表分母
}x,y;//定义两个数字
int main()
{
scanf("%d/%d %d/%d",&x.a,&x.b,&y.a,&y.b);//读取分数，格式类似 3/5 2/7
if(1.0*x.a/x.b>1.0*y.a/y.b) printf("x is larger than y");//x比y大
else if(1.0*x.a/x.b<1.0*y.a/y.b) printf("y is larger than x");//y比x大
else printf("x is smae as y");//两者一样大
return 0;
}
28. 分数加减问题。
输入“a/boc/d”，其中 a、b、c、d是一个0-9的整数。o 是运算符“+”或者“-”。输出对于输入数据的每一行输出两个分数的运算结果。注意结果应符合书写习惯，没有多余的符号、分子、分母，并且化简至最简分数。
29.年月日搜索问题。
中国俗话说“三天打渔两天晒网”。张三从 2000年 1月 1号起开始“三天打渔两天晒网”，请问张三在以后的某一天是“打渔”还是“晒网”。
30. DNA 序列还原。
某生物学文件内容为多条长度不等 DNA 序列，为书写方便其中有些片段用小括号括起并跟一个 int数字，表示该片段需要重复多次。如“(AGG)3”表示“AGG”片段需要重复3次，请按要求将源文件还原后写入新的文件中。注意：括号内的 DNA片段长度不定长，重复次数可能是个多位数。
31.算术计算器。
程序首先显示计算器界面，并等待用户输入一个 2 个操作数的算术计算式（见图11所示）。假如用户输入 22+2[HTML_REMOVED]，程序将在计算器的显示屏上输出计算结果（见图 12 所示）。如果输入错误，显示 input error!。当用户输入一个算式后，计算器显示计算结果，同时屏幕项部显示：Continue? 如果用户此时按 Y键，则继续输入下一个算式，否则，程序终止。提示：在屏幕的指定位置输出利用 gotoxy() 和cprintf 函数实现。包含在 conio.h头文件中。用户输入“y”或“Y”可用 getch函数接收。边框线可以用 ASCII 中的“制表线”绘制。
模块五:
32. 饭卡管理程序。
- (1). 建立饭卡信息：添加若干人的饭卡号、姓名、金额，要求饭卡号是唯一的；
- (2). 买饭：要求用户输入饭卡号、饭费，系统自动从该人的饭卡中减去饭钱，并分别显示买饭前后的金额，如果原来饭卡中的余额不足 5 元，则不能买饭，显示“余额不足，请充值”；
- (3). 充值：输入饭卡号、充值金额，充值完成后显示充值前后的金额。
33. 歌曲排行榜管理系统。
- (1). 每首歌曲包括编号、歌曲名称、歌手姓名、点播次数（如001，告白气球，周杰伦， 123） ；
- (2). 要求提供输入歌曲信息、删除歌曲信息、修改歌曲信息。（注删除、修改可按照歌曲名称查找）。
- (3). 程序要求有菜单，根据需求选择功能。
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#define CLS "clear"//在win系统中改成"cls" 调试端为macOS
const int MAXN=1e3+10;//数据量大上限
int data_open;//日志模式开关
int idx=0;//数据量顶
int add_users(char num[],char name[]);//用于添加用户
int buy(char num[],int fee);//用于消费
void main_tab();//首页
int recharge(char num[],int fee);//用于充值
int read();//用于读取数据
int write();//用于写入数据
void add_users_input();
void buy_input();
void recharge_input();
//代码中所有的input均为前端处理函数
int query_residue(char num[]);
struct DataBase//数据库结构体
{
char num[30];
char name[30];
int money;//这边使用int类型存储是防止double类型存储的金钱存在偏移，扩大100倍显示
}info[MAXN];
void query_residue_output()
{
char num[100];
printf("请输入需要查询的卡号，回车键结束\n");
scanf("%s",num);
int v=query_residue(num);//记录返回值等待处理
if(v==-1)
{
if(data_open) system(CLS);
printf("用户名不存在\n");//处理特殊情况
main_tab();//返回主菜单
return;
}
if(data_open) system(CLS);
printf("余额为%.2lf\n",v/100.0);//输出余额
main_tab();
return;
}
int read()
{
FILE *fp=fopen("data.fzy","r");//以制度模式打开文件
if(fp==NULL) return 0;//如果文件读取失败那么不再继续执行，代表程序为新程序
fscanf(fp,"%d",&data_open);//读取日志模式状态
char num[100],name[100];//文件读取缓冲区
int money;//文件读取缓冲区
memset(info,0,sizeof info);//清空原有数据
idx=0;//清空数据顶
while(fscanf(fp,"%s%s%d",num,name,&money)==3)
{
++idx;
if(idx>=MAXN-10) printf("Error,数据量过大\n");
//数据最大规模可以在代码顶部的全局变量区进行调整
strcpy(info[idx].num,num);//将文件写入内存
strcpy(info[idx].name,name);//将文件写入内存
info[idx].money=money;//将文件写入内存
}
fclose(fp);//关闭文件，停止占用
return 0;
}
int write()
{
FILE *fp=fopen("data.fzy","w+");//写文件
fprintf(fp,"%d\n",data_open);//写入日志模式配置文件
for(int i=1;i<=idx;++i)
fprintf(fp,"%s %s %d\n",info[i].num,info[i].name,info[i].money);
fclose(fp);//关闭fp文件停止占用
printf("数据保存成功\n");//宿处保存成功提示
return 0;
}
int query_residue(char num[])
//返回的数组是余额的100倍
//返回值-1代表用户名不存在
{
int users_num=-1;//进行标记防止数据读入失败
for(int i=1;i<=idx;++i)
{
struct DataBase output=info[i];
if(strcmp(output.num,num)==0)//找到用户名所在的位置
{
users_num=i;
break;
}
}
if(users_num==-1) return -1;//用户名不存在
return info[users_num].money;//返回结果
}
void recharge_input()
{
char num[100];//用户名缓冲区
double drawin;//存入的钱(原始金额)
printf("请输入卡号和充值金额，使用空格分开\n");
scanf("%s%lf",num,&drawin);
int v=recharge(num,(int)(drawin*100));
//通过recharge()函数获取一个返回值
if(v==-1)
{
if(data_open) system(CLS);
printf("操作失败(返回值-1)：用户名不存在\n");//处理异常情况
main_tab();//返回主界面
return;
}
printf("用户名%s充值后卡内余额剩余%.2lf元\n",num,v/100.0);//前端提示
main_tab();//返回主页面
return;
}
void buy_input()
{
char num[100];
double fee;
printf("请输入卡号和消费金额，使用空格分开\n");
scanf("%s %lf",num,&fee);
int v=buy(num,(int)(fee*100));
switch(v)
{
case -1://处理买饭的第一个异常：用户名不存在
{
if(data_open) system(CLS);
printf("操作失败(返回值-1)：用户名不存在\n");
main_tab();
return;
}
case -2://处理买饭的第二个异常：余额不足5元
{
if(data_open) system(CLS);
printf("操作失败(返回值-2)：原始卡内余额不足5元，请充值\n");
main_tab();
return;
}
case -3://处理买饭的第三个异常：余额有5元但不足以支付
{
if(data_open) system(CLS);
printf("操作失败(返回值-3)：无法完成此次消费，因为卡内余额不足以支付饭费\n");
main_tab();
return;
}
case 0://没有异常
{
if(data_open) system(CLS);
int residue=query_residue(num);
//这边的residue不可能为-1，如果返回值为-1，用户不存在，则上面的case -1已经解决了这个问题
printf("操作成功，卡号%s已完成消费%.2lf元,余额%.2lf元\n",num,fee,residue/100.0);
//返回消费的金额，剩余的余额等信息
main_tab();//返回主屏幕
return;
}
}
}
void add_users_input()//新增用户的前端页面
{
char num[100],name[100];//用户名和卡号的缓冲区
printf("请输入卡号和用户，使用空格分开，要求不超过25个字符\n");
scanf("%s %s",num,name);//输入想要添加的用户名
int v=add_users(num,name);//获取一个返回值
switch(v)
{
case -1://处理用户名添加的第一个异常：用户名重复
{
if(data_open) system(CLS);
printf("操作失败(返回值-1)：用户重复添加\n");
main_tab();
return;
}
case -2://获取用户名添加的第二个异常：卡号溢出
{
if(data_open) system(CLS);
printf("操作失败(返回值-2)：卡号超长\n");
main_tab();
return;
}
case -3://获取用户名添加的第三个异常：用户名溢出
{
if(data_open) system(CLS);
printf("操作失败(返回值-3)：用户名超长\n");
main_tab();
return;
}
case 0://没有异常
{
if(data_open) system(CLS);
printf("操作成功，已添加用户%s %s\n",num,name);
main_tab();
return;
}
}
}
void main_tab()
{
//下面是主界面
for(int i=1;i<=50;++i) printf("#");
for(int i=1;i<=3;++i) printf("\n");
printf(" fzy饭卡管理程序@2024-07-28\n");
printf(" 请输入以下数字，选择您所要进行的操作：\n");
printf(" 1.从磁盘中读取记录\n");
printf(" 2.向磁盘中写入记录\n");
printf(" 3.新增用户\n");
printf(" 4.买饭消费\n");
printf(" 5.卡片充值\n");
printf(" 6.查询卡内余额\n");
printf(" 7.打开或关闭日志开关\n");
printf(" 8.退出系统\n");
for(int i=1;i<=2;++i) printf("\n");
for(int i=1;i<=50;++i) printf("#");
printf("\n请输入您的选择(回车键确认)：");
//主界面打印完成，供用户选择
while(1)
{
int choose;
scanf("%d",&choose);//不断重复询问选择
switch(choose)
{
case 1:read();break;//读文件
case 2:write();break;//写文件
case 3:add_users_input();break;//增加用户
case 4:buy_input();break;//买饭
case 5:recharge_input();break;//充值
case 6:query_residue_output();break;//查询余额
case 7:data_open=!data_open;break;//打开或关闭数据日志
case 8:return;//退出软件
}
}
}
int add_users(char num[],char name[])
//返回值为-1，代表程序执行出现错误:用户重复添加
//返回值为-2:卡号超长
//返回值为-3:姓名超长
//返回值为0，代表用户添加成功
{
for(int i=1;i<=idx;++i)
{
struct DataBase output=info[i];
if(strcmp(output.num,num)==0) return -1;
}
//执行到这一步，代表用户没有被重复添加
++idx;
if(strlen(num)>25) return -2;//卡号超长判断
if(strlen(name)>25) return -3;//姓名超长判断
strcpy(info[idx].num,num);//将数据写入
strcpy(info[idx].name,name);//将数据读出
info[idx].money=0;
write();
return 0;
}
int buy(char num[],int fee)
//返回值为-1，代表用户不存在
//返回值为-2，代表余额不足
//返回值为-3，代表余额不足以支付饭费
//返回值为0，代表程序正常运行结束
{
int users_num=-1;
for(int i=1;i<=idx;++i)
{
struct DataBase output=info[i];
if(strcmp(output.num,num)==0)
{
users_num=i;
break;
}
}
if(users_num==-1) return -1;//用户名不存在
if(info[users_num].money<500) return -2;//卡内原有余额不足5元，需充值
if(info[users_num].money-fee<0) return -3;//卡内余额不足以消费，需充值
info[users_num].money-=fee;
write();
return 0;
}
int recharge(char num[],int fee)
//返回-1：用户名不存在
//返回到数字为充值后到余额
{
int users_num=-1;//搜索是否存在用户
for(int i=1;i<=idx;++i)
{
struct DataBase output=info[i];
if(strcmp(output.num,num)==0)
{
users_num=i;
break;
}
}
if(users_num==-1) return -1;//用户名不存在
info[users_num].money+=fee;
write();//写入文件，保存信息
return info[users_num].money;//返回余额(余额的100倍)
}
int main()
{
read();//读取数据
if(data_open) system(CLS);
main_tab();//进入主页面
printf("已退出系统\n");//退出提示
return 0;
}
34. 学生成绩管理系统。
- (1). 输入 n 个学生的学号，姓名，高等数学、大学物理、英语和 C 语言四门课程的成绩。
- (2). 计算每门课平均分数并输出；
- (3). 按照某类课程的成绩高低排序；
- (4). 找出每门课最高分的同学学号和姓名（如果最高分有多名同学，都输出）。
35. 排考场座位。
假设考场有 8 8 的座位，本程序可自动对考生进行座位安排，每当一个考生进入考场就为他安排座位（要求用链表实现）。要求
(1). 设定考场座位：用户输入准考证号和姓名，然后系统随机产生该考生座位的行号和列号，要求做到一个考生只有一个座位，且在已有考生的座位上不能再安排新的考生；
(2). 取消考场座位；
(3). 显示某座位考生信息：输入座位的行号和列号，显示该座位学生的信息
(4). 查找学生座位：输入某考生准考证号，显示该学生的座位；
* (5). 显示考场座次表：在每个座位对应的行列上显示该考生的准考证号。
36. 防疫隔离系统。
江苏省按照防疫要求，要求所有入苏人员需要隔离 14天（如某河南人从上海进入江苏，身份证省份为河南，来源身份为上海）。请你帮助工作人员设计防疫隔离系统。
(1). 输入 n 个人员的身份证号，姓名，来源省份（可能是境外），开始隔离日期（假设每人隔离 14 天）。
(2). 输入某日期，输出当日隔离人员情况（隔离期已满不显示）；
(3). 输入某日期，按照剩余隔离日期由多到少排序（隔离期已满不显示）；
(4). 根据身份证号，统计各省隔离人员人数（隔离期已满不显示）；
(5). 按照年龄输出输出当日隔离人员情况（隔离期已满不显示）；
(6). 按照性别输出当日隔离人员情况（隔离期已满不显示）；
* (7). 输入某日期和来源省份，输出当日隔离人员情况（隔离期已满不显示）。
（注：身份证前1、2 位数字表示：所在省（直辖市、自治区）的代码，第 7—14 位数字表示：出生年、月、日，第17 位数字表示性别：奇数表示男性，偶数表示女性。）
