郑轻OJ101~150题答案+详细解析【已更新】

//注意：题目要求只需提交inverse函数部分即可
int inverse(int n)
  int m=0;    //定义最终需要返回的结果，注意应赋值为0，不然m的值会随机生成
  do{
      int x=n%10;    //把最低位提取出来
      m=m*10+x;    <qc>//逆序相加</qc>
      n/=10;    //舍弃最低位
  }while(n>0);    //判断是否需要继续逆序
  return m;    //把结果传回main函数，注意题目只需传回逆序数值，而不是相加值
}
//注意：题目要求只需提交inverse函数部分即可
int inverse(int n)

  int m=0;    //定义最终需要返回的结果，注意应赋值为0，不然m的值会随机生成
  do{
      int x=n%10;    //把最低位提取出来
      m=m*10+x;    <qc>//逆序相加</qc>
      n/=10;    //舍弃最低位
  }while(n>0);    //判断是否需要继续逆序
  return m;    //把结果传回main函数，注意题目只需传回逆序数值，而不是相加值
}
//注意：题目要求只需提交inverse函数部分即可
int inverse(int n)

	int m=0;    //定义最终需要返回的结果，注意应赋值为0，不然m的值会随机生成
	do{
	    int x=n%10;    //把最低位提取出来
	    m=m*10+x;    //逆序相加
	    n/=10;    //舍弃最低位
	}while(n>0);    //判断是否需要继续逆序
	return m;    //把结果传回main函数，注意题目只需传回逆序数值，而不是相加值
}

double CancelFee(double price)
{
  double change=0;    //定义并把退票费初始化
  double x=price*0.05;    //先计算退票费用
  double y=(int)(price*0.05);    //保留整数部分
  while(x>=1)    //先把整数部分去掉看小数部分
  {
    x--;
  }
  
  if(x<0.25)    //尾数小于0.25元的舍去
  {
    x=0;
  }
  else if(x>=0.25&&x<0.75)    //不小于0.25元且小于0.75元的计为0.5元
  {
    x=0.5;
  }
  else if(x>=0.75)    //不小于0.75元的进为1元
  {
    x=1;
  }
  change=x+y;    //总退票费
  return change;
}
double CancelFee(double price)
{
  double change=0;    //定义并把退票费初始化
  double x=price*0.05;    //先计算退票费用
  double y=(int)(price*0.05);    //保留整数部分
  while(x>=1)    //先把整数部分去掉看小数部分
  {
    x--;
  }
  
  if(x<0.25)    //尾数小于0.25元的舍去
  {
    x=0;
  }
  else if(x>=0.25&&x<0.75)    //不小于0.25元且小于0.75元的计为0.5元
  {
    x=0.5;
  }
  else if(x>=0.75)    //不小于0.75元的进为1元
  {
    x=1;
  }
  change=x+y;    //总退票费
  return change;
}
double CancelFee(double price)
{
	double change=0;    //定义并把退票费初始化
	double x=price*0.05;    //先计算退票费用
	double y=(int)(price*0.05);    //保留整数部分
	while(x>=1)    //先把整数部分去掉看小数部分
	{
		x--;
	}
	
	if(x<0.25)    //尾数小于0.25元的舍去
	{
		x=0;
	}
	else if(x>=0.25&&x<0.75)    //不小于0.25元且小于0.75元的计为0.5元
	{
		x=0.5;
	}
	else if(x>=0.75)    //不小于0.75元的进为1元
	{
		x=1;
	}
	change=x+y;    //总退票费
	return change;
}

#include<stdio.h>
int GP(int n)
{
  if(n<60)    //低于六十分没有G点
  {
    return 0;
  }
  else
    return (n-50)/10;    //六十分以上算出G点并返回值
}
int main()
{
  int n,m,ncase;
  scanf("%d",&ncase);    //输入n门课程
  double sum1=0,sum2=0;
  while(ncase--)
  {
    scanf("%d %d",&m,&n);    //输入学分和成绩
    sum1+=GP(n)*m;    //算出并累加每门课的绩点乘以该门课的学分
    sum2+=m;    //算出总学分
  }
  printf("%.1f",sum1/sum2);  //输出平均学分绩点，保留一位小数
  return 0;
}
#include<stdio.h>
int GP(int n)
{
  if(n<60)    //低于六十分没有G点
  {
    return 0;
  }
  else
    return (n-50)/10;    //六十分以上算出G点并返回值
}
int main()
{
  int n,m,ncase;
  scanf("%d",&ncase);    //输入n门课程
  double sum1=0,sum2=0;
  while(ncase--)
  {
    scanf("%d %d",&m,&n);    //输入学分和成绩
    sum1+=GP(n)*m;    //算出并累加每门课的绩点乘以该门课的学分
    sum2+=m;    //算出总学分
  }
  printf("%.1f",sum1/sum2);  //输出平均学分绩点，保留一位小数
  return 0;
}
#include<stdio.h>
int GP(int n)
{
	if(n<60)    //低于六十分没有G点
	{
		return 0;
	}
	else
		return (n-50)/10;    //六十分以上算出G点并返回值
}
int main()
{
	int n,m,ncase;
	scanf("%d",&ncase);    //输入n门课程
	double sum1=0,sum2=0;
	while(ncase--)
	{
		scanf("%d %d",&m,&n);    //输入学分和成绩
		sum1+=GP(n)*m;    //算出并累加每门课的绩点乘以该门课的学分
		sum2+=m;    //算出总学分
	}
	printf("%.1f",sum1/sum2);  //输出平均学分绩点，保留一位小数
	return 0;
}

#include<stdio.h>
int FacSum(int n)
{
  int sum=1;    //因为1是肯定有的，直接赋值1减少一次循环，优化算法
  for(int i=2;i<=n/2;i++)    //这里涉及到一个小技巧，因子不可能比的这个数的一半大，所以直接n/2，优化算法提高效率
  {
    if(n%i==0)    //这里遍历一下查找因子
    {
      sum+=i;    //找到直接相加
    }
  }
  return sum;    //把和返回
}
int main()
{
  int n;
  scanf("%d",&n);
  int result=FacSum(n);    //调用并接收函数
  printf("%d",result);
}
#include<stdio.h>
int FacSum(int n)
{
  int sum=1;    //因为1是肯定有的，直接赋值1减少一次循环，优化算法
  for(int i=2;i<=n/2;i++)    //这里涉及到一个小技巧，因子不可能比的这个数的一半大，所以直接n/2，优化算法提高效率
  {
    if(n%i==0)    //这里遍历一下查找因子
    {
      sum+=i;    //找到直接相加
    }
  }
  return sum;    //把和返回
}
int main()
{
  int n;
  scanf("%d",&n);
  int result=FacSum(n);    //调用并接收函数
  printf("%d",result);
}
#include<stdio.h>
int FacSum(int n)
{
	int sum=1;    //因为1是肯定有的，直接赋值1减少一次循环，优化算法
	for(int i=2;i<=n/2;i++)    //这里涉及到一个小技巧，因子不可能比的这个数的一半大，所以直接n/2，优化算法提高效率
	{
		if(n%i==0)    //这里遍历一下查找因子
		{
			sum+=i;    //找到直接相加
		}
	}
	return sum;    //把和返回
}
int main()
{
	int n;
	scanf("%d",&n);
	int result=FacSum(n);    //调用并接收函数
	printf("%d",result);
}

#include<stdio.h>
int facsum(int n)
{
  int sum=0;
  if(n==2)
    return 1;    //2只有一个正因子1（除本身）
  if(n>2)
  {
    for(int i=1;i<n;i++)    //遍历寻找因子
    {
      if(n%i==0)
      {
        sum+=i;    //找到则相加
      }
    }
  }
  return sum;
}
int main()
{
  int m,n,an=0;    //an为标识，用于判断输出
  scanf("%d %d",&m,&n);
  for(int j=m;j<=n;j++)    //遍历m到n之间的数
  {
    int num;
    num=facsum(j);    //调用函数接收正因子之和
    if(j==facsum(num)&&j<num)    //如果俩个数正因子之和相等，且比这个数小，则为友好数对，不加后面那个判断则会输出俩次
    {
      printf("%d %d\n",j,num);
      an=1;    //标识更改
    }
  }
  if(an==0)    //找不到则输出没有答案
    printf("No answer");
  return 0;
}
#include<stdio.h>
int facsum(int n)
{
  int sum=0;
  if(n==2)
    return 1;    //2只有一个正因子1（除本身）
  if(n>2)
  {
    for(int i=1;i<n;i++)    //遍历寻找因子
    {
      if(n%i==0)
      {
        sum+=i;    //找到则相加
      }
    }
  }
  return sum;
}
int main()
{
  int m,n,an=0;    //an为标识，用于判断输出
  scanf("%d %d",&m,&n);
  for(int j=m;j<=n;j++)    //遍历m到n之间的数
  {
    int num;
    num=facsum(j);    //调用函数接收正因子之和
    if(j==facsum(num)&&j<num)    //如果俩个数正因子之和相等，且比这个数小，则为友好数对，不加后面那个判断则会输出俩次
    {
      printf("%d %d\n",j,num);
      an=1;    //标识更改
    }
  }
  if(an==0)    //找不到则输出没有答案
    printf("No answer");
  return 0;
}
#include<stdio.h>
int facsum(int n)
{
	int sum=0;
	if(n==2)
		return 1;    //2只有一个正因子1（除本身）
	if(n>2)
	{
		for(int i=1;i<n;i++)    //遍历寻找因子
		{
			if(n%i==0)
			{
				sum+=i;    //找到则相加
			}
		}
	}
	return sum;
}
int main()
{
	int m,n,an=0;    //an为标识，用于判断输出
	scanf("%d %d",&m,&n);
	for(int j=m;j<=n;j++)    //遍历m到n之间的数
	{
		int num;
		num=facsum(j);    //调用函数接收正因子之和
		if(j==facsum(num)&&j<num)    //如果俩个数正因子之和相等，且比这个数小，则为友好数对，不加后面那个判断则会输出俩次
		{
			printf("%d %d\n",j,num);
			an=1;    //标识更改
		}
	}
	if(an==0)    //找不到则输出没有答案
		printf("No answer");
	return 0;
}

