2023东华大学OJ机试题110-135

东华大学计算机研究生复试题

110 考试排名

typedef struct exam {
	char name[10];
	int count;
	int score;
}EXAM;

//基本思路是：用结构体存储考试，有学生姓名，AC通过数量和时长，用time[]数组来存储字符串【时长】，先判断有多少题AC，然后再计算时长，遇到 ( 跳出循环，还有计算错误提交次数
#include 
#include 
int main() {
	EXAM ex[100],tmp;
	char time[10];
	int i,n,m,j=0,k,temp,l,len;
	scanf("%d%d",&n,&m);
	while(scanf("%s",&ex[j].name) != EOF) {
		ex[j].count=0,ex[j].score=0;
		for(i=0;i<n;i++) {
			scanf("%s",&time);
			//判断负数
			if(time[0]=='-')
				continue;
			//判0
			if(time[0]=='0')
				continue;
			
			//判断正数
			ex[j].count++;
			temp=0;
			len = strlen(time);
			//计算分数
			for(k=0;k<len;k++) {
				if(time[k]=='(') break;
				temp = temp*10+time[k]-'0';
			}
			ex[j].score += temp;
			temp =0;
			//计算错误提交次数
			if(k<len) {
				for(l=k+1;l<len-1;l++)//第len-1是)
					temp = temp*10+time[l]-'0';
			}
			ex[j].score += temp*m;
		}
		j++;
	}
	//排序输出
	for(i=0;i<j;i++) {//j代表人数个数
		for(k=1;k<j-i;k++) {
			//判断提交次数
			if(ex[k-1].count < ex[k].count) {
				tmp=ex[k-1];
				ex[k-1]=ex[k];
				ex[k]=tmp;
			} else if(ex[k-1].count==ex[k].count) {
				//提交次数相等，判断分数
				if(ex[k-1].score > ex[k].score) {
					tmp=ex[k-1];
					ex[k-1]=ex[k];
					ex[k]=tmp;
				} else if(ex[k-1].score == ex[k].score) {
					//分数相等,判断名字姓氏
					if(ex[k-1].name[0] > ex[k].name[0]) {
						tmp=ex[k-1];
						ex[k-1]=ex[k];
						ex[k]=tmp;
					}
				}
			}
		}
	}
	for(i=0;i<j;i++) {
		printf("%-10s %2d %4d\n",ex[i].name,ex[i].count,ex[i].score);
	}
	return 0;
}

111 统计候选人的票数

题目描述：设有3个候选人zhang、li、wang（候选人姓名不区分大小写），10个选民，选民每次输入一个得票的候选人的名字，若选民输错候选人姓名，则按废票处理。选民投票结束后，程序自动显示各候选人的得票结果和废票信息。要求用结构体数组candidate表示3个候选人的姓名和得票结果。

#include 
#include 
struct candidate{
	char name[10];
	int result;
}C[3]={{"li",0},{"zhang",0},{"wang",0}};
int main(){
		int s=0;//s统计错误的名字数量
	for(int i=0;i<10;i++){
		char Name[10];
		scanf("%s",Name);
		if(strcmp(Name,"li")==0)//strcmp比较函数（相等返回0） 
			C[0].result++;
		else if(strcmp(Name,"zhang")==0)
			C[1].result++;
		else if(strcmp(Name,"wang")==0)
			C[2].result++;
		else s++;
	}  
	printf("li:");printf("%d\n",C[0].result);
	printf("zhang:");printf("%d\n",C[1].result);
	printf("wang:");printf("%d\n",C[2].result);
	printf("Wrong election:");printf("%d",s);
	return 0;
}

112 密码分析

题目描述：密码分析学中常常需要统计字符出现的频度。给定若干行短文，要求按字符出现的频度由高到低输出，当两个字符出现的频度相同时，按字符大小的顺序输出。

注意：只需要统计英文字母的频度，非英文字母一律忽略。

思路：需要使用isalpha函数和islower函数

