算法-蓝桥杯习题（二）

 1 /*
 2 算法训练 明明的随机数
 3 
 4 问题描述
 5 　　明明想在学校中请一些同学一起做一项问卷调查，为了实验的客观性，他先用计算机生成了N个1到1000之间的随机整数（N≤100），对于其中重复的数字，只保留一个，把其余相同的数去掉，不同的数对应着不同的学生的学号。然后再把这些数从小到大排序，按照排好的顺序去找同学做调查。请你协助明明完成“去重”与“排序”的工作。
 6 输入格式
 7 　　输入有2行，第1行为1个正整数，表示所生成的随机数的个数：
 8 　　N
 9 　　第2行有N个用空格隔开的正整数，为所产生的随机数。
10 输出格式
11 　　输出也是2行，第1行为1个正整数M，表示不相同的随机数的个数。第2行为M个用空格隔开的正整数，为从小到大排好序的不相同的随机数。
12 样例输入
13 10
14 20 40 32 67 40 20 89 300 400 15
15 样例输出
16 8
17 15 20 32 40 67 89 300 400
18 题目来源
19 　　计13李震摘编自NOIP06PJ01
20 */
21 #include <stdio.h>
22 #define MaxSize 100+5
23 
24 void printArray(int array[],int lenth)
25 {
26     int i;
27     
28     printf("%d\n",lenth);
29     for(i=0;i<lenth;i++)
30     {
31         printf("%d ",array[i]);
32     }
33     printf("\n");
34     
35     return ;
36 } 
37 
38 void sortArray(int array[],int lenth)
39 {
40     int i,j;
41     
42     for(i=0;i<lenth;i++)
43     {
44         for(j=lenth-1;j>i;j--)
45         {
46             if(array[j]<array[j-1])
47             {
48                 int temp;
49                 temp=array[j];
50                 array[j]=array[j-1];
51                 array[j-1]=temp;
52             }
53         }
54     }
55     
56     return ;
57 } 
58 
59 main()
60 {
61     int N,m,i,j;
62     int array[MaxSize];
63     
64     scanf("%d",&N);
65     m=N;
66     for(i=0;i<m;i++)
67     {
68         scanf("%d",&array[i]);
69         for(j=0;j<i;j++)
70         {
71             if(array[i]==array[j])
72             {
73                 i--;
74                 m--;
75                 continue;
76             }
77         }
78     }
79     
80     sortArray(array,m);
81     
82     printArray(array,m);
83     
84     return 0;
85 }

  1 /*
  2 算法训练 字符串的展开
  3 
  4 　　在初赛普及组的“阅读程序写结果”的问题中，我们曾给出一个字符串展开的例子：如果在输入的字符串中，含有类似于“d-h”或者“4-8”的字串，我们就把它当作一种简写，输出时，用连续递增的字母获数字串替代其中的减号，即，将上面两个子串分别输出为“defgh”和“45678”。在本题中，我们通过增加一些参数的设置，使字符串的展开更为灵活。具体约定如下：
  5 　　(1) 遇到下面的情况需要做字符串的展开：在输入的字符串中，出现了减号“-”，减号两侧同为小写字母或同为数字，且按照ASCII码的顺序，减号右边的字符严格大于左边的字符。
  6 　　(2) 参数p1：展开方式。p1=1时，对于字母子串，填充小写字母；p1=2时，对于字母子串，填充大写字母。这两种情况下数字子串的填充方式相同。p1=3时，不论是字母子串还是数字字串，都用与要填充的字母个数相同的星号“*”来填充。
  7 　　(3) 参数p2：填充字符的重复个数。p2=k表示同一个字符要连续填充k个。例如，当p2=3时，子串“d-h”应扩展为“deeefffgggh”。减号两边的字符不变。
  8 　　(4) 参数p3：是否改为逆序：p3=1表示维持原来顺序，p3=2表示采用逆序输出，注意这时候仍然不包括减号两端的字符。例如当p1=1、p2=2、p3=2时，子串“d-h”应扩展为“dggffeeh”。
  9 　　(5) 如果减号右边的字符恰好是左边字符的后继，只删除中间的减号，例如：“d-e”应输出为“de”，“3-4”应输出为“34”。如果减号右边的字符按照ASCII码的顺序小于或等于左边字符，输出时，要保留中间的减号，例如：“d-d”应输出为“d-d”，“3-1”应输出为“3-1”。
 10 输入格式
 11 　　输入包括两行：
 12 　　第1行为用空格隔开的3个正整数，一次表示参数p1，p2，p3。
 13 　　第2行为一行字符串，仅由数字、小写字母和减号“-”组成。行首和行末均无空格。
 14 输出格式
 15 　　输出只有一行，为展开后的字符串。
 16 输入输出样例1
 17 输入格式
 18 输出格式
 19 1 2 1
 20 abcs-w1234-9s-4zz
 21 abcsttuuvvw1234556677889s-4zz
 22 输入输出样例2
 23 输入格式
 24 输出格式
 25 2 3 2
 26 a-d-d
 27 aCCCBBBd-d
 28 输入输出样例3
 29 输入格式
 30 输出格式
 31 3 4 2
 32 di-jkstra2-6
 33 dijkstra2************6
 34 数据规模和约定
 35 　　40%的数据满足：字符串长度不超过5
 36 　　100%的数据满足：1<=p1<=3，1<=p2<=8，1<=p3<=2。字符串长度不超过100
 37 */
 38 #include<stdio.h>
 39  #include<stdlib.h>
 40  #include<string.h>
 41  void fill(char a)
 42  {
 43  }
 44  int main()
 45  {
 46      char s[120]={0};
 47      memset(s,0,sizeof(s));
 48      int p1,p2,p3,i,j,k;
 49      scanf("%d%d%d",&p1,&p2,&p3);
 50      scanf("%s",s);
 51      for(i=0;i<strlen(s);i++)
 52      {
 53          if(s[i]==‘-‘)
 54          {
 55              if(s[i-1]>=‘a‘ && s[i-1]<=‘z‘ && s[i+1]>=‘a‘ && s[i+1]<=‘z‘ && s[i+1]>s[i-1]
 56              || s[i-1]>=‘0‘ && s[i-1]<=‘9‘ && s[i+1]>=‘0‘ && s[i+1]<=‘9‘ && s[i+1]>s[i-1])
 57              {
 58                  if(p1==3)
 59                  {
 60                      for(j=1;j<=p2*(s[i+1]-s[i-1]-1);j++)
 61                      {
 62                          printf("*");
 63                      }
 64                  }
 65                  else
 66                  {
 67                      if(s[i-1]>=‘0‘ && s[i-1]<=‘9‘ && s[i+1]>=‘0‘ && s[i+1]<=‘9‘)
 68                      {
 69                          if(p3==1)
 70                          {
 71                              for(j=s[i-1]+1;j<=s[i+1]-1;j++)
 72                              {
 73                                  for(k=1;k<=p2;k++)
 74                                  {
 75                                      printf("%c",j);
 76                                  }
 77                              }
 78                          }
 79                          else
 80                          {
 81                              for(j=s[i+1]-1;j>=s[i-1]+1;j--)
 82                              {
 83                                  for(k=1;k<=p2;k++)
 84                                  {
 85                                      printf("%c",j);
 86                                  }
 87                              }
 88                          }
 89                      }
 90                      else
 91                      {
 92                          if(p3==1)
 93                          {
 94                              for(j=s[i-1]+1;j<=s[i+1]-1;j++)
 95                              {
 96                                  for(k=1;k<=p2;k++)
 97                                  {
 98                                      printf("%c",p1==1?j:j-32);
 99                                  }
100                              }
101                          }
102                          else
103                          {
104                              for(j=s[i+1]-1;j>=s[i-1]+1;j--)
105                              {
106                                  for(k=1;k<=p2;k++)
107                                  {
108                                      printf("%c",p1==1?j:j-32);
109                                  }
110                              }
111                          }
112                      }
113                  }
114              }
115              else
116              {
117                  printf("%c",s[i]);
118              }
119          }
120          else
121          {
122              printf("%c",s[i]);
123          }
124      }
125      return 0;
126  }

 1 /*
 2 算法训练 貌似化学
 3 
 4 问题描述
 5 　　现在有a,b,c三种原料，如果他们按x:y:z混合，就能产生一种神奇的物品d。
 6 　　当然不一定只产生一份d，但a,b,c的最简比一定是x:y:z
 7 　　现在给你3种可供选择的物品:
 8 　　每个物品都是由a,b,c以一定比例组合成的，求出最少的物品数，使得他们能凑出整数个d物品（这里的最少是指三者个数的总和最少）
 9 输入格式
10 　　第一行三个整数，表示d的配比（x,y,z）
11 　　接下来三行，表示三种物品的配比，每行三个整数（<=10000）。
12 输出格式
13 　　四个整数，分别表示在最少物品总数的前提下a,b,c,d的个数（d是由a,b,c配得的）
14 　　目标答案<=10000
15 　　如果不存在满足条件的方案，输出NONE
16 样例输入
17 3 4 5
18 1 2 3
19 3 7 1
20 2 1 2
21 样例输出
22 8 1 5 7
23 */

 1 /*
 2 算法训练 最大体积
 3 
 4 问题描述
 5 　　每个物品有一定的体积（废话），不同的物品组合，装入背包会战用一定的总体积。假如每个物品有无限件可用，那么有些体积是永远也装不出来的。为了尽量装满背包，附中的OIER想要研究一下物品不能装出的最大体积。题目保证有解，如果是有限解，保证不超过2，000，000，000
 6 　　如果是无限解，则输出0
 7 输入格式
 8 　　第一行一个整数n（n<=10），表示物品的件数
 9 　　第2行到N+1行: 每件物品的体积(1<= <=500)
10 输出格式
11 　　一个整数ans，表示不能用这些物品得到的最大体积。
12 样例输入
13 3
14 3
15 6
16 10
17 样例输出
18 17
19 */
20 #include <stdio.h>
21 int n;
22 int a[510];
23 int f[100001];
24 void swap(int *a,int *b)
25 {
26    int c;
27    c=*a;
28    *a=*b;
29    *b=c;
30 }
31 int gcd(int a,int b)
32 {
33     if(a>b)
34       swap(&a,&b);
35     if(a==0)
36       return b;
37     return gcd(b%a,a);
38 }
39 int main()
40 {
41     int i,j,t;
42     scanf("%d",&n);
43     for(i=1;i<=n;i++)
44         scanf("%d",&a[i]);
45     t=a[1];
46     for(i=2;i<=n;i++)
47         t=gcd(t,a[i]);
48     if(t!=1)
49     {
50         printf("0\n");
51         return 0;
52     }
53     else
54     {
55           f[0]=1;
56           for(i=1;i<=n;i++)
57           {
58               for(j=a[i];j<=65536;j++)
59                   f[j] |= f[j-a[i]];
60           }
61           for(i=65536;i>=0;i--)
62           {
63               if(!f[i])
64               {
65                   printf("%d\n",i);
66                   return 0;
67               }
68           }
69           printf("0\n");
70           return 0;
71     }
72 }

 1 /*
 2 算法训练 9-7链表数据求和操作
 3 
 4 　　读入10个复数，建立对应链表，然后求所有复数的和。
 5 样例输入
 6 1 2
 7 1 3
 8 4 5
 9 2 3
10 3 1
11 2 1
12 4 2
13 2 2
14 3 3
15 1 1
16 样例输出
17 23+23i
18 */
19 #include <stdio.h>
20 
21 main()
22 {
23     int i,j,k,time=10,m=0,n=0;
24     
25     for(k=0;k<time;k++)
26     {
27         scanf("%d%d",&i,&j);
28         m+=i;
29         n+=j;
30     }
31     
32     printf("%d+%di\n",m,n);
33     
34     return 0;
35 }
36 /*
37 #include <stdio.h>
38 #include <malloc.h>
39 typedef struct linknode
40 {
41     int x;
42     int y;
43     struct linknode *next;
44 }node;
45 
46 int main()
47 {
48 node *begin=(node *)malloc(sizeof(node));
49 node *q=begin,*p;
50 int m=0,n=0;
51 scanf("%d%d",&q->x,&q->y);
52 int i;
53 for(i=1;i<10;i++)
54 {
55     p=(node *)malloc(sizeof(node));
56     scanf("%d%d",&p->x,&p->y);
57     q->next=p;
58     q=p;
59 }
60 p->next=NULL;
61 while(begin!=NULL)
62 {

63    m+=begin->x;    
64    n+=begin->y;
65    begin=begin->next;    
66 }
67 printf("%d+%di",m,n);
68     return 0;
69 }
70 */

 1 /*
 2  算法训练 6-3判定字符位置
 3  
 4  返回给定字符串s中元音字母的首次出现位置。英语元音字母只有‘a’、‘e’、‘i’、‘o’、‘u’五个。
 5 　　若字符串中没有元音字母，则返回0。
 6 　　只考虑小写的情况。
 7 样例输入
 8 and
 9 样例输出
10 1
11 */
12 #include <stdio.h>
13 #include <string.h>
14 #define MaxSize 1000
15 
16 main()
17 {
18     char str[MaxSize];
19     int lenth,i;
20     
21     gets(str);
22     lenth=strlen(str);
23     
24     for(i=0;i<lenth;i++)
25     {
26         if(str[i]==‘a‘||str[i]==‘e‘||str[i]==‘i‘||str[i]==‘o‘||str[i]==‘u‘)
27         {
28             printf("%d\n",i+1);
29             return 0;

30         }
31     }
32     printf("0\n");
33     
34     return 0;
35 }

 1 /*
 2 算法训练 黑色星期五
 3 
 4 问题描述
 5 　　有些西方人比较迷信，如果某个月的13号正好是星期五，他们就会觉得不太吉利，用古人的说法，就是“诸事不宜”。请你编写一个程序，统计出在某个特定的年份中，出现了多少次既是13号又是星期五的情形，以帮助你的迷信朋友解决难题。
 6 　　说明：（1）一年有365天，闰年有366天，所谓闰年，即能被4整除且不能被100整除的年份，或是既能被100整除也能被400整除的年份；（2）已知1998年1月1日是星期四，用户输入的年份肯定大于或等于1998年。
 7 　　输入格式：输入只有一行，即某个特定的年份（大于或等于1998年）。
 8 　　输出格式：输出只有一行，即在这一年中，出现了多少次既是13号又是星期五的情形。
 9 　　输入输出样例
10 样例输入
11 1998
12 样例输出
13 3
14 */
15 #include <stdio.h>
16 
17 int getWeekOfFirstDay(int year)
18 {
19     //已知1998年1月1日是星期四
20     int i=1998,week=3;
21     int days=0;
22     
23     for(i=1998;i<year;i++)
24     {
25         if(i%400==0||(i%4==0&&i%100!=0))
26         days+=366;
27         else
28         days+=365;
29     }
30     
31     return (days+week)%7;
32 }
33 
34 void printBlackFridayTimes(int year)
35 {
36     int day[2][12]={{31,28,31,30,31,30,31,31,30,31,30},{31,29,31,30,31,30,31,31,30,31,30}};
37     int week=getWeekOfFirstDay(year),flag=year%400==0||(year%4==0&&year%100!=0)?1:0;
38     int times=0,i,days=0;
39     
40     //遍历12个月 
41     for(i=0;i<12;i++)
42     {
43         //判断每个月13号是否是黑色星期五 
44         if((days+12+week)%7==4)
45         times++;
46         
47         days+=day[flag][i]; 
48     }
49     
50     printf("%d\n",times);
51     return ;
52 } 
53 
54 main()
55 {
56     int year;
57 
58     scanf("%d",&year);
59     printBlackFridayTimes(year);
60     
61     return 0;
62 }

 1 /*
 2 算法训练 阿尔法乘积
 3 
 4 问题描述
 5 　　计算一个整数的阿尔法乘积。对于一个整数x来说，它的阿尔法乘积是这样来计算的：如果x是一个个位数，那么它的阿尔法乘积就是它本身；否则的话，x的阿尔法乘积就等于它的各位非0的数字相乘所得到的那个整数的阿尔法乘积。例如：4018224312的阿尔法乘积等于8，它是按照以下的步骤来计算的：
 6 　　4018224312 → 4*1*8*2*2*4*3*1*2 → 3072 → 3*7*2 → 42 → 4*2 → 8
 7 　　编写一个程序，输入一个正整数（该整数不会超过6,000,000），输出它的阿尔法乘积。
 8 　　输入格式：输入只有一行，即一个正整数。
 9 　　输出格式：输出相应的阿尔法乘积。
10 　　输入输出样例
11 样例输入
12 4018224312
13 样例输出
14 8
15 */
16 #include <stdio.h>
17 
18 void getResult(long long int num)
19 {
20     long long  int n=1;
21     int i;
22     
23     //出口设计
24     if(num<10)
25     {
26         printf("%I64d\n",num);
27         
28         return ;
29     }
30     
31     //相似设计
32     do
33     {
34         i=num%10;
35         num/=10;
36         if(i)
37         {
38             n*=i;
39         }
40     }
41     while(num);
42     
43     //递归调用 
44     getResult(n);
45     
46 }
47 
48 main()
49 {
50     long long int num;
51     
52     scanf("%I64d",&num);
53     getResult(num);
54     
55     return 0; 
56 }

 1 /*
 2 算法训练 完数
 3 
 4 问题描述
 5 　　一个数如果恰好等于它的因子之和，这个数就称为“完数”。例如，6的因子为1、2、3，而6＝1＋2＋3，因此6就是“完数”。又如，28的因子为1、2、4、7、14，而28＝1＋2＋4＋7＋14，因此28也是“完数”。编写一个程序，判断用户输入的一个数是否为“完数”。
 6 　　输入格式：输入只有一行，即一个整数。
 7 　　输出格式：输出只有一行，如果该数为完数，输出yes，否则输出no。
 8 　　输入输出样例
 9 样例输入
10 6
11 样例输出
12 yes
13 */
14 #include <stdio.h>
15 
16 void getResult(int num)
17 {
18     int i,sum=0;
19     
20     for(i=1;i<num;i++)
21     {
22         if(num%i==0)
23         {
24             sum+=i;
25         }
26     }
27     
28     if(sum==num)
29     {
30         printf("yes\n");
31     }
32     else
33     {
34         printf("no\n");
35     }
36     
37 }
38 
39 main()
40 {
41     int num;
42     
43     scanf("%d",&num);
44     getResult(num);
45     
46     return 0;
47 }

 1 /*
 2 算法训练 数对
 3 
 4 问题描述
 5 　　编写一个程序，该程序从用户读入一个整数，然后列出所有的数对，每个数对的乘积即为该数。
 6 　　输入格式：输入只有一行，即一个整数。
 7 　　输出格式：输出有若干行，每一行是一个乘法式子。（注意：运算符号与数字之间有一个空格）
 8 　　输入输出样例
 9 样例输入
10 32
11 样例输出
12 1 * 32 = 32
13 2 * 16 = 32
14 4 * 8 = 32
15 8 * 4 = 32
16 16 * 2 = 32
17 32 * 1 = 32
18 */
19 #include <stdio.h>
20 
21 void getResult(int num)
22 {
23     int i;
24     
25     for(i=1;i<=num;i++)
26     {
27         if(num%i==0)
28         {
29             printf("%d * %d = %d\n",i,num/i,num);
30         }
31     }
32     
33     return ;
34 }
35 
36 main()
37 {
38     int num;
39     
40     scanf("%d",&num);
41     
42     getResult(num);
43     
44     return 0;
45 }

 1 /*
 2 算法训练 整除问题
 3 
 4 问题描述
 5 　　编写一个程序，输入三个正整数min、max和factor，然后对于min到max之间的每一个整数（包括min和max），如果它能被factor整除，就把它打印出来。
 6 　　输入格式：输入只有一行，包括三个整数min、max和factor。
 7 　　输出格式：输出只有一行，包括若干个整数。
 8 　　输入输出样例
 9 样例输入
10 1 10 3
11 样例输出
12 3 6 9
13 */
14 #include <stdio.h>
15 
16 void getResult(int min,int max,int factor)
17 {
18     int i;
19     
20     for(i=min;i<=max;i++)
21     {
22         if(i%factor==0)
23         {
24             printf("%d ",i);
25         }
26     }
27     printf("\n");
28     
29     return ;
30 }
31 
32 main()
33 {
34     int min,max,factor;
35     
36     scanf("%d%d%d",&min,&max,&factor);
37     getResult(min,max,factor);
38     
39     return 0;
40 }

 1 /*
 2 算法训练 薪水计算
 3 
 4 问题描述
 5 　　编写一个程序，计算员工的周薪。薪水的计算是以小时为单位，如果在一周的时间内，员工工作的时间不超过40 个小时，那么他/她的总收入等于工作时间乘以每小时的薪水。如果员工工作的时间在40 到50 个小时之间，那么对于前40 个小时，仍按常规方法计算；而对于剩余的超额部分，每小时的薪水按1.5 倍计算。如果员工工作的时间超过了50 个小时，那么对于前40 个小时，仍按常规方法计算；对于40～50 个小时之间的部分，每小时的薪水按1.5 倍计算；而对于超出50 个小时的部分，每小时的薪水按2 倍计算。请编写一个程序，输入员工的工作时间和每小时的薪水，然后计算并显示他/她应该得到的周薪。
 6 　　输入格式：输入只有一行，包括一个整数和一个实数，分别表示工作时间和每小时薪水。
 7 　　输出格式：输出只有一个实数，表示周薪，保留小数点后2位。
 8 　　输入输出样例
 9 样例输入
10 40 50
11 样例输出
12 2000.00
13 */
14 #include <stdio.h>
15 
16 main()
17 {
18     int time;
19     float money,sum;
20     
21     scanf("%d%f",&time,&money);
22     if(time<=40)
23     {
24         sum=time*money;
25         printf("%.2f\n",sum);
26     }
27     else
28     {
29         time-=40;
30         if(time<=10)
31         {
32             sum=time*money*1.5+40*money;
33             printf("%.2f\n",sum);
34         }
35         else
36         {
37             time-=10;
38             sum=time*money*2+10*money*1.5+40*money;
39             printf("%.2f\n",sum);
40         }
41     }
42     
43     return 0;
44 }

 1 /*
 2 算法训练 数位分离
 3 
 4 问题描述
 5 　　编写一个程序，输入一个1000 以内的正整数，然后把这个整数的每一位数字都分离出来，并逐一地显示。
 6 　　输入格式：输入只有一行，即一个1000以内的正整数。
 7 　　输出格式：输出只有一行，即该整数的每一位数字，之间用空格隔开。
 8 　　输入输出样例
 9 样例输入
10 769
11 样例输出
12 7 6 9
13 */
14 #include <stdio.h>
15 
16 void getResult(int num)
17 {
18     //出口 
19     if(num<10)
20     {
21         printf("%d ",num);
22         return ;
23     }
24     //递归 
25     getResult(num/10);
26     
27     printf("%d ",num%10);
28 }
29 
30 main()
31 {
32     int n;
33     
34     scanf("%d",&n);
35     getResult(n);
36     printf("\n"); 
37     
38     return 0;
39 }

 1 /*
 2 算法训练 Hello World!
 3 
 4 描述
 5 　　本题定义本学期作业题的输出格式，请认真阅读。
 6 　　如无特殊说明，开头无空格，间隔符为1个空格，答案最后必须输出换行符("\n")。
 7 输入格式
 8 　　无
 9 输出格式
10 　　Hello World!
11 */
12 #include <stdio.h>
13 
14 main()
15 {
16     printf("Hello World!\n");
17     
18     return 0;
19 }

  1 /*
  2 算法训练 新生舞会
  3 
  4 问题描述
  5 　　新生舞会开始了。n名新生每人有三个属性：姓名、学号、性别。其中，姓名用长度不超过20的仅由大小写字母构成的字符串表示，学号用长度不超过10的仅由数字构成的字符串表示，性别用一个大写字符‘F’或‘M’表示。任意两人的姓名、学号均互不相同。换言之，每个人可被其姓名或学号唯一确定。给出m对两人的信息（姓名或学号），判断他们是否能共舞。两人能共舞的充要条件为两人性别相异。
  6 输入格式
  7 　　第一行一个整数n（2<=n<=1000），表示学生人数。接下来的n行每行依次包含一名新生的姓名、学号、性别，分别用一个空格隔开。
  8 　　之后的一行是一个整数m(1<=m<=1000)，表示询问的数目。接着的m行每行包含两个信息（姓名或学号），保证两个信息不属于同一人，中间用一个空格隔开。
  9 输出格式
 10 　　对于每个询问输出一行，如果两人可以共舞，输出一个大写字母‘Y’，否则输出一个大写字母‘N’。
 11 样例输入
 12 4
 13 John 10 M
 14 Jack 11 M
 15 Kate 20 F
 16 Jim 21 M
 17 3
 18 John 11
 19 20 Jack
 20 Jim Jack
 21 样例输出
 22 N
 23 Y
 24 N
 25 
 26 提示
 27 可以把名字和学号都当成字符串处理。可以按以下流程实现。
 28 
 29 #include<iostream>
 30 #include<cstring>
 31 using namespace std;
 32 
 33 struct tstudent
 34 {
 35 char name[21];
 36 char num[21];
 37 char sex;
 38 };
 39 
 40 void readdata(tstudent student[], int n)
 41 {
 42 输入N个学生的信息
 43 }
 44 
 45 int findstudent(tstudent student[], int n, char* data)
 46 {
 47 if (data == NULL) return -1;
 48 
 49 判断是否有某个学生的学号或名字等于data，如果有，函数返回该学生在student数组中的序号，否则返回-1
 50 }
 51 
 52 void solve(tstudent student[], int n, int m)
 53 {
 54 char x[21], y[21];
 55 for (int i=0; i<m; i++) {
 56 输入两个人的信息X、Y。通过调用findstudent函数判断这两个人能否成为舞伴
 57 }
 58 }
 59 
 60 int main()
 61 {
 62 int n, m;
 63 tstudent student[1010];
 64 
 65 cin>>n;
 66 
 67 readdata(student, n);
 68 cin>>m;
 69 solve(student, n, m);
 70 }
 71 */
 72 #include <stdio.h>
 73 #include <string.h>
 74 #define MaxSize 1000+5
 75 
 76 typedef struct
 77 {
 78     char name[21];
 79     char num[21];
 80     char sex;
 81 }tstudent;
 82 
 83 void readdata(tstudent student[], int n)
 84 {
 85     int i;
 86     //输入N个学生的信息
 87     for(i=0;i<n;i++)
 88     {
 89         scanf("%s %s %c",student[i].name,student[i].num,&student[i].sex);
 90     }
 91 }
 92 
 93 int findstudent(tstudent student[], int n, char* data)
 94 {
 95     int i;
 96     
 97     if (data == NULL) 
 98     {
 99         return -1;
100     }
101     //判断是否有某个学生的学号或名字等于data，如果有，函数返回该学生在student数组中的序号，否则返回-
102     for(i=0;i<n;i++)
103     {
104         if(!strcmp(data,student[i].name)||!strcmp(data,student[i].num))
105         return i;
106     }
107     
108     return -1;
109 }
110 
111 void solve(tstudent student[], int n, int m)
112 {
113     char x[21], y[21];
114     int i,a,b;
115     
116     for (i=0; i<m; i++) 
117     {
118         //输入两个人的信息X、Y。通过调用findstudent函数判断这两个人能否成为舞伴
119         scanf("%s %s",x,y);
120         if((a=findstudent(student,n,x))!=-1&&(b=findstudent(student,n,y))!=-1)
121         {
122             if(student[a].sex!=student[b].sex)
123             printf("Y\n");
124             else
125             printf("N\n");
126         }
127         else
128         {
129             printf("N\n");
130         }
131     }
132 }
133 
134 int main()
135 {
136     int n, m;
137     tstudent student[MaxSize];
138     
139     scanf("%d",&n);
140     readdata(student, n);
141     
142     scanf("%d",&m);
143     solve(student, n, m);
144     
145     return ;
146 }