//只需要求出这个数的逆序并判断俩数是否相等即可
#include<stdio.h>
int hws(int i)
{
  int sum=0;
  while(i>9)
  {
    sum+=i%10;
    i/=10;
    sum=sum*10;
  }
  return sum+i;    //返回逆序结果
}
int main()
{
  int m,n;
  scanf("%d %d",&m,&n);
  for(int i=m;i<=n;i++)
  {
    int num=hws(i);
    if(i==num)  //若俩数相等则为回文数
    {
      printf("%d ",i);
    }
  }
  return 0;
}
//只需要求出这个数的逆序并判断俩数是否相等即可
#include<stdio.h>
int hws(int i)
{
  int sum=0;
  while(i>9)
  {
    sum+=i%10;
    i/=10;
    sum=sum*10;
  }
  return sum+i;    //返回逆序结果
}
int main()
{
  int m,n;
  scanf("%d %d",&m,&n);
  for(int i=m;i<=n;i++)
  {
    int num=hws(i);
    if(i==num)  //若俩数相等则为回文数
    {
      printf("%d ",i);
    }
  }
  return 0;
}
//只需要求出这个数的逆序并判断俩数是否相等即可
#include<stdio.h>
int hws(int i)
{
	int sum=0;
	while(i>9)
	{
		sum+=i%10;
		i/=10;
		sum=sum*10;
	}
	return sum+i;    //返回逆序结果
}
int main()
{
	int m,n;
	scanf("%d %d",&m,&n);
	for(int i=m;i<=n;i++)
	{
		int num=hws(i);
		if(i==num)  //若俩数相等则为回文数
		{
			printf("%d ",i);
		}
	}
	return 0;
}

//这题比上一题多加了一个循环判断
#include<stdio.h>
int inverse(int n)
{
  int sum=0;
  while(n>=10)    //求出逆序数
  {
    sum+=n%10;
    n/=10;
    sum*=10;
  }
  return sum+n;
}
int main()
{
  int n,m;
  scanf("%d",&n);
  while(m=inverse(n),m!=n)    //m接收n的倒序数，若不相等则开始循环
  {
    printf("%d ",n);    //输出过程值，注意有空格
    n=m+n;    //正序和倒序相加，开始第二轮循环
  }
  printf("%d",m);    //输出最后的回文数
  return 0;
}
//这题比上一题多加了一个循环判断
#include<stdio.h>
int inverse(int n)
{
  int sum=0;
  while(n>=10)    //求出逆序数
  {
    sum+=n%10;
    n/=10;
    sum*=10;
  }
  return sum+n;
}
int main()
{
  int n,m;
  scanf("%d",&n);
  while(m=inverse(n),m!=n)    //m接收n的倒序数，若不相等则开始循环
  {
    printf("%d ",n);    //输出过程值，注意有空格
    n=m+n;    //正序和倒序相加，开始第二轮循环
  }
  printf("%d",m);    //输出最后的回文数
  return 0;
}
//这题比上一题多加了一个循环判断
#include<stdio.h>
int inverse(int n)
{
	int sum=0;
	while(n>=10)    //求出逆序数
	{
		sum+=n%10;
		n/=10;
		sum*=10;
	}
	return sum+n;
}
int main()
{
	int n,m;
	scanf("%d",&n);
	while(m=inverse(n),m!=n)    //m接收n的倒序数，若不相等则开始循环
	{
		printf("%d ",n);    //输出过程值，注意有空格
		n=m+n;    //正序和倒序相加，开始第二轮循环
	}
	printf("%d",m);    //输出最后的回文数
	return 0;
}

//本题应找出每行空格与数字的规律
#include<stdio.h>
void PrintDigit(int m)
{
  for(int i=1;i<=m;i++)    //左边逐递增
  {
    printf("%d",i);
  }
  m--;    //使m-1，不输出最高位
  while(m>=1)    //右边逐渐递减
  {
    printf("%d",m--);
  }
}
void PrintSpace(int m)    //打印空格
{
  for(int i=0;i<m;i++)
  {
    printf(" ");
  }
}
int main()
{
  int m;
  scanf("%d",&m);
  for(int i=1;i<=m;i++)    //打印上半部分
  {
    PrintSpace(m-i);    //上半部分空格逐渐递减
    PrintDigit(i);    //数字逐渐增加
    printf("\n");    //换行
  }
  for(int j=1;j<m;j++)    //打印下半部分
  {
    PrintSpace(j);    //空格逐渐递增
    PrintDigit(m-j);    //数字逐渐减少
    if(j!=m-1)    //该判断可以使最后一行不用换行
      printf("\n");
  }
  return 0;
}
//本题应找出每行空格与数字的规律
#include<stdio.h>
void PrintDigit(int m)
{
  for(int i=1;i<=m;i++)    //左边逐递增
  {
    printf("%d",i);
  }
  m--;    //使m-1，不输出最高位
  while(m>=1)    //右边逐渐递减
  {
    printf("%d",m--);
  }
}
void PrintSpace(int m)    //打印空格
{
  for(int i=0;i<m;i++)
  {
    printf(" ");
  }
}
int main()
{
  int m;
  scanf("%d",&m);
  for(int i=1;i<=m;i++)    //打印上半部分
  {
    PrintSpace(m-i);    //上半部分空格逐渐递减
    PrintDigit(i);    //数字逐渐增加
    printf("\n");    //换行
  }
  for(int j=1;j<m;j++)    //打印下半部分
  {
    PrintSpace(j);    //空格逐渐递增
    PrintDigit(m-j);    //数字逐渐减少
    if(j!=m-1)    //该判断可以使最后一行不用换行
      printf("\n");
  }
  return 0;
}
//本题应找出每行空格与数字的规律
#include<stdio.h>
void PrintDigit(int m)
{
	for(int i=1;i<=m;i++)    //左边逐递增
	{
		printf("%d",i);
	}
	m--;    //使m-1，不输出最高位
	while(m>=1)    //右边逐渐递减
	{
		printf("%d",m--);
	}
}
void PrintSpace(int m)    //打印空格
{
	for(int i=0;i<m;i++)
	{
		printf(" ");
	}
}
int main()
{
	int m;
	scanf("%d",&m);
	for(int i=1;i<=m;i++)    //打印上半部分
	{
		PrintSpace(m-i);    //上半部分空格逐渐递减
		PrintDigit(i);    //数字逐渐增加
		printf("\n");    //换行
	}
	for(int j=1;j<m;j++)    //打印下半部分
	{
		PrintSpace(j);    //空格逐渐递增
		PrintDigit(m-j);    //数字逐渐减少
		if(j!=m-1)    //该判断可以使最后一行不用换行
			printf("\n");
	}
	return 0;
}

#include<stdio.h>
int digitSum(int n)
{
  int sum=0;
  while(n>9)    //只要是大于或等于俩位数就分离
  {
    sum+=n%10;    //提取最低位并相加
    n/=10;    //除去最低位
  }
  return sum+n;    //返回各个位上数字的和
}
int main()
{
  int n,x;
  scanf("%d",&n);
  if(n>9)
  {
    x=digitSum(n);    //调用函数并接收函数返回的值
    while(x>9)    //如果返回的值还是俩位数或以上则继续相加
    {
      int t=n;
      n=x;
      x=t;
      x=digitSum(n);
    }
    printf("%d",x);
  }
  else
    printf("%d",n);
  return 0;
}
#include<stdio.h>
int digitSum(int n)
{
  int sum=0;
  while(n>9)    //只要是大于或等于俩位数就分离
  {
    sum+=n%10;    //提取最低位并相加
    n/=10;    //除去最低位
  }
  return sum+n;    //返回各个位上数字的和
}
int main()
{
  int n,x;
  scanf("%d",&n);
  if(n>9)
  {
    x=digitSum(n);    //调用函数并接收函数返回的值
    while(x>9)    //如果返回的值还是俩位数或以上则继续相加
    {
      int t=n;
      n=x;
      x=t;
      x=digitSum(n);
    }
    printf("%d",x);
  }
  else
    printf("%d",n);
  return 0;
}
#include<stdio.h>
int digitSum(int n)
{
	int sum=0;
	while(n>9)    //只要是大于或等于俩位数就分离
	{
		sum+=n%10;    //提取最低位并相加
		n/=10;    //除去最低位
	}
	return sum+n;    //返回各个位上数字的和
}
int main()
{
	int n,x;
	scanf("%d",&n);
	if(n>9)
	{
		x=digitSum(n);    //调用函数并接收函数返回的值
		while(x>9)    //如果返回的值还是俩位数或以上则继续相加
		{
			int t=n;
			n=x;
			x=t;
			x=digitSum(n);
		}
		printf("%d",x);
	}
	else
		printf("%d",n);
	return 0;
}