#include
#include
#include
typedef struct count{//存储结果
	char c;
	int num;
}COUNT;
int main()
{
COUNT count[26];
COUNT key;
char str[101],ch;
int len,i,j;
while(gets(str))
{
len=strlen(str);
for(int i=0;i<26;i++)
{
count[i].c='A'+i;//初始化结构体
count[i].num=0;
}
for(i=0;i<len;i++) //遍历字符串
{
ch=str[i];
if(isalpha(ch))//如果当前是字符

if(islower(ch))//如果是小写则转换为大写
{
ch-=32;
}
count[ch-'A'].num++;//该字符对应位置的数量加1
}
}
		for(i=1;i<26;i++){//结构体排序
			if(count[i].num>count[i-1].num){
				key=count[i];
				for(j=i-1;j>=0 && count[j].num<key.num;j--)
					count[j+1]=count[j];
				count[j+1]=key;
			}		
		}
for(i=0;i<26;i++){
			if(count[i].num>0){
				printf("%c %d\n",count[i].c,count[i].num);
			}
		}
		printf("\n");
}
return 0;
}

113 学生信息

题目描述：你的程序需要从标准输入设备（通常为键盘）中输入N（1≤N≤10）个学生的信息，每项信息包含该学生的编号、姓名、性别、年龄、成绩共五项，按成绩进行排序，然后按成绩从低到高输出，输入保证没有相同的成绩

思路：一个排序搞定

#include
#include
typedef struct student{
	int id;
	char name[16];
	char sex[10];
	int age;
	double grade;
}STUDENT;
int main(){
	int n;
	STUDENT stu[11];
	STUDENT key;
	int i,j;
	scanf("%d",&n);
	for(i=0;i<n;i++){
		scanf("%d%s%*c%s%d%lf",&stu[i].id,stu[i].name,stu[i].sex,&stu[i].age,&stu[i].grade);
	}
	//冒泡排序，用习惯了
   for(i=0;i<n-1;i++)
   {
      for(j=n-1;j>i;j--)
        {
              if(stu[j-1].grade>stu[j].grade)
                {
                   key=stu[j-1];
                   stu[j-1]=stu[j];
                   stu[j]=key;
                 }
         }
   }



	for(i=0;i<n;i++){
		printf("%d %s %s %d %.0f\n",stu[i].id,stu[i].name,stu[i].sex,stu[i].age,stu[i].grade);
	}
	return 0;
}

114 成绩统计