/*观察图中孩子与双亲的关系，如果双亲编号为i，左孩子为2*i,右孩子为2*i+1。反之，对于一个编号为i的结点，不论奇数偶数，除以2取整就是i。所以我们可以用递归让较大的数（也就是辈分低的数）向上找双亲，直到他们相遇*/
#include<stdio.h>
int common(int x,int y)
{
    if(x==y)    //如果相等，x的值则为共同祖先
        return x;
    else if(x>y)
    {
        return common(x / 2, y);    //若x较大则让x向上走
    }
    else
        return common(x, y / 2);    //若y较大则让y向上走
}
int main()
{
    int x, y,j;
    scanf("%d %d", &x, &y);
    j = common(x, y);    //调用并接收函数传递回来的值
    printf("%d", j);
}
/*观察图中孩子与双亲的关系，如果双亲编号为i，左孩子为2*i,右孩子为2*i+1。反之，对于一个编号为i的结点，不论奇数偶数，除以2取整就是i。所以我们可以用递归让较大的数（也就是辈分低的数）向上找双亲，直到他们相遇*/
#include<stdio.h>
int common(int x,int y)
{
    if(x==y)    //如果相等，x的值则为共同祖先
        return x;
    else if(x>y)
    {
        return common(x / 2, y);    //若x较大则让x向上走
    }
    else
        return common(x, y / 2);    //若y较大则让y向上走
}
int main()
{
    int x, y,j;
    scanf("%d %d", &x, &y);
    j = common(x, y);    //调用并接收函数传递回来的值
    printf("%d", j);
}
/*观察图中孩子与双亲的关系，如果双亲编号为i，左孩子为2*i,右孩子为2*i+1。反之，对于一个编号为i的结点，不论奇数偶数，除以2取整就是i。所以我们可以用递归让较大的数（也就是辈分低的数）向上找双亲，直到他们相遇*/
#include<stdio.h>
int common(int x,int y)
{
    if(x==y)    //如果相等，x的值则为共同祖先
        return x;
    else if(x>y)
    {
        return common(x / 2, y);    //若x较大则让x向上走
    }
    else
        return common(x, y / 2);    //若y较大则让y向上走
}
int main()
{
    int x, y,j;
    scanf("%d %d", &x, &y);
    j = common(x, y);    //调用并接收函数传递回来的值
    printf("%d", j);
}

//好好理解一下递归捏
#include<stdio.h>
void inverse(int n)
{
    int num;
    scanf("%d", &num);    //读一个整数存入num
    if(n>1)    //如果n有多个数则开始递归逆序输出
    {
        inverse(n - 1);
        printf("%d ", num);
    }
    if(n==1)    //若只有一行则直接输出
        printf("%d ", num);
}
int main()
{
    int n;
    scanf("%d", &n);
    inverse(n);    //调用函数
    return 0;
}
//好好理解一下递归捏
#include<stdio.h>
void inverse(int n)
{
    int num;
    scanf("%d", &num);    //读一个整数存入num
    if(n>1)    //如果n有多个数则开始递归逆序输出
    {
        inverse(n - 1);
        printf("%d ", num);
    }
    if(n==1)    //若只有一行则直接输出
        printf("%d ", num);
}
int main()
{
    int n;
    scanf("%d", &n);
    inverse(n);    //调用函数
    return 0;
}
//好好理解一下递归捏
#include<stdio.h>
void inverse(int n)
{
    int num;
    scanf("%d", &num);    //读一个整数存入num
    if(n>1)    //如果n有多个数则开始递归逆序输出
    {
        inverse(n - 1);
        printf("%d ", num);
    }
    if(n==1)    //若只有一行则直接输出
        printf("%d ", num);
}
int main()
{
    int n;
    scanf("%d", &n);
    inverse(n);    //调用函数
    return 0;
}

//特别简单，明白递归的原理，直接倒序输出就好了
#include<stdio.h>
void convert(int n)
{
    if(n>0)    //使用递归倒序输出余数
    {
        convert(n / 2);
        printf("%d", n % 2);
    }
}
int main()
{
    int n;
    scanf("%d", &n);
    convert(n);
}
//特别简单，明白递归的原理，直接倒序输出就好了
#include<stdio.h>
void convert(int n)
{
    if(n>0)    //使用递归倒序输出余数
    {
        convert(n / 2);
        printf("%d", n % 2);
    }
}
int main()
{
    int n;
    scanf("%d", &n);
    convert(n);
}
//特别简单，明白递归的原理，直接倒序输出就好了
#include<stdio.h>
void convert(int n)
{
    if(n>0)    //使用递归倒序输出余数
    {
        convert(n / 2);
        printf("%d", n % 2);
    }
}
int main()
{
    int n;
    scanf("%d", &n);
    convert(n);
}

//题目给了斐波那契数列的求法，我们只需填充枝叶即可
#include<stdio.h>
int fib(int k)
{
    if(k==1||k==2)
        return 1;
    else     //
        return fib(k - 1) + fib(k - 2);
}
int main()
{
    int n;
    scanf("%d", &n);
    printf("%d\n", fib(n));
    printf("递归调用了%d次", 2*fib(n)-1);    //我们仔细观察函数，发现else的return有俩个递归，所以次数为2*fib(n)-1次
    return 0;
}
//题目给了斐波那契数列的求法，我们只需填充枝叶即可
#include<stdio.h>
int fib(int k)
{
    if(k==1||k==2)
        return 1;
    else     //
        return fib(k - 1) + fib(k - 2);
}
int main()
{
    int n;
    scanf("%d", &n);
    printf("%d\n", fib(n));
    printf("递归调用了%d次", 2*fib(n)-1);    //我们仔细观察函数，发现else的return有俩个递归，所以次数为2*fib(n)-1次
    return 0;
}
//题目给了斐波那契数列的求法，我们只需填充枝叶即可
#include<stdio.h>
int fib(int k)
{
    if(k==1||k==2)
        return 1;
    else     //
        return fib(k - 1) + fib(k - 2);
}
int main()
{
    int n;
    scanf("%d", &n);
    printf("%d\n", fib(n));
    printf("递归调用了%d次", 2*fib(n)-1);    //我们仔细观察函数，发现else的return有俩个递归，所以次数为2*fib(n)-1次
    return 0;
}

//本题考察的是对数组下标的理解
#include<stdio.h>
int main()
{
  int n;
  scanf("%d",&n);
  
  int  arr[n];    //定义一个长度为n的数组
  for(int i=0;i<n;i++)    //数组下标从0开始数
  {
    scanf("%d",&arr[i]);    //依次把值存进数组
  }
  for(int i=n-1;i>=0;i--)    //数组最大下标为长度-1，然后倒序输出
  {
    printf("%4d",arr[i]);    //占四列，右对齐
  }
  return 0;
}
//本题考察的是对数组下标的理解
#include<stdio.h>
int main()
{
  int n;
  scanf("%d",&n);
  
  int  arr[n];    //定义一个长度为n的数组
  for(int i=0;i<n;i++)    //数组下标从0开始数
  {
    scanf("%d",&arr[i]);    //依次把值存进数组
  }
  for(int i=n-1;i>=0;i--)    //数组最大下标为长度-1，然后倒序输出
  {
    printf("%4d",arr[i]);    //占四列，右对齐
  }
  return 0;
}
//本题考察的是对数组下标的理解
#include<stdio.h>
int main()
{
	int n;
	scanf("%d",&n);
	
	int  arr[n];    //定义一个长度为n的数组
	for(int i=0;i<n;i++)    //数组下标从0开始数
	{
		scanf("%d",&arr[i]);    //依次把值存进数组
	}
	for(int i=n-1;i>=0;i--)    //数组最大下标为长度-1，然后倒序输出
	{
		printf("%4d",arr[i]);    //占四列，右对齐
	}
	return 0;
}

#include <stdio.h>
int main () {
    int n, a = 0;
    scanf("%d", &n);
    int room[1000];    //n不大于1000，即数组的长度不大于1000
    for (int i = 0; i < n; i++)     //读入数组
    {
        scanf("%d", &room[i]);
    }
    int min = room[0];
    for (int j = 0; j < n; j++)
    {
        if (min > room[j])    //一个简单的排序找出最小值
        {
            min = room[j];
            a = j;
        }
    }
    printf("%d %d", min, a);    //输出最小值及其下标
    return 0;
}
#include <stdio.h>

int main () {
    int n, a = 0;
    scanf("%d", &n);
    int room[1000];    //n不大于1000，即数组的长度不大于1000
    for (int i = 0; i < n; i++)     //读入数组
    {
        scanf("%d", &room[i]);
    }
    int min = room[0];
    for (int j = 0; j < n; j++)
    {
        if (min > room[j])    //一个简单的排序找出最小值
        {
            min = room[j];
            a = j;
        }
    }
    printf("%d %d", min, a);    //输出最小值及其下标
    return 0;
}
#include <stdio.h>

int main () {
    int n, a = 0;
    scanf("%d", &n);
    int room[1000];    //n不大于1000，即数组的长度不大于1000
    for (int i = 0; i < n; i++)     //读入数组
    {
        scanf("%d", &room[i]);
    }
    int min = room[0];
    for (int j = 0; j < n; j++)
    {
        if (min > room[j])    //一个简单的排序找出最小值
        {
            min = room[j];
            a = j;
        }
    }
    printf("%d %d", min, a);    //输出最小值及其下标
    return 0;
}

#include <stdio.h>
// 删除数组A中下标为i的元素
void del(int a[], int n, int i)
{
  // 判断i是否超出数组范围
  if (i < 0 || i >= n)
  {
    printf("Invalid index\n");
    return;
  }
  // 将数组A中下标为i的元素之后的元素向前移动一位
  for (int j = i; j < n - 1; j++)
  {
    a[j] = a[j + 1];
  }
  // 数组长度减1
  n--;
}
// 打印数组A
void PrintArr(int a[], int n)
{
  // 遍历数组A
  for (int i = 0; i < n; i++)
  {
    printf("%d", a[i]);
    if (i < n - 1)
    {
      printf(" ");
    }
  }
  printf("\n");
}
int main()
{
  // 输入数组长度和要删除的元素下标
  int n, i;
  scanf("%d", &n);
  int A[n];
  // 输入数组A的元素
  for (int i = 0; i < n; i++)
  {
    scanf("%d", &A[i]);
  }
  scanf("%d", &i);
  // 调用del函数删除数组A中下标为i的元素
  del(A, n, i);
  // 打印删除元素后的数组
  PrintArr(A, n - 1); // 输出删除元素后的数组，跳过最后一个元素
  return 0;
}
#include <stdio.h>

// 删除数组A中下标为i的元素
void del(int a[], int n, int i)
{
  // 判断i是否超出数组范围
  if (i < 0 || i >= n)
  {
    printf("Invalid index\n");
    return;
  }
  // 将数组A中下标为i的元素之后的元素向前移动一位
  for (int j = i; j < n - 1; j++)
  {
    a[j] = a[j + 1];
  }
  // 数组长度减1
  n--;
}

// 打印数组A
void PrintArr(int a[], int n)
{
  // 遍历数组A
  for (int i = 0; i < n; i++)
  {
    printf("%d", a[i]);
    if (i < n - 1)
    {
      printf(" ");
    }
  }
  printf("\n");
}

int main()
{
  // 输入数组长度和要删除的元素下标
  int n, i;
  scanf("%d", &n);
  int A[n];
  // 输入数组A的元素
  for (int i = 0; i < n; i++)
  {
    scanf("%d", &A[i]);
  }
  scanf("%d", &i);
  // 调用del函数删除数组A中下标为i的元素
  del(A, n, i);
  // 打印删除元素后的数组
  PrintArr(A, n - 1); // 输出删除元素后的数组，跳过最后一个元素
  return 0;
}
#include <stdio.h>

// 删除数组A中下标为i的元素
void del(int a[], int n, int i)
{
	// 判断i是否超出数组范围
	if (i < 0 || i >= n)
	{
		printf("Invalid index\n");
		return;
	}
	// 将数组A中下标为i的元素之后的元素向前移动一位
	for (int j = i; j < n - 1; j++)
	{
		a[j] = a[j + 1];
	}
	// 数组长度减1
	n--;
}

// 打印数组A
void PrintArr(int a[], int n)
{
	// 遍历数组A
	for (int i = 0; i < n; i++)
	{
		printf("%d", a[i]);
		if (i < n - 1)
		{
			printf(" ");
		}
	}
	printf("\n");
}

int main()
{
	// 输入数组长度和要删除的元素下标
	int n, i;
	scanf("%d", &n);
	int A[n];
	// 输入数组A的元素
	for (int i = 0; i < n; i++)
	{
		scanf("%d", &A[i]);
	}
	scanf("%d", &i);
	// 调用del函数删除数组A中下标为i的元素
	del(A, n, i);
	// 打印删除元素后的数组
	PrintArr(A, n - 1); // 输出删除元素后的数组，跳过最后一个元素
	return 0;
}

#include<stdio.h>
//函数find用于查找数组a中元素x的位置
int find(int a[],int *n,int x)
{
  int t=-1;
  //遍历数组a，查找元素x的位置
  for(int i=0;i<*n;i++)
  {
    if(x==a[i])
    {
      t=i;
      return t;
      break;
    }
  }
  return t;
}
//函数del用于删除数组a中元素x的位置
void del(int a[],int *n,int x)
{  
  //从x位置开始，将数组a中后面的元素向前移动一位
  for(int j=x-1;j<*n-1;j++)
  {
    a[j]=a[j+1];
  }
  (*n)--;
}
//函数PrintArr用于打印数组a
void PrintArr(int a[],int n)
{
  //遍历数组a，打印每一个元素
  for(int i=0;i<n;i++)
  {
    printf("%4d",a[i]);
  }
  printf("\n");
}
int main()
{
  int t;
  int n,x;
  //输入数组a的长度
  scanf("%d",&n);
  //定义一个长度为n的数组a
  int a[n];
  //输入数组a的每一个元素
  for(int i=0;i<n;i++)
  {
    scanf("%d",&a[i]);
  }
  //输入要查找的元素x
  scanf("%d",&x);
  //调用函数find，查找元素x的位置
  t=find(a,&n,x);
  //如果元素x不存在，则输出Not Found
  if(t==-1)
  {
    printf("Not Found");
  }
  //如果元素x存在，则调用函数del，删除元素x的位置，并打印新的数组a
  else
  {
    del(a,&n,x);
    PrintArr(a,n);
  }
  return 0;
}
#include<stdio.h>
//函数find用于查找数组a中元素x的位置
int find(int a[],int *n,int x)
{
  int t=-1;
  //遍历数组a，查找元素x的位置
  for(int i=0;i<*n;i++)
  {
    if(x==a[i])
    {
      t=i;
      return t;
      break;
    }
  }
  return t;
}
//函数del用于删除数组a中元素x的位置
void del(int a[],int *n,int x)
{  
  //从x位置开始，将数组a中后面的元素向前移动一位
  for(int j=x-1;j<*n-1;j++)
  {
    a[j]=a[j+1];
  }
  (*n)--;
}
//函数PrintArr用于打印数组a
void PrintArr(int a[],int n)
{
  //遍历数组a，打印每一个元素
  for(int i=0;i<n;i++)
  {
    printf("%4d",a[i]);
  }
  printf("\n");
}
int main()
{
  int t;
  int n,x;
  //输入数组a的长度
  scanf("%d",&n);
  //定义一个长度为n的数组a
  int a[n];
  //输入数组a的每一个元素
  for(int i=0;i<n;i++)
  {
    scanf("%d",&a[i]);
  }
  //输入要查找的元素x
  scanf("%d",&x);
  //调用函数find，查找元素x的位置
  t=find(a,&n,x);
  //如果元素x不存在，则输出Not Found
  if(t==-1)
  {
    printf("Not Found");
  }
  //如果元素x存在，则调用函数del，删除元素x的位置，并打印新的数组a
  else
  {
    del(a,&n,x);
    PrintArr(a,n);
  }
  return 0;
}
#include<stdio.h>
//函数find用于查找数组a中元素x的位置
int find(int a[],int *n,int x)
{
	int t=-1;
	//遍历数组a，查找元素x的位置
	for(int i=0;i<*n;i++)
	{
		if(x==a[i])
		{
			t=i;
			return t;
			break;
		}
	}
	return t;
}
//函数del用于删除数组a中元素x的位置
void del(int a[],int *n,int x)
{	
	//从x位置开始，将数组a中后面的元素向前移动一位
	for(int j=x-1;j<*n-1;j++)
	{
		a[j]=a[j+1];
	}
	(*n)--;
}
//函数PrintArr用于打印数组a
void PrintArr(int a[],int n)
{
	//遍历数组a，打印每一个元素
	for(int i=0;i<n;i++)
	{
		printf("%4d",a[i]);
	}
	printf("\n");
}
int main()
{
	int t;
	int n,x;
	//输入数组a的长度
	scanf("%d",&n);
	//定义一个长度为n的数组a
	int a[n];
	//输入数组a的每一个元素
	for(int i=0;i<n;i++)
	{
		scanf("%d",&a[i]);
	}
	//输入要查找的元素x
	scanf("%d",&x);
	//调用函数find，查找元素x的位置
	t=find(a,&n,x);
	//如果元素x不存在，则输出Not Found
	if(t==-1)
	{
		printf("Not Found");
	}
	//如果元素x存在，则调用函数del，删除元素x的位置，并打印新的数组a
	else
	{
		del(a,&n,x);
		PrintArr(a,n);
	}
	return 0;
}

#include<stdio.h>
void insert(int a[],int n,int num)
{
  //将num插入到a数组中
  a[n]=num;
  n++;
  //冒泡排序
  for(int i=0;i<n-1;i++)
  {
    for(int j=0;j<n-1-i;j++)
    {
      if(a[j]>a[j+1])
      {
        int t=a[j];
        a[j]=a[j+1];
        a[j+1]=t;
      }
    }
  }
}
void PrintArr(int a[],int n)
{
  //打印数组
  for(int i=0;i<n+1;i++)
  {
    printf("%d",a[i]);
    if(i<n)
    {
      printf(" ");
    }
  }
}
int main()
{
  //输入数组大小
  int n;
  scanf("%d",&n);
  //初始化数组
  int a[n];
  //输入数组元素
  for(int i=0;i<n;i++)
  {
    scanf("%d",&a[i]);
  }
  //输入插入的元素
  int num;
  scanf("%d",&num);
  //插入元素
  insert(a,n,num);
  //打印数组
  PrintArr(a,n);
  return 0;
}
#include<stdio.h>
void insert(int a[],int n,int num)
{
  //将num插入到a数组中
  a[n]=num;
  n++;
  //冒泡排序
  for(int i=0;i<n-1;i++)
  {
    for(int j=0;j<n-1-i;j++)
    {
      if(a[j]>a[j+1])
      {
        int t=a[j];
        a[j]=a[j+1];
        a[j+1]=t;
      }
    }
  }
}
void PrintArr(int a[],int n)
{
  //打印数组
  for(int i=0;i<n+1;i++)
  {
    printf("%d",a[i]);
    if(i<n)
    {
      printf(" ");
    }
  }
}
int main()
{
  //输入数组大小
  int n;
  scanf("%d",&n);
  //初始化数组
  int a[n];
  //输入数组元素
  for(int i=0;i<n;i++)
  {
    scanf("%d",&a[i]);
  }
  //输入插入的元素
  int num;
  scanf("%d",&num);
  //插入元素
  insert(a,n,num);
  //打印数组
  PrintArr(a,n);
  return 0;
}
#include<stdio.h>
void insert(int a[],int n,int num)
{
	//将num插入到a数组中
	a[n]=num;
	n++;
	//冒泡排序
	for(int i=0;i<n-1;i++)
	{
		for(int j=0;j<n-1-i;j++)
		{
			if(a[j]>a[j+1])
			{
				int t=a[j];
				a[j]=a[j+1];
				a[j+1]=t;
			}
		}
	}
}
void PrintArr(int a[],int n)
{
	//打印数组
	for(int i=0;i<n+1;i++)
	{
		printf("%d",a[i]);
		if(i<n)
		{
			printf(" ");
		}
	}
}
int main()
{
	//输入数组大小
	int n;
	scanf("%d",&n);
	//初始化数组
	int a[n];
	//输入数组元素
	for(int i=0;i<n;i++)
	{
		scanf("%d",&a[i]);
	}
	//输入插入的元素
	int num;
	scanf("%d",&num);
	//插入元素
	insert(a,n,num);
	//打印数组
	PrintArr(a,n);
	return 0;
}