#include
struct student
{
char name[10];
int math;
int zhen;
int avg;
};
int main()
{
int i,j;
student stu[5];
student temp;
int mathx=0;
int k;
for(i=0;i<5;i++)
{
scanf("%s %d %d",&stu[i].name,&stu[i].math,&stu[i].zhen);
}
for(i=0;i<5;i++)
{
 stu[i].avg=(stu[i].math+stu[i].zhen)/2;
}
/*for(i=0;i<4;i++)
{
  for(j=4;j>i;j--)
    {
     if(stu[j-1].avg
for(j=0;j<5;j++)
{
   if(stu[j].math>mathx)
    {
         mathx=stu[j].math;
         k=j;
    }
}
for(i=0;i<5;i++)
{
   printf("%s %d\n",stu[i].name,stu[i].avg);
}
printf("%s %d %d\n",stu[k].name,stu[k].math,stu[k].zhen);
return 0;
}

115 摩托车

思路：暴力破解，对客户所需摩托车型号进行循环，在明明的摩托车里查找

/*
	T84 摩托车 
*/ 

#include
#include
#define MAX_SIZE 105 

typedef struct Motorbike {
	char motorbikeType[3];// 摩托车型号
	char color[15];// 颜色 
	char motorType[3];// 马达型号 
} Motorbike;


int main() {
	//printf("%d\n", strcmp("a1", "a2"));
	int flag = 0;
	int i = 0, j = 0;
	int n = 0, m = 0;
	Motorbike req[MAX_SIZE];// 客户需要的摩托车
	Motorbike own[MAX_SIZE];// 明明工厂拥有的摩托车 
	
	while (scanf("%d%d", &n, &m) != EOF) {
		for (i = 0; i < n; i++)
			scanf("%s", req[i].motorbikeType);
			
		for (i = 0; i < m; i++)
			scanf("%s%s%s", own[i].motorbikeType, own[i].color, own[i].motorType);
			
		
		flag = 0;//用来标识是否存在客户需要的摩托车
		for (i = 0; i < n; i++) {
			for (j = 0; j < m; j++) {
				if (strcmp(req[i].motorbikeType, own[j].motorbikeType) == 0) {
					flag = 1;
					printf("%s %s %s\n", own[j].motorbikeType, 
					own[j].color, own[j].motorType);
				}
			}
		}
		if (!flag) {
			printf("Not found!\n");
		}
	}
	
	return 0;
}
 

116 扑克牌

#include 
#include 

char colo[5]={'0','C','D','H','S'};
char num[15]={'0','0','2','3','4','5','6','7','8','9','T','J','Q','K','A'} ;


struct Card{
	int color;     							//黑桃红心方块草花分别为4321 ； 
	int number;    							//T=10，J=11，Q=12，K=13，A=14； 
}; 

/**
*以颜色排序
*/
void sortcolor(Card a[])
{
	for(int i=0;i<12;i++)
	{
		for(int j=0;j<12-i;j++)
		{
			if(a[j].color<a[j+1].color)
			{
				int tempcolor=a[j].color,tempnum=a[j].number;
				a[j].color=a[j+1].color;
				a[j].number=a[j+1].number;
				a[j+1].color=tempcolor;
				a[j+1].number=tempnum;
			}
			
		}
	}
	
}

/**
*以数字排序
*/
void sortnum(Card a[])
{
	for(int i=0;i<12;i++)
	{
		for(int j=0;j<12-i;j++)
		{
			if(a[j].number<a[j+1].number)
			{
				int tempcolor=a[j].color,tempnum=a[j].number;
				a[j].color=a[j+1].color;
				a[j].number=a[j+1].number;
				a[j+1].color=tempcolor;
				a[j+1].number=tempnum;
			}
			
		}
	}
	
}

int main(){
	int n;
	scanf("%d",&n);
	getchar();
	n*=4;
	for(int i=1;i<=n;i++)					//以行为单位进行处理，2副牌即8行
	{
		char a[100];					
		gets(a);
		int r=0;
		Card card[13];
		/**
		*先看做一个字符串存入数组，然后按一个颜色一个大小一个空格的顺序，逐组存入。
		*/
		for(int i=0;i<strlen(a);i++)		
		{
			for(int k=0;k<5;k++)
			{
				if(a[i]==colo[k])
				{
					card[r].color=k;
				}
			}
			i++;
			for(int k=0;k<15;k++)
			{
				if(a[i]==num[k])
				{
					card[r].number=k;
				}
			}
			i++;
			r++;

		}
		
		sortcolor(card);
		sortnum(card);
		
		for(int i=0;i<13;i++)
		{
			printf("%c%c",colo[card[i].color],num[card[i].number]);
			if(i==12)
			{
				printf("\n");
			}
			else
			{
				printf(" ");
			}
		}
		
		
		if(i%4==0)
		{
			printf("\n");
		}
		
		
		
	}
	
}

117 混合牛奶

思路：将农民的牛奶价格从小到大排序，依次遍历农民，如果当前农民的牛奶数量小于剩余的牛奶数量，则全收，如果大于则收剩余的牛奶数量即可

#include 
#include 

typedef struct {
	int price;
	int amount;
} milks;

//设置结构体快速排序，从小到大排序
void quickSort(int low,int high,milks R[]) {
	milks temp;
	int i=low,j=high;
	if(low<high) {
		temp=R[low];
		while(i<j) {
			while(j>i&&R[j].price>=temp.price) {
				--j;
			}
			if(i<j) {
				R[i]=R[j];
				++i;
			}

			while(i<j&&R[i].price<temp.price) {
				++i;
			}
			if(i<j) {
				R[j]=R[i];
				--j;
			}
		}
		R[i]=temp;
		quickSort(low,i-1,R);
		quickSort(i+1,high,R);
	}
}

int main(int argc, char *argv[]) {
	int n,m,i,ret=0;
	milks milk[100];
	scanf("%d%d",&n,&m);
	for(i=0; i<m; i++) {
		scanf("%d%d",&milk[i].price,&milk[i].amount);
	}
	//表示剩余的需要的牛奶数量
	int remain=n;
	
	quickSort(0,m-1,milk);

	for(i=0;i<m;i++) {
		if(milk[i].amount<remain) {//如果这个农民牛奶小于剩余牛奶数量，则全收
			ret+=milk[i].price*milk[i].amount;
			remain-=milk[i].amount;

		} else {
			ret+=milk[i].price*(remain);
			break;
		}
	}
	printf("%d\n",ret);

	return 0;
}

119 挤牛奶

题目描述： 三个农民每天清晨5点起床，然后去牛棚给3头牛挤奶。第一个农民在300时刻(从5点开始计时，秒为单位)给他的牛挤奶，一直到1000时刻。第二个农民在700时刻开始，在 1200时刻结束。第三个农民在1500时刻开始2100时刻结束。期间最长的至少有一个农民在挤奶的连续时间为900秒(从300时刻到1200时刻)，而最长的无人挤奶的连续时间(从挤奶开始一直到挤奶结束)为300秒(从1200时刻到1500时刻)。 你的任务是编一个程序，读入一个有N个农民(1 <= N <= 5000)挤N头牛的工作时间列表，计算以下两点(均以秒为单位): 最长至少有一人在挤奶的时间段。 最长的无人挤奶的时间段。

#include
#include
using namespace std;
 
struct node{
    int start,end;
}a[5010];
 
bool cmp(node c,node d){
    return c.start<d.start;
}
 
int main()
{
    int n;
    cin>>n;
    for(int i=1;i<=n;i++){//数组下标从1开始
        cin>>a[i].start>>a[i].end;
    }
    sort(a+1,a+1+n,cmp);
    
    int st=a[1].start,ed=a[1].end;//st和ed分别记录当前挤奶的开始和结束时间
    int max1=ed-st; //最长的有人挤奶时间
    int max2=0; //最长无人挤奶时间
    
    for(int i=2;i<=n;i++)
    {
        if(a[i].start<ed){  //存在交集，前后连上
            ed=max(ed,a[i].end); 
            max1=max(max1,ed-st);//更新最长的有人挤奶时间
        }
        else{ //前后连不上
            max2=max(max2,a[i].start-ed);//更新最长无人挤奶时间
            st=a[i].start; //更新一下当前的st和ed
            ed=a[i].end;
        }
    }
    
    cout<<max1<<" "<<max2<<endl;
    
    
	return 0;
}
 
 
//看是否存在交集
//前提是start必须排序
//有交集就是更新最长有人挤奶时间
//无交集就是更新最长无人挤奶时间

120 顺序的分数

 
#include
#include
using namespace std;
 
 
struct fen{  //用结构体来分别存分子分母
    int fz,fm;
}a[1010];
 
 
int gcd(int a,int b){  //判断是否还能约分
	int max=a>b?a:b;
	int i;
	for(i=2;i<max;i++)
	{
		if(a%i==0&&b%i==0)
		{
			return 0;
		}
	}
	return 1;
}
 
bool cmp(fen a,fen b){
    return a.fz*b.fm<a.fm*b.fz;
}
 
 
int main() {
   
    int n,i,j;
    cin>>n;
    a[1].fz=0,a[1].fm=1;//数组下标从1开始
    int k=1;
    for(i=1;i<=n;i++){ //枚举分母
        for(j=1;j<i;j++)  //枚举分子
        {  
            if(gcd(i,j)==1){
                k++;
                a[k].fz=j;
                a[k].fm=i;
            }
        }
    }
    
    sort(a+1,a+1+k,cmp); //按照分数小的排序
    for(i=1;i<=k;i++){
        printf("%d/%d\n",a[i].fz,a[i].fm);
    }
  
	return 0;
}
 
 
//1.判断互质
//2.如何存分数？ 结构体
//分数如何排序？ 小学数学

121 分糖果

#include 
#include 
using namespace std;
int main()
{
    int T,i;
    cin>>T;
    while(T--){
        int n,tmp=0,sum=0;
        cin>>n;
        int a[n];
        for(i=0;i<n;i++){
            cin>>a[i];
            sum+=a[i];//计算所有糖果价值总和
        }
        sort(a,a+n);//从小到大排序
        for(i=0;i<n;i++) {
            tmp=tmp ^ a[i];//二进制各位相同为0，不同为1->异或运算
        }
        //充要条件：若某两堆的二进制异或总和为0，则这两堆在弟弟眼中是相等的
        //如果最后可以分成相等的两堆，说明结果一定为0
        //既然总和为0，随意挑选一个，剩下的所有总和一定与它相等（ 0-n=-n ）
        //利益最大化->剔除掉价值最小的糖果，剩下的就是利益最大的
        if(tmp==0){
            cout<<sum-a[0]<<endl;
        }
        else cout<<"NO"<<endl;
    }
return 0;
}

122循环数

思路：①如果数字各位有相同的数字，则不是循环数
②循环过程中，如果一轮的起点和终点值相同，则不是循环数（其实也就是位置相同，因为①，所以值相同就是位置相同）
③循环结束后（所有数都被数到了）如果停留的位置不是起点，则不是循环数。
以上三点是根据题目显而易见的

还有一个很重要的判别条件是，读重复了。例如134257（随便举的不一定会有）中3读到两次。这时候必然不是循环数！
细品可知，重复两次肯定会重复无限次，就死循环了。

#include 
#include 

/**
*repeat函数判断数字n有没有重复的数字，有则返回1，没有则返回0。 
*/ 
int repeat(int n)
{
	char a[20];
	sprintf(a,"%d",n);
	int len=strlen(a);

	for(int i=0;i<len-1;i++) 
	{
		for(int j=i+1;j<len;j++)
		{
			if(a[i]==a[j])
			{
				return 1;
			}
		}
	}
	return 0;
	
}

int check(int tag[],int len)//判断是否还有数字没有被数过
{
	for(int i=0;i<len;i++)
	{
		if(tag[i]==0)
		{
			return 0;
		}
	}
	return 1;
}




/**
*round函数判断是否满足循环规则。 
*/
int round(int n)
{
char a[20];
sprintf(a,"%d",n);
int len=strlen(a);

int tag[len];						//tag数组用以标记这个数字有没有被数到过，数到了置为1 
memset(tag,0,sizeof(tag));

int start=0;
while(check(tag,len)==0) 
{
       	if(tag[start]==1)//防止死循环
	{
		return 0;
	}        

	int temp=a[start]-'0';
	int end=(start+temp)%len;
	if(a[start]==a[end])
	{
		return 0;
	}
	tag[start]=1;
	start=end;
}
if(start==0)
{
	return 1;
}
else
{
	return 0;
}
	
	
	
} 

int main(){
	int m;
	scanf("%d",&m);
	for(int i=m+1;;i++)
	{
		if(repeat(i)==0)//如果没有重复数字则继续判断
		{
			if(round(i)==1)//如果是循环数则输出
			{
			
			printf("%d\n",i);
			break;
			}
		}
	}
	
	
}

125 回文或镜面回文

#include
#include
#define CHAR_MAX_SIZE 25

// 每个字母和数字对应的镜面字母（如果没有就用空格表示） 
char charMirror[] = "A   3  HIL JM O   2TUVWXY5", digitMirror[] = "O1SE Z  8 "; 
int isPalin(char str[]);
int isMirror(char str[]); 

int main() {
	char str[CHAR_MAX_SIZE] = "";
	int palinTag = 0, mirrorTag = 0;// 回文、镜面回文标记 

	while (scanf("%s", str) != EOF) {// 测试用例NOTAPALINDROME结果不对 
		palinTag = isPalin(str);
		mirrorTag = isMirror(str);
		
		if (!palinTag && !mirrorTag) 
			printf("%s -- is not a palindrome.\n\n", str);
		if (palinTag && !mirrorTag) 
			printf("%s -- is a regular palindrome.\n\n", str);
		if (!palinTag && mirrorTag) 
			printf("%s -- is a mirrored string.\n\n", str);
		if (palinTag && mirrorTag) 
			printf("%s -- is a mirrored palindrome.\n\n", str);
	} 	
	
	return 0;
}

// 判断回文字符串
int isPalin(char str[]) {
	int i = 0;
	char strCopy[CHAR_MAX_SIZE] = "";
	strcpy(strCopy, str); 
	int len = strlen(strCopy); 
		
	for (i = 0; i < len / 2; i++) {
		if (strCopy[i] != strCopy[len - i - 1])
			return 0;
	}
	
	return 1;
}

// 判断镜面回文
// 只要处于对称位置的两个字符互为镜面字符就可以了 
int isMirror(char str[]) {
	int i = 0;
	int len = strlen(str);
	for (i = 0; i < len / 2; i++) {
		if (str[i] >= 'A' && str[i] <= 'Z') {// 当前字符为字母
			if (str[len - i - 1] != charMirror[str[i] - 'A'])
				return 0;
		} 
		else {// 当前字符为数字
			if (str[len - i - 1] == '0' && 'O' != digitMirror[str[i] - '0'])
				return 0;
			if (str[len - i - 1] != digitMirror[str[i] - '0'])
				return 0;
		} 
	}
	
	return 1; 
} 
 

126 数列2

题目描述：明明爸爸的问题可以归结为：给你一个数列，从中选出1个或若干个数（可以不连续），要求这些数的和能被11整除，问这样的选数方法一共有多少种。

不知道哪里错了

#include 
using namespace std;
int count=0,a[100],k,n;
void DFS(int sum,int index,int now){
    if(now==k&&sum!=0&&sum%11==0){//当前选数到达阈值，且总和不为0可以被11整除，此时计数+1
        count++;
        return;
    }
    if(now>k||index==n)return;//选数超出阈值，或者当前数字坐标超出数组范围
    DFS(sum+a[index],index+1,now+1);//加上当前元素的情况 
    DFS(sum,index+1,now);//不加当前元素的情况
}
int main(){
    while(cin>>n){
        for(int i=0;i<n;i++)
            cin>>a[i];
        count==0;
        for(k=1;k<=n;k++)//k是当前选数的阈值，分别从1到n
        {
           DFS(0,0,0);
        }
        cout<<count<<endl;
    }
}

127 我素故我在

/*
	T49 我素故我在 
	算法概述：由于3维的纯素数一定与2维有关，4维的纯素数一定与3维
	有关，以此类推。所以可以先将8维和以下的纯素数通过深度优先搜索
	的方法求出并存起来，输入的时候直接问数组就好了 
*/ 

#include 
//声明函数
int purePrimes[10][100];// 存放所有的纯素数，如nums[1][2]表示的是一维的第二个纯素数   
int count_number[100];
int pure_prime(int number){
		if(number==1)
		return 0;
	int i;
	for(i=2;i<=number/2;i++)
		if(number%i==0)
			return 0;
	if(i>number/2)
		return 1;
}
//x代表纯素数 dimen代表维数  count_number代表当前维数第几个 
void dfs(int x,int dimen,int number)
{
	if(dimen>8)
		return ;
	purePrimes[dimen][number]=x;
	int i;
	for(i=1;i<10;i++) //if 10*x+i是素数  那么舍去尾数i 则10*x+1必是纯素数 
	{
			if(pure_prime(10*x+i))
			dfs(10*x+i,dimen+1,++count_number[dimen+1]);
		}
}
int main(){
		int N;
		scanf("%d",&N);
		int i;
		//count_number[100]={0};
			for(i=2;i<10;i++)
		{	if(pure_prime(i))	// 先将所有的纯素数求出来 
			dfs(i,1,++count_number[1]);
			} 
		while(N--)
		{	
			int T;
			scanf("%d",&T);	//不能提前输入 否则会超时	
		for( i=1;i<=count_number[T];i++)
			printf("%d\n",purePrimes[T][i]);
	}
	return 0;
} 

128 汉诺塔问题的第m步

#include 
#include 

 
int count=0;
int flag;

void hanoi(int n,char A,char B,char C,int m){
	if (n==0){
		return;	
	}
	hanoi(n-1,A,C,B,m); 将A上的n-1个盘子移动到B
	++count;
	if (count==m)
	{
		printf("%c--%c\n", A, C);
		flag=1;
		return;
	}
	hanoi(n-1,B,A,C,m);将B上的n-1个盘子移动到C
}

int main() {
	int m, n;
	while (scanf("%d%d", &n, &m) != EOF){
		flag = 0;//用来标识是否存在第M步
		count = 0;//统计当前走的步数
		hanoi(n, 'A', 'B', 'C',m);//盘子数n，以及步数m
		if (flag == 0){
			printf("none\n");
		}
	}
	return 0;
}

129 数字游戏

#include 
#include 
#include 

//连接两个字符串，将字符串从大到小排序即可
int rule(char x[],char y[])
{
	char sy[80],ys[80];
	strcpy(sy,x);
	strcpy(ys,y);
	strcat(sy,y);
	strcat(ys,x);
	if(strcmp(sy,ys)<0)
	{
		return 1;//如果前一个小于后一个
	}
	else
		return 0;
}

int main()
{
	int i,j,k,n;
	char str[50][50];//二维数组存储数字字符串
	while(scanf("%d",&n)!=EOF) 
	{

		if(n==0) {
			break;
		}

		for(i=0; i<n; ++i) {
			scanf("%s",str[i]);
		}

		//排序，冒泡
		for(j=0;j<n-1;j++)
		{
			for(k=n-1;k>j;k--)
			{
				if(rule(str[k-1],str[k]))
				{
					//如果前一个比后一个小的话交换
					char temp[50];
					strcpy(temp,str[k]);
					strcpy(str[k],str[k-1]);
					strcpy(str[k-1],temp);
				}
			}
		}
		for(i=0; i<n; i++) {
			printf("%s",str[i]);
		}
		printf("\n");
	}
	return 0;
}

133 FJ的字符串

思路：字符串的连接strcat，从第二个字符串开始，每一个字符串均是前一个字符串 + 一个新字符 + 前一个字符串

#include
#include 
int main(){
	int n,i;
	char a[200000]={"A"};//初始化字符串
	char b[200000];
	char c[2];
	scanf("%d",&n);
	if(n==1)//单独讨论仅一个字符的情况
		printf("%s",a);
	else{	
		for(i=1;i<n;i++){
			c[0]='A'+i;//新的字符
			strcpy(b,a);//保存前一个字符串的内容
			strcat(a,c);//加入新字符
			strcat(a,b);//加入前一个字符串
		}
		printf("%s",a);
	}
	return 0;
	
} 

135 芯片测试

思路：只用看被检测情况就可以了（看列上是0比较多还是1比较多）
如果1多于半数就是好的，0就是坏的

#include
#define MAX 100
int main()
{
int n,i,j;
int count1,count2;
int a[MAX][MAX];
scanf("%d",&n);
for(i=0;i<n;i++)
 for(j=0;j<n;j++)
  scanf("%d",&a[i][j]);
for (j = 0; j<n; j++)
 { 
  for (i = 0; i<n; i++)
  {
   count1=0;
   count2=0;
   if(a[i][j]==1)
    count1++;
   else
    count2++;  
  }
  if (count1>count2) 
  { 
   printf("%d ",j+1);
  }
 } 
return 0;
}