#include<stdio.h>
void sort(int a[],int n)
{
  //冒泡排序
  for(int i=0;i<n-1;i++)
  {
    for(int j=0;j<n-1-i;j++)
    {
      if(a[j]>a[j+1])
      {
        int t=a[j];
        a[j]=a[j+1];
        a[j+1]=t;
      }
    }
  }
}
void PrintArr(int a[],int n)
{
  //输出数组
  for(int i=0;i<n;i++)
  {
    printf("%d",a[i]);
    if(i<n-1)
    {
      printf(" ");
    }
  }
}
int main()
{
  //输入数组长度
  int n;
  scanf("%d",&n);
  int a[n];
  //输入数组元素
  for(int i=0;i<n;i++)
  {
    scanf("%d",&a[i]);
  }
  //调用冒泡排序函数
  sort(a,n);
  //输出排序后的数组
  PrintArr(a,n);
  return 0;
}
#include<stdio.h>
void sort(int a[],int n)
{
  //冒泡排序
  for(int i=0;i<n-1;i++)
  {
    for(int j=0;j<n-1-i;j++)
    {
      if(a[j]>a[j+1])
      {
        int t=a[j];
        a[j]=a[j+1];
        a[j+1]=t;
      }
    }
  }
}
void PrintArr(int a[],int n)
{
  //输出数组
  for(int i=0;i<n;i++)
  {
    printf("%d",a[i]);
    if(i<n-1)
    {
      printf(" ");
    }
  }
}
int main()
{
  //输入数组长度
  int n;
  scanf("%d",&n);
  int a[n];
  //输入数组元素
  for(int i=0;i<n;i++)
  {
    scanf("%d",&a[i]);
  }
  //调用冒泡排序函数
  sort(a,n);
  //输出排序后的数组
  PrintArr(a,n);
  return 0;
}
#include<stdio.h>
void sort(int a[],int n)
{
	//冒泡排序
	for(int i=0;i<n-1;i++)
	{
		for(int j=0;j<n-1-i;j++)
		{
			if(a[j]>a[j+1])
			{
				int t=a[j];
				a[j]=a[j+1];
				a[j+1]=t;
			}
		}
	}
}
void PrintArr(int a[],int n)
{
	//输出数组
	for(int i=0;i<n;i++)
	{
		printf("%d",a[i]);
		if(i<n-1)
		{
			printf(" ");
		}
	}
}
int main()
{
	//输入数组长度
	int n;
	scanf("%d",&n);
	int a[n];
	//输入数组元素
	for(int i=0;i<n;i++)
	{
		scanf("%d",&a[i]);
	}
	//调用冒泡排序函数
	sort(a,n);
	//输出排序后的数组
	PrintArr(a,n);
	return 0;
}

#include<stdio.h>
int MinIndex(int a[],int n)
{
    int min = a[0],down=0;    //最小值和下标初始为第一个
    for (int i = 0; i < n;i++)
    {
        if(a[i]<min)    //如果遍历出来的数比最小值小
        {
            min = a[i];    //替换最小值
            down = i;    //记录下标
        }
    }
    return down;
}
int MaxIndex(int a[],int n)
{
    int max = a[0], down = n - 1;     //最大值和下标初始为最后一个
    for (int i = 0; i < n; i++)
    {
        if (a[i] > max)     // 如果遍历出来的数比最大值大
        {
            max = a[i];    //替换最大值
            down = i;    //记录下标
        }
    }
    return down;
}
void PrintArr(int a[],int n)    //打印函数
{
    for (int i = 0; i < n ;i++)
    {
        printf("%d", a[i]);
        if(i<n-1)
        {
            printf(" ");
        }
    }
}
int main()
{
    int n,x,y,t;
    int a[15];
    scanf("%d", &n);
    for (int i = 0; i < n;i++)
    {
        scanf("%d", &a[i]);
    }
    x=MinIndex(a, n);    //最小值和第一个交换
    t = a[0];
    a[0] = a[x];
    a[x] = t;
    y=MaxIndex(a, n);    //最大值与最后一个交换
    t = a[n - 1];
    a[n - 1] = a[y];
    a[y] = t;
    PrintArr(a, n);
    return 0;
}
#include<stdio.h>
int MinIndex(int a[],int n)
{
    int min = a[0],down=0;    //最小值和下标初始为第一个
    for (int i = 0; i < n;i++)
    {
        if(a[i]<min)    //如果遍历出来的数比最小值小
        {
            min = a[i];    //替换最小值
            down = i;    //记录下标
        }
    }
    return down;
}
int MaxIndex(int a[],int n)
{
    int max = a[0], down = n - 1;     //最大值和下标初始为最后一个
    for (int i = 0; i < n; i++)
    {
        if (a[i] > max)     // 如果遍历出来的数比最大值大
        {
            max = a[i];    //替换最大值
            down = i;    //记录下标
        }
    }
    return down;
}
void PrintArr(int a[],int n)    //打印函数
{
    for (int i = 0; i < n ;i++)
    {
        printf("%d", a[i]);
        if(i<n-1)
        {
            printf(" ");
        }
    }
}
int main()
{
    int n,x,y,t;
    int a[15];
    scanf("%d", &n);
    for (int i = 0; i < n;i++)
    {
        scanf("%d", &a[i]);
    }
    x=MinIndex(a, n);    //最小值和第一个交换
    t = a[0];
    a[0] = a[x];
    a[x] = t;
    y=MaxIndex(a, n);    //最大值与最后一个交换
    t = a[n - 1];
    a[n - 1] = a[y];
    a[y] = t;
    PrintArr(a, n);
    return 0;
}
#include<stdio.h>
int MinIndex(int a[],int n)
{
    int min = a[0],down=0;    //最小值和下标初始为第一个
    for (int i = 0; i < n;i++)
    {
        if(a[i]<min)    //如果遍历出来的数比最小值小
        {
            min = a[i];    //替换最小值
            down = i;    //记录下标
        }
    }
    return down;
}
int MaxIndex(int a[],int n)
{
    int max = a[0], down = n - 1;     //最大值和下标初始为最后一个
    for (int i = 0; i < n; i++)
    {
        if (a[i] > max)     // 如果遍历出来的数比最大值大
        {
            max = a[i];    //替换最大值
            down = i;    //记录下标
        }
    }
    return down;
}
void PrintArr(int a[],int n)    //打印函数
{
    for (int i = 0; i < n ;i++)
    {
        printf("%d", a[i]);
        if(i<n-1)
        {
            printf(" ");
        }
    }
}
int main()
{
    int n,x,y,t;
    int a[15];
    scanf("%d", &n);
    for (int i = 0; i < n;i++)
    {
        scanf("%d", &a[i]);
    }
    x=MinIndex(a, n);    //最小值和第一个交换
    t = a[0];
    a[0] = a[x];
    a[x] = t;
    y=MaxIndex(a, n);    //最大值与最后一个交换
    t = a[n - 1];
    a[n - 1] = a[y];
    a[y] = t;
    PrintArr(a, n);
    return 0;
}

#include <stdio.h>
// 检查矩阵是否为上三角矩阵
int IsUpperTriMatrix(int a[][10], int n)
{
    // 遍历矩阵的每一行
    for (int i = 1; i < n; i++)
    {
        // 遍历当前行的每一列
        for (int j = 0; j < i; j++)
        {
            // 如果当前列的元素不为0，则说明矩阵不是上三角矩阵
            if (a[i][j] != 0)
            {
                return 0;
            }
        }
    }
    // 如果遍历完矩阵的每一行，说明矩阵是上三角矩阵
    return 1;
}
int main()
{
    // 读取矩阵的行数
    int n, i, j;
    scanf("%d", &n);
    // 初始化一个n*n的矩阵
    int a[10][10];
    // 读取矩阵的每一个元素
    for (i = 0; i < n; i++)
    {
        for (j = 0; j < n; j++)
        {
            scanf("%d", &a[i][j]);
        }
    }
    // 调用函数检查矩阵是否为上三角矩阵
    if (IsUpperTriMatrix(a, n))
    {
        printf("YES\n");
    }
    else
    {
        printf("NO\n");
    }
    return 0;
}
#include <stdio.h>

// 检查矩阵是否为上三角矩阵
int IsUpperTriMatrix(int a[][10], int n)
{
    // 遍历矩阵的每一行
    for (int i = 1; i < n; i++)
    {
        // 遍历当前行的每一列
        for (int j = 0; j < i; j++)
        {
            // 如果当前列的元素不为0，则说明矩阵不是上三角矩阵
            if (a[i][j] != 0)
            {
                return 0;
            }
        }
    }
    // 如果遍历完矩阵的每一行，说明矩阵是上三角矩阵
    return 1;
}

int main()
{
    // 读取矩阵的行数
    int n, i, j;
    scanf("%d", &n);
    // 初始化一个n*n的矩阵
    int a[10][10];
    // 读取矩阵的每一个元素
    for (i = 0; i < n; i++)
    {
        for (j = 0; j < n; j++)
        {
            scanf("%d", &a[i][j]);
        }
    }
    // 调用函数检查矩阵是否为上三角矩阵
    if (IsUpperTriMatrix(a, n))
    {
        printf("YES\n");
    }
    else
    {
        printf("NO\n");
    }
    return 0;
}
#include <stdio.h>

// 检查矩阵是否为上三角矩阵
int IsUpperTriMatrix(int a[][10], int n)
{
    // 遍历矩阵的每一行
    for (int i = 1; i < n; i++)
    {
        // 遍历当前行的每一列
        for (int j = 0; j < i; j++)
        {
            // 如果当前列的元素不为0，则说明矩阵不是上三角矩阵
            if (a[i][j] != 0)
            {
                return 0;
            }
        }
    }
    // 如果遍历完矩阵的每一行，说明矩阵是上三角矩阵
    return 1;
}

int main()
{
    // 读取矩阵的行数
    int n, i, j;
    scanf("%d", &n);
    // 初始化一个n*n的矩阵
    int a[10][10];
    // 读取矩阵的每一个元素
    for (i = 0; i < n; i++)
    {
        for (j = 0; j < n; j++)
        {
            scanf("%d", &a[i][j]);
        }
    }
    // 调用函数检查矩阵是否为上三角矩阵
    if (IsUpperTriMatrix(a, n))
    {
        printf("YES\n");
    }
    else
    {
        printf("NO\n");
    }
    return 0;
}

#include <stdio.h>
int boolf(int a[][100], int n)
{
    // 定义两个标志变量，用于记录异常的行和列
    int flag1 = 0, flag2 = 0, x, y;
    // 遍历每一行，检查每一行的和是否为奇数
    for (int i = 0; i < n ; i++)
    {
        int sum = 0;
        // 计算每一行的和
        for (int j = 0; j < n ; j++)
        {
            sum += a[i][j];
        }
        // 如果和为奇数，则记录异常的行
        if (sum % 2 != 0)
        {
            flag1++;
            x = i;
        }
    }
    // 遍历每一列，检查每一列的和是否为奇数
    for (int i = 0; i < n ; i++)
    {
        int sum = 0;
        // 计算每一列的和
        for (int j = 0; j < n ; j++)
        {
            sum += a[j][i];
        }
        // 如果和为奇数，则记录异常的列
        if (sum % 2 != 0)
        {
            flag2++;
            y = i;
        }
    }
    // 如果异常的行和列都为0，则说明没有异常，输出OK
    if (flag1 == 0 && flag2 == 0)
    {
        printf("OK");
    }
    // 如果异常的行和列只有一个，则说明只修改一个位置，输出修改位置的行列坐标
    else if (flag1 == 1 && flag2 == 1)
    {
        printf("Change bit(%d,%d)", x, y);
    }
    // 如果异常的行和列有两个，则说明整张图片异常，输出corrupt
    else
        printf("Corrupt");
}
int main()
{
    // 定义一个变量，用于存储图片的行数
    int n;
    // 定义一个二维数组，用于存储图片的像素值
    int a[100][100];
    // 读取图片的行数
    scanf("%d", &n);
    // 读取图片的像素值
    for (int i = 0; i < n ; i++)
    {
        for (int j = 0; j < n ; j++)
        {
            scanf("%d", &a[i][j]);
        }
    }
    // 调用boolf函数，检查图片是否异常
    boolf(a, n);
    return 0;
}
#include <stdio.h>

int boolf(int a[][100], int n)
{
    // 定义两个标志变量，用于记录异常的行和列
    int flag1 = 0, flag2 = 0, x, y;
    // 遍历每一行，检查每一行的和是否为奇数
    for (int i = 0; i < n ; i++)
    {
        int sum = 0;
        // 计算每一行的和
        for (int j = 0; j < n ; j++)
        {
            sum += a[i][j];
        }
        // 如果和为奇数，则记录异常的行
        if (sum % 2 != 0)
        {
            flag1++;
            x = i;
        }
    }
    // 遍历每一列，检查每一列的和是否为奇数
    for (int i = 0; i < n ; i++)
    {
        int sum = 0;
        // 计算每一列的和
        for (int j = 0; j < n ; j++)
        {
            sum += a[j][i];
        }
        // 如果和为奇数，则记录异常的列
        if (sum % 2 != 0)
        {
            flag2++;
            y = i;
        }
    }
    // 如果异常的行和列都为0，则说明没有异常，输出OK
    if (flag1 == 0 && flag2 == 0)
    {
        printf("OK");
    }
    // 如果异常的行和列只有一个，则说明只修改一个位置，输出修改位置的行列坐标
    else if (flag1 == 1 && flag2 == 1)
    {
        printf("Change bit(%d,%d)", x, y);
    }
    // 如果异常的行和列有两个，则说明整张图片异常，输出corrupt
    else
        printf("Corrupt");
}

int main()
{
    // 定义一个变量，用于存储图片的行数
    int n;
    // 定义一个二维数组，用于存储图片的像素值
    int a[100][100];
    // 读取图片的行数
    scanf("%d", &n);
    // 读取图片的像素值
    for (int i = 0; i < n ; i++)
    {
        for (int j = 0; j < n ; j++)
        {
            scanf("%d", &a[i][j]);
        }
    }
    // 调用boolf函数，检查图片是否异常
    boolf(a, n);
    return 0;
}
#include <stdio.h>

int boolf(int a[][100], int n)
{
    // 定义两个标志变量，用于记录异常的行和列
    int flag1 = 0, flag2 = 0, x, y;
    // 遍历每一行，检查每一行的和是否为奇数
    for (int i = 0; i < n ; i++)
    {
        int sum = 0;
        // 计算每一行的和
        for (int j = 0; j < n ; j++)
        {
            sum += a[i][j];
        }
        // 如果和为奇数，则记录异常的行
        if (sum % 2 != 0)
        {
            flag1++;
            x = i;
        }
    }
    // 遍历每一列，检查每一列的和是否为奇数
    for (int i = 0; i < n ; i++)
    {
        int sum = 0;
        // 计算每一列的和
        for (int j = 0; j < n ; j++)
        {
            sum += a[j][i];
        }
        // 如果和为奇数，则记录异常的列
        if (sum % 2 != 0)
        {
            flag2++;
            y = i;
        }
    }
    // 如果异常的行和列都为0，则说明没有异常，输出OK
    if (flag1 == 0 && flag2 == 0)
    {
        printf("OK");
    }
    // 如果异常的行和列只有一个，则说明只修改一个位置，输出修改位置的行列坐标
    else if (flag1 == 1 && flag2 == 1)
    {
        printf("Change bit(%d,%d)", x, y);
    }
    // 如果异常的行和列有两个，则说明整张图片异常，输出corrupt
    else
        printf("Corrupt");
}

int main()
{
    // 定义一个变量，用于存储图片的行数
    int n;
    // 定义一个二维数组，用于存储图片的像素值
    int a[100][100];
    // 读取图片的行数
    scanf("%d", &n);
    // 读取图片的像素值
    for (int i = 0; i < n ; i++)
    {
        for (int j = 0; j < n ; j++)
        {
            scanf("%d", &a[i][j]);
        }
    }
    // 调用boolf函数，检查图片是否异常
    boolf(a, n);
    return 0;
}

#include<stdio.h>
int main()
{
    //定义变量
    int m, p, n;
    int arr[15][15];
    int brr[15][15];
    int crr[15][15];
    //输入变量
    scanf("%d %d %d", &m, &p, &n);
    //输入arr
    for (int i = 0; i < m;i++)
    {
        for (int j = 0; j < p;j++)
        {
            scanf("%d", &arr[i][j]);
        }
    }
    //输入brr
    for (int i = 0; i < p;i++)
    {
        for (int j = 0; j < n;j++)
        {
            scanf("%d", &brr[i][j]);
        }
    }
    //计算crr
    for (int i = 0; i < m; i++)
    {
        for (int j = 0; j < n; j++)
        {
            crr[i][j] = 0;
            for (int k = 0; k < p; k++)
            {
                crr[i][j] += arr[i][k] * brr[k][j];
            }
        }
    }
    //输出crr
    for (int i = 0; i < m; i++)
    {
        printf("%d", crr[i][0]);
        for (int j = 1; j < n; j++)
        {
            printf(" %d", crr[i][j]);
        }
        printf("\n");
    }
    return 0;
}
#include<stdio.h>
int main()
{
    //定义变量
    int m, p, n;
    int arr[15][15];
    int brr[15][15];
    int crr[15][15];
    //输入变量
    scanf("%d %d %d", &m, &p, &n);
    //输入arr
    for (int i = 0; i < m;i++)
    {
        for (int j = 0; j < p;j++)
        {
            scanf("%d", &arr[i][j]);
        }
    }
    //输入brr
    for (int i = 0; i < p;i++)
    {
        for (int j = 0; j < n;j++)
        {
            scanf("%d", &brr[i][j]);
        }
    }
    //计算crr
    for (int i = 0; i < m; i++)
    {
        for (int j = 0; j < n; j++)
        {
            crr[i][j] = 0;
            for (int k = 0; k < p; k++)
            {
                crr[i][j] += arr[i][k] * brr[k][j];
            }
        }
    }
    //输出crr
    for (int i = 0; i < m; i++)
    {
        printf("%d", crr[i][0]);
        for (int j = 1; j < n; j++)
        {
            printf(" %d", crr[i][j]);
        }
        printf("\n");
    }
    return 0;
}
#include<stdio.h>
int main()
{
    //定义变量
    int m, p, n;
    int arr[15][15];
    int brr[15][15];
    int crr[15][15];
    //输入变量
    scanf("%d %d %d", &m, &p, &n);
    //输入arr
    for (int i = 0; i < m;i++)
    {
        for (int j = 0; j < p;j++)
        {
            scanf("%d", &arr[i][j]);
        }
    }
    //输入brr
    for (int i = 0; i < p;i++)
    {
        for (int j = 0; j < n;j++)
        {
            scanf("%d", &brr[i][j]);
        }
    }
    //计算crr
    for (int i = 0; i < m; i++)
    {
        for (int j = 0; j < n; j++)
        {
            crr[i][j] = 0;
            for (int k = 0; k < p; k++)
            {
                crr[i][j] += arr[i][k] * brr[k][j];
            }
        }
    }
    //输出crr
    for (int i = 0; i < m; i++)
    {
        printf("%d", crr[i][0]);
        for (int j = 1; j < n; j++)
        {
            printf(" %d", crr[i][j]);
        }
        printf("\n");
    }
    return 0;
}

#include<stdio.h>
int main()
{
    //定义两个整型变量m和n
    int m, n;
    //定义一个二维数组a，大小为m*n
    double a[1005][15];
    //输入m和n
    scanf("%d %d", &m, &n);
    //循环m次，每次循环输入a[i][j]
    for (int i = 0; i < m;i++)
    {
        for (int j = 0; j < n;j++)
        {
            scanf("%lf", &a[i][j]);
        }
    }
    //循环n次，每次循环计算每一列的平均值
    for (int i = 0; i < n;i++)
    {
        double sum = 0;
        //循环m次，每次循环累加a[j][i]
        for (int j = 0; j < m;j++)
        {
            sum += a[j][i];
        }
        //计算每一列的平均值
        double avg = sum / m;
        //输出平均值，保留两位小数
        printf("%.2lf", avg);
        //如果不是最后一行，输出空格
        if(i!=n-1)
        {
            printf(" ");
        }
    }
        return 0;
}
#include<stdio.h>
int main()
{
    //定义两个整型变量m和n
    int m, n;
    //定义一个二维数组a，大小为m*n
    double a[1005][15];
    //输入m和n
    scanf("%d %d", &m, &n);
    //循环m次，每次循环输入a[i][j]
    for (int i = 0; i < m;i++)
    {
        for (int j = 0; j < n;j++)
        {
            scanf("%lf", &a[i][j]);
        }
    }
    //循环n次，每次循环计算每一列的平均值
    for (int i = 0; i < n;i++)
    {
        double sum = 0;
        //循环m次，每次循环累加a[j][i]
        for (int j = 0; j < m;j++)
        {
            sum += a[j][i];
        }
        //计算每一列的平均值
        double avg = sum / m;
        //输出平均值，保留两位小数
        printf("%.2lf", avg);
        //如果不是最后一行，输出空格
        if(i!=n-1)
        {
            printf(" ");
        }
    }
        return 0;
}
#include<stdio.h>
int main()
{
    //定义两个整型变量m和n
    int m, n;
    //定义一个二维数组a，大小为m*n
    double a[1005][15];
    //输入m和n
    scanf("%d %d", &m, &n);
    //循环m次，每次循环输入a[i][j]
    for (int i = 0; i < m;i++)
    {
        for (int j = 0; j < n;j++)
        {
            scanf("%lf", &a[i][j]);
        }
    }
    //循环n次，每次循环计算每一列的平均值
    for (int i = 0; i < n;i++)
    {
        double sum = 0;
        //循环m次，每次循环累加a[j][i]
        for (int j = 0; j < m;j++)
        {
            sum += a[j][i];
        }
        //计算每一列的平均值
        double avg = sum / m;
        //输出平均值，保留两位小数
        printf("%.2lf", avg);
        //如果不是最后一行，输出空格
        if(i!=n-1)
        {
            printf(" ");
        }
    }
        return 0;
}

//纯暴力手法
#include <stdio.h>
int main()
{
    // 定义变量
    int year, month, day, num = 0;
    // 输入
    scanf("%d-%d-%d", &year, &month, &day);
    // 判断是否为闰年
    if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0)
    {
        // 根据月份判断
        switch (month)
        {
        case 1:
            printf("%d", day);
            break;
        case 2:
            printf("%d", 31 + day);
            break;
        case 3:
            printf("%d", 31 + 29 + day);
            break;
        case 4:
            printf("%d", 31 * 2 + 29 + day);
            break;
        case 5:
            printf("%d", 31 * 2 + 29 + 30 + day);
            break;
        case 6:
            printf("%d", 31 * 3 + 29 + 30 + day);
            break;
        case 7:
            printf("%d", 31 * 3 + 29 + 30 * 2 + day);
            break;
        case 8:
            printf("%d", 31 * 4 + 29 + 30 * 2 + day);
            break;
        case 9:
            printf("%d", 31 * 5 + 29 + 30 * 2 + day);
            break;
        case 10:
            printf("%d", 31 * 5 + 29 + 30 * 3 + day);
            break;
        case 11:
            printf("%d", 31 * 6 + 29 + 30 * 3 + day);
            break;
        case 12:
            printf("%d", 31 * 6 + 29 + 30 * 4 + day);
            break;
        }
    }
    // 不是闰年
    else
    {
        // 根据月份判断
        switch (month)
        {
        case 1:
            printf("%d", day);
            break;
        case 2:
            printf("%d", 31 + day);
            break;
        case 3:
            printf("%d", 31 + 28 + day);
            break;
        case 4:
            printf("%d", 31 * 2 + 28 + day);
            break;
        case 5:
            printf("%d", 31 * 2 + 28 + 30 + day);
            break;
        case 6:
            printf("%d", 31 * 3 + 28 + 30 + day);
            break;
        case 7:
            printf("%d", 31 * 3 + 28 + 30 * 2 + day);
            break;
        case 8:
            printf("%d", 31 * 4 + 28 + 30 * 2 + day);
            break;
        case 9:
            printf("%d", 31 * 5 + 28 + 30 * 2 + day);
            break;
        case 10:
            printf("%d", 31 * 5 + 28 + 30 * 3 + day);
            break;
        case 11:
            printf("%d", 31 * 6 + 28 + 30 * 3 + day);
            break;
        case 12:
            printf("%d", 31 * 6 + 28 + 30 * 4 + day);
            break;
        }
    }
    return 0;
}
//纯暴力手法
#include <stdio.h>
int main()
{
    // 定义变量
    int year, month, day, num = 0;
    // 输入
    scanf("%d-%d-%d", &year, &month, &day);
    // 判断是否为闰年
    if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0)
    {
        // 根据月份判断
        switch (month)
        {
        case 1:
            printf("%d", day);
            break;
        case 2:
            printf("%d", 31 + day);
            break;
        case 3:
            printf("%d", 31 + 29 + day);
            break;
        case 4:
            printf("%d", 31 * 2 + 29 + day);
            break;
        case 5:
            printf("%d", 31 * 2 + 29 + 30 + day);
            break;
        case 6:
            printf("%d", 31 * 3 + 29 + 30 + day);
            break;
        case 7:
            printf("%d", 31 * 3 + 29 + 30 * 2 + day);
            break;
        case 8:
            printf("%d", 31 * 4 + 29 + 30 * 2 + day);
            break;
        case 9:
            printf("%d", 31 * 5 + 29 + 30 * 2 + day);
            break;
        case 10:
            printf("%d", 31 * 5 + 29 + 30 * 3 + day);
            break;
        case 11:
            printf("%d", 31 * 6 + 29 + 30 * 3 + day);
            break;
        case 12:
            printf("%d", 31 * 6 + 29 + 30 * 4 + day);
            break;
        }
    }
    // 不是闰年
    else
    {
        // 根据月份判断
        switch (month)
        {
        case 1:
            printf("%d", day);
            break;
        case 2:
            printf("%d", 31 + day);
            break;
        case 3:
            printf("%d", 31 + 28 + day);
            break;
        case 4:
            printf("%d", 31 * 2 + 28 + day);
            break;
        case 5:
            printf("%d", 31 * 2 + 28 + 30 + day);
            break;
        case 6:
            printf("%d", 31 * 3 + 28 + 30 + day);
            break;
        case 7:
            printf("%d", 31 * 3 + 28 + 30 * 2 + day);
            break;
        case 8:
            printf("%d", 31 * 4 + 28 + 30 * 2 + day);
            break;
        case 9:
            printf("%d", 31 * 5 + 28 + 30 * 2 + day);
            break;
        case 10:
            printf("%d", 31 * 5 + 28 + 30 * 3 + day);
            break;
        case 11:
            printf("%d", 31 * 6 + 28 + 30 * 3 + day);
            break;
        case 12:
            printf("%d", 31 * 6 + 28 + 30 * 4 + day);
            break;
        }
    }
    return 0;
}
//纯暴力手法
#include <stdio.h>
int main()
{
    // 定义变量
    int year, month, day, num = 0;
    // 输入
    scanf("%d-%d-%d", &year, &month, &day);
    // 判断是否为闰年
    if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0)
    {
        // 根据月份判断
        switch (month)
        {
        case 1:
            printf("%d", day);
            break;
        case 2:
            printf("%d", 31 + day);
            break;
        case 3:
            printf("%d", 31 + 29 + day);
            break;
        case 4:
            printf("%d", 31 * 2 + 29 + day);
            break;
        case 5:
            printf("%d", 31 * 2 + 29 + 30 + day);
            break;
        case 6:
            printf("%d", 31 * 3 + 29 + 30 + day);
            break;
        case 7:
            printf("%d", 31 * 3 + 29 + 30 * 2 + day);
            break;
        case 8:
            printf("%d", 31 * 4 + 29 + 30 * 2 + day);
            break;
        case 9:
            printf("%d", 31 * 5 + 29 + 30 * 2 + day);
            break;
        case 10:
            printf("%d", 31 * 5 + 29 + 30 * 3 + day);
            break;
        case 11:
            printf("%d", 31 * 6 + 29 + 30 * 3 + day);
            break;
        case 12:
            printf("%d", 31 * 6 + 29 + 30 * 4 + day);
            break;
        }
    }
    // 不是闰年
    else
    {
        // 根据月份判断
        switch (month)
        {
        case 1:
            printf("%d", day);
            break;
        case 2:
            printf("%d", 31 + day);
            break;
        case 3:
            printf("%d", 31 + 28 + day);
            break;
        case 4:
            printf("%d", 31 * 2 + 28 + day);
            break;
        case 5:
            printf("%d", 31 * 2 + 28 + 30 + day);
            break;
        case 6:
            printf("%d", 31 * 3 + 28 + 30 + day);
            break;
        case 7:
            printf("%d", 31 * 3 + 28 + 30 * 2 + day);
            break;
        case 8:
            printf("%d", 31 * 4 + 28 + 30 * 2 + day);
            break;
        case 9:
            printf("%d", 31 * 5 + 28 + 30 * 2 + day);
            break;
        case 10:
            printf("%d", 31 * 5 + 28 + 30 * 3 + day);
            break;
        case 11:
            printf("%d", 31 * 6 + 28 + 30 * 3 + day);
            break;
        case 12:
            printf("%d", 31 * 6 + 28 + 30 * 4 + day);
            break;
        }
    }
    return 0;
}

#include<stdio.h>
int main()
{
    //定义一个变量n
    int n;
    //定义一个二维数组a，初始值为1
    int a[35][35]={1};
    //输入n
    scanf("%d",&n);
    //循环n次
    for (int i = 0; i < n;i++)
    {
        //循环i次
        for (int j = 0; j < i + 1;j++)
        {
            //如果i等于0或者j等于0，则a[i][0]等于1
            if(i==0||j==0)
            {
                a[i][0] = 1;
            }
            //如果i大于0且j不等于0，则a[i][j]等于a[i - 1][j - 1] + a[i - 1][j]
            if(i>0&&j!=0)
            {
                a[i][j] = a[i - 1][j - 1] + a[i - 1][j];
            }
            //输出a[i][j]
            printf("%d", a[i][j]);
            //如果j小于n-1，则输出空格
            if(j<n-1)
                printf(" ");
            //如果j等于i，则换行
            if(j==i)
            {
                printf("\n");
            }
        }
    }
        return 0;
}
#include<stdio.h>
int main()
{
    //定义一个变量n
    int n;
    //定义一个二维数组a，初始值为1
    int a[35][35]={1};
    //输入n
    scanf("%d",&n);
    //循环n次
    for (int i = 0; i < n;i++)
    {
        //循环i次
        for (int j = 0; j < i + 1;j++)
        {
            //如果i等于0或者j等于0，则a[i][0]等于1
            if(i==0||j==0)
            {
                a[i][0] = 1;
            }
            //如果i大于0且j不等于0，则a[i][j]等于a[i - 1][j - 1] + a[i - 1][j]
            if(i>0&&j!=0)
            {
                a[i][j] = a[i - 1][j - 1] + a[i - 1][j];
            }
            //输出a[i][j]
            printf("%d", a[i][j]);
            //如果j小于n-1，则输出空格
            if(j<n-1)
                printf(" ");
            //如果j等于i，则换行
            if(j==i)
            {
                printf("\n");
            }
        }
    }
        return 0;
}
#include<stdio.h>
int main()
{
    //定义一个变量n
    int n;
    //定义一个二维数组a，初始值为1
    int a[35][35]={1};
    //输入n
    scanf("%d",&n);
    //循环n次
    for (int i = 0; i < n;i++)
    {
        //循环i次
        for (int j = 0; j < i + 1;j++)
        {
            //如果i等于0或者j等于0，则a[i][0]等于1
            if(i==0||j==0)
            {
                a[i][0] = 1;
            }
            //如果i大于0且j不等于0，则a[i][j]等于a[i - 1][j - 1] + a[i - 1][j]
            if(i>0&&j!=0)
            {
                a[i][j] = a[i - 1][j - 1] + a[i - 1][j];
            }
            //输出a[i][j]
            printf("%d", a[i][j]);
            //如果j小于n-1，则输出空格
            if(j<n-1)
                printf(" ");
            //如果j等于i，则换行
            if(j==i)
            {
                printf("\n");
            }
        }
    }
        return 0;
}

#include <stdio.h>
int main()
{
    // 定义一个字符数组
    char a[105];
    // 定义一个整型数组，用于存储每个字母出现的次数
    int s[27] = {0}, i = 0, m = 0, j;
    // 读取字符串，并将其中的大写字母转换为小写字母
    while ((a[i] = getchar()) != '\n')
    {
        if (a[i] >= 'A' && a[i] <= 'Z')
            a[i] = a[i] + 32;
        // 计算每个字母出现的次数
        j = a[i] - 'a';
        s[j] += 1;
        i++;
    }
    // 遍历数组，找到出现次数最多的字母
    for (i = 0; i < 26; i++)
    {
        if (s[m] < s[i])
        {
            m = i;
        }
    }
    // 输出出现次数最多的字母
    printf("%c", m + 'a');
    return 0;
}
#include <stdio.h>
int main()
{
    // 定义一个字符数组
    char a[105];
    // 定义一个整型数组，用于存储每个字母出现的次数
    int s[27] = {0}, i = 0, m = 0, j;
    // 读取字符串，并将其中的大写字母转换为小写字母
    while ((a[i] = getchar()) != '\n')
    {
        if (a[i] >= 'A' && a[i] <= 'Z')
            a[i] = a[i] + 32;
        // 计算每个字母出现的次数
        j = a[i] - 'a';
        s[j] += 1;
        i++;
    }
    // 遍历数组，找到出现次数最多的字母
    for (i = 0; i < 26; i++)
    {
        if (s[m] < s[i])
        {
            m = i;
        }
    }
    // 输出出现次数最多的字母
    printf("%c", m + 'a');
    return 0;
}
#include <stdio.h>
int main()
{
    // 定义一个字符数组
    char a[105];
    // 定义一个整型数组，用于存储每个字母出现的次数
    int s[27] = {0}, i = 0, m = 0, j;
    // 读取字符串，并将其中的大写字母转换为小写字母
    while ((a[i] = getchar()) != '\n')
    {
        if (a[i] >= 'A' && a[i] <= 'Z')
            a[i] = a[i] + 32;
        // 计算每个字母出现的次数
        j = a[i] - 'a';
        s[j] += 1;
        i++;
    }
    // 遍历数组，找到出现次数最多的字母
    for (i = 0; i < 26; i++)
    {
        if (s[m] < s[i])
        {
            m = i;
        }
    }
    // 输出出现次数最多的字母
    printf("%c", m + 'a');
    return 0;
}

#include <stdio.h>
int main()
{
    // 定义变量n和t
    int n, t;
    // 定义变量ch
    char ch;
    // 输入变量n
    scanf("%d", &n);
    // 跳过换行符
    getchar();
    // 循环n次
    for (int i = 0; i < n; i++)
    {
        // 初始化t为0
        t = 0;
        // 循环读取字符，直到遇到换行符
        while ((ch= getchar()) != '\n')
        {
            // 如果字符大于等于0且小于等于9，t加1
            if (ch>= '0' && ch <= '9')
            {
                t++;
            }
        }
        // 输出t
        printf("%d\n", t);
    }
    return 0;
}
#include <stdio.h>
int main()
{
    // 定义变量n和t
    int n, t;
    // 定义变量ch
    char ch;
    // 输入变量n
    scanf("%d", &n);
    // 跳过换行符
    getchar();
    // 循环n次
    for (int i = 0; i < n; i++)
    {
        // 初始化t为0
        t = 0;
        // 循环读取字符，直到遇到换行符
        while ((ch= getchar()) != '\n')
        {
            // 如果字符大于等于0且小于等于9，t加1
            if (ch>= '0' && ch <= '9')
            {
                t++;
            }
        }
        // 输出t
        printf("%d\n", t);
    }
    return 0;
}
#include <stdio.h>
int main()
{
    // 定义变量n和t
    int n, t;
    // 定义变量ch
    char ch;
    // 输入变量n
    scanf("%d", &n);
    // 跳过换行符
    getchar();
    // 循环n次
    for (int i = 0; i < n; i++)
    {
        // 初始化t为0
        t = 0;
        // 循环读取字符，直到遇到换行符
        while ((ch= getchar()) != '\n')
        {
            // 如果字符大于等于0且小于等于9，t加1
            if (ch>= '0' && ch <= '9')
            {
                t++;
            }
        }
        // 输出t
        printf("%d\n", t);
    }
    return 0;
}

#include <stdio.h>
#include <string.h>
#include <ctype.h>
int main () {
  // 定义变量
  int count = 0, len;
  char ch[1001];
  // 读取一行字符串
  fgets(ch, sizeof(ch), stdin);
  // 计算字符串长度
  len  = strlen(ch);
  
  // 如果字符串最后是换行符，则去掉换行符
  if (ch[len-1] == '\n') {
    ch[len-1] = '\0'; // 移除末尾的换行符
    len--; 
  }
  
  // 计算空格数量
  for (int i = 0; i < len; i++) {
    // 判断字符串中每个字符的前一个字符是否是字母或数字，且当前字符是否是空格
    if (isalnum(ch[i-1]) && ch[i] == ' '){
      count++;
    }
  }
  
  // 判断字符串最后一个字符是否是字母或数字
  if (isalnum(ch[len-1])){
    count++;
  }
  
  // 输出空格数量
  printf ("%d",count);
  return 0;
}
#include <stdio.h>
#include <string.h>
#include <ctype.h>

int main () {
  // 定义变量
  int count = 0, len;
  char ch[1001];
  // 读取一行字符串
  fgets(ch, sizeof(ch), stdin);
  // 计算字符串长度
  len  = strlen(ch);
  
  // 如果字符串最后是换行符，则去掉换行符
  if (ch[len-1] == '\n') {
    ch[len-1] = '\0'; // 移除末尾的换行符
    len--; 
  }
  
  // 计算空格数量
  for (int i = 0; i < len; i++) {
    // 判断字符串中每个字符的前一个字符是否是字母或数字，且当前字符是否是空格
    if (isalnum(ch[i-1]) && ch[i] == ' '){
      count++;
    }
  }
  
  // 判断字符串最后一个字符是否是字母或数字
  if (isalnum(ch[len-1])){
    count++;
  }
  
  // 输出空格数量
  printf ("%d",count);
  return 0;
}
#include <stdio.h>
#include <string.h>
#include <ctype.h>

int main () {
	// 定义变量
	int count = 0, len;
	char ch[1001];
	// 读取一行字符串
	fgets(ch, sizeof(ch), stdin);
	// 计算字符串长度
	len  = strlen(ch);
	
	// 如果字符串最后是换行符，则去掉换行符
	if (ch[len-1] == '\n') {
		ch[len-1] = '\0'; // 移除末尾的换行符
		len--; 
	}
	
	// 计算空格数量
	for (int i = 0; i < len; i++) {
		// 判断字符串中每个字符的前一个字符是否是字母或数字，且当前字符是否是空格
		if (isalnum(ch[i-1]) && ch[i] == ' '){
			count++;
		}
	}
	
	// 判断字符串最后一个字符是否是字母或数字
	if (isalnum(ch[len-1])){
		count++;
	}
	
	// 输出空格数量
	printf ("%d",count);
	return 0;
}