算法-藍橋杯習題（二）

藍橋杯習題

藍橋杯練習系統習題加答案更新新地址（已更新200左右習題）

http://blog.csdn.net/rodestillfaraway 

 

---

 

目錄

算法訓練（詳見 算法-藍橋杯習題（一））Go

算法訓練（詳見 算法-藍橋杯習題（二））Go

算法提升（waiting...）

歷屆試題（詳見 算法-藍橋杯習題（六））Go

歷屆試題（詳見 算法-藍橋杯習題（七））Go

 

---

 

藍橋杯練習系統評測數據

連接：

http://pan.baidu.com/s/1mhophTQ

密碼: m2pa

 

---

 

算法訓練（111題）

 

 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=一、p2=二、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的因子爲一、二、3，而6＝1＋2＋3，所以6就是「完數」。又如，28的因子爲一、二、四、七、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 }

 1 /*
 2 算法訓練 反置數
 3 
 4 問題描述
 5 　　一個整數的「反置數」指的是把該整數的每一位數字的順序顛倒過來所獲得的另外一個整數。若是一個整數的末尾是以0結尾，那麼在它的反置數當中，這些0就被省略掉了。好比說，1245的反置數是5421，而1200的反置數是21。請編寫一個程序，輸入兩個整數，而後計算這兩個整數的反置數之和sum，而後再把sum的反置數打印出來。要求：因爲在本題中須要屢次去計算一個整數的反置數，所以必須把這部分代碼抽象爲一個函數的形式。
 6 　　輸入格式：輸入只有一行，包括兩個整數，中間用空格隔開。
 7 　　輸出格式：輸出只有一行，即相應的結果。
 8 　　輸入輸出樣例
 9 樣例輸入
10 435 754
11 樣例輸出
12 199
13 */
14 #include <stdio.h>
15 #include <math.h>
16 
17 int getTheNumber(int num)
18 {
19     int number=1,i,j=1,flag=0;
20     
21     if(!num)
22     return 0;
23     
24     while(num)
25     {
26         i=num%10;
27         if(i||flag)
28         {
29             if(!flag)
30             {
31                 number=i;
32             }
33             else
34             {
35                 number=number*10+i;
36             }
37             flag=1;
38         }
39         num/=10;
40     }
41     
42     return number;
43 }
44 
45 main()
46 {
47     int n,m;
48     
49     scanf("%d%d",&n,&m);
50     
51     printf("%d\n",getTheNumber(getTheNumber(n)+getTheNumber(m)));
52     
53     return 0;
54 }

 1 /*
 2 算法訓練 字符刪除
 3 
 4 問題描述
 5 　　編寫一個程序，先輸入一個字符串str（長度不超過20），再輸入單獨的一個字符ch，而後程序會把字符串str當中出現的全部的ch字符都刪掉，從而獲得一個新的字符串str2，而後把這個字符串打印出來。
 6 　　輸入格式：輸入有兩行，第一行是一個字符串（內部沒有空格），第二行是一個字符。
 7 　　輸出格式：通過處理之後的字符串。
 8 　　輸入輸出樣例
 9 樣例輸入
10 123-45-678
11 -
12 樣例輸出
13 12345678
14 */
15 #include <stdio.h>
16 #include <string.h>
17 #define MaxSize 20+5
18 
19 void printResult(char str[],char ch)
20 {
21     int i;
22     for(i=0;i<strlen(str);i++)
23     {
24         if(str[i]!=ch)
25         {
26             printf("%c",str[i]);
27         }
28     }
29     printf("\n");
30 }
31 
32 main()
33 {
34     char ch,str[MaxSize];
35     
36     //if(scanf("%s %c",str,&ch)!=EOF)
37     if(gets(str)!=NULL)
38     {
39         scanf("%c",&ch);
40         printResult(str,ch);
41     }
42     
43     return 0;
44 }

  1 /*
  2 算法訓練 字串統計
  3 
  4 問題描述
  5 　　給定一個長度爲n的字符串S，還有一個數字L，統計長度大於等於L的出現次數最多的子串（不一樣的出現能夠相交），若是有多個，輸出最長的，若是仍然有多個，輸出第一次出現最先的。
  6 輸入格式
  7 　　第一行一個數字L。
  8 　　第二行是字符串S。
  9 　　L大於0，且不超過S的長度。
 10 輸出格式
 11 　　一行，題目要求的字符串。
 12 
 13 　　輸入樣例1：
 14 　　4
 15 　　bbaabbaaaaa
 16 
 17 　　輸出樣例1：
 18 　　bbaa
 19 
 20 　　輸入樣例2：
 21 　　2
 22 　　bbaabbaaaaa
 23 
 24 　　輸出樣例2：
 25 　　aa
 26 數據規模和約定
 27 　　n<=60
 28 　　S中全部字符都是小寫英文字母。
 29 
 30 　　提示
 31 　　枚舉全部可能的子串，統計出現次數，找出符合條件的那個
 32 */
 33 #include<stdio.h>
 34 #include<string.h>
 35 char b[60][60];
 36 int c[60];
 37 int main()
 38 {
 39     int l,i1,max=1,now=0,maxn=1,i2,weizhi=0,i3,i4,weizhi1,changdu1=-1;
 40     
 41     char a[10000];
 42     scanf("%d",&l);
 43     getchar();
 44     gets(a);
 45     int n=strlen(a);
 46     
 47     for(i1=n;i1>=l;i1--)//長度 
 48     {
 49         weizhi=0;
 50          for(i3=0;i3<n-i1;i3++)
 51                 c[i3]=0;
 52         for(i2=0;i2<n;i2++)//開始位置 
 53         {
 54             if(i2+i1>n) 
 55               break;
 56             int ok=1;      
 57            
 58 
 59             for(i3=0;i3<weizhi;i3++)//b的位置 
 60             {     int ko=1;
 61                   for(i4=0;i4<i1;i4++)    
 62                    {  
 63                          if(b[i3][i4]!=a[i2+i4])
 64                              ko=0;
 65                              
 66                       }
 67                       if(ko)
 68                         {  ok=0;
 69                            c[i3]++;
 70                         if(c[i3]>max)
 71                            {max=c[i3];
 72                             changdu1=i1;
 73                             weizhi1=i2;
 74                            }
 75                         break;
 76                      }
 77             
 78             }
 79             
 80             if(ok)
 81             {
 82                 for(i4=0;i4<i1;i4++)
 83                 {
 84                     b[weizhi][i4]=a[i2+i4];
 85                 }
 86                 c[weizhi]=1;
 87                 weizhi++;
 88             }
 89             
 90             
 91         }
 92         
 93     
 94         
 95     }
 96 
 97     for(i1=weizhi1;i1<weizhi1+changdu1;i1++)
 98       printf("%c",a[i1]);
 99       printf("\n");
100     return 0;
101 }

 1 /*
 2 算法訓練 進制轉換
 3 
 4 問題描述
 5 　　編寫一個程序，輸入一個二進制的字符串（長度不超過32），而後計算出相應的十進制整數，並把它打印出來。
 6 　　輸入格式：輸入爲一個字符串，每一個字符都是’0’或’1’，字符串的長度不超過32。
 7 　　輸出格式：輸出一個整數。
 8 　　輸入輸出樣例
 9 樣例輸入
10 1101
11 樣例輸出
12 13
13 */
14 #include <stdio.h>
15 #include <math.h>
16 #include <string.h>
17 #define MaxSize 32
18 
19 void print2Return10(char str[])
20 {
21     long long int num=0;
22     int lenth=strlen(str),i;
23     
24     for(i=0;i<lenth;i++)
25     {
26         if(str[i]!='0')
27         {
28             num+=pow(2,lenth-i-1);
29         }
30     }
31     
32     printf("%lld\n",num);
33     
34     return ;
35 }
36 
37 main()
38 {
39     char str[MaxSize];
40     
41     gets(str);
42     print2Return10(str);
43     
44     return 0;
45 }

 1 /*
 2 算法訓練 階乘
 3 
 4 問題描述
 5 　　一個整數n的階乘能夠寫成n!，它表示從1到n這n個整數的乘積。階乘的增加速度很是快，例如，13!就已經比較大了，已經沒法存放在一個整型變量中；而35!就更大了，它已經沒法存放在一個浮點型變量中。所以，當n比較大時，去計算n!是很是困難的。幸運的是，在本題中，咱們的任務不是去計算n!，而是去計算n!最右邊的那個非0的數字是多少。例如，5! = 1*2*3*4*5 = 120，所以5!最右邊的那個非0的數字是2。再如：7! = 5040，所以7!最右邊的那個非0的數字是4。請編寫一個程序，輸入一個整數n(n<=100)，而後輸出n! 最右邊的那個非0的數字是多少。
 6 　　輸入格式：輸入只有一個整數n。
 7 　　輸出格式：輸出只有一個整數，即n! 最右邊的那個非0的數字。
 8 　　輸入輸出樣例
 9 樣例輸入
10 6
11 樣例輸出
12 2
13 */
14 #include<stdio.h>
15 
16 int main(void)
17 {
18     int n;
19     int i;
20     int sum=1;
21     scanf("%d",&n);
22 
23     for(i=n;i>=1;i--)
24     {
25         sum = sum*i;
26         while(sum%10==0)
27             sum=sum/10;
28         if(sum/100>0)
29             sum=sum%100;
30     }
31 
32     printf("%d",sum%10);
33     
34     return 0;
35 }

 1 /*
 2 算法訓練 輸出米字形
 3 
 4 根據輸入的正整數n (1　　米字形由一個(2n-1)*(2n-1)的矩陣組成，矩陣包含從大寫A開始的n個字母
 5 　　例如:n=3時，包含A,B,C；n=4時，包含A,B,C,D。
 6 　　矩陣的正中間爲n個字母中字典序最大的那個，從這個字母開始，沿着西北、正北、東北、正西、正東、西南、正南、東南八個方向各有一條由大寫字母組成的直線。而且直線上的字母按字典序依次減少，直到大寫字母A。
 7 　　矩陣的其它位置用英文句號．填充。
 8 
 9 　　樣例輸入一
10 　　3
11 
12 　　樣例輸出一
13 　　Ａ．Ａ．Ａ
14 　　．ＢＢＢ．
15 　　ＡＢＣＢＡ
16 　　．ＢＢＢ．
17 　　Ａ．Ａ．Ａ
18 
19 　　樣例輸入二
20 　　4
21 
22 　　樣例輸出二
23 　　Ａ．．Ａ．．Ａ
24 　　．Ｂ．Ｂ．Ｂ．
25 　　．．ＣＣＣ．．
26 　　ＡＢＣＤＣＢＡ
27 　　．．ＣＣＣ．．
28 　　．Ｂ．Ｂ．Ｂ．
29 　　Ａ．．Ａ．．Ａ
30 */
31 #include <stdio.h>
32 int main()
33 {
34     int n,i,j,k,t;
35     scanf("%d",&n);
36     char a[2*n-1][2*n-1];
37     for(i=0;i<2*n-1;i++)
38     for(j=0;j<2*n-1;j++)
39     a[i][j]=0;
40     k=n;
41     
42     for(i=0;i<n-1;i++) //行數 
43     {
44         k--;  //k爲字符間隔 
45         t=i;
46         for(j=1;j<=3;j++)
47         {
48           a[i][t]='A'+i;
49           t+=k;
50         }
51     }
52     for(i=0;i<n;i++)    //中間一行 
53     {
54         a[n-1][i]='A'+i;
55         a[n-1][2*n-2-i]='A'+i;
56     }
57     for(i=0;i<=n-2;i++)   //填補句號 
58     for(j=0;j<2*n-1;j++)
59     {
60         if(a[i][j]==0)
61         a[i][j]='.';
62     }
63     
64     for(i=0;i<=n-2;i++)    //翻轉 
65     for(j=0;j<2*n-1;j++)
66     a[2*n-2-i][j]=a[i][j];
67     
68     for(i=0;i<2*n-1;i++)
69     {
70     for(j=0;j<2*n-1;j++)
71     printf("%c",a[i][j]);
72     printf("\n"); 
73     }
74 
75     
76     return 0;
77 }

 1 /*
 2 算法訓練 整數平均值
 3 
 4 編寫函數，求包含n個元素的整數數組中元素的平均值。要求在函數內部使用指針操縱數組元素，其中n個整數從鍵盤輸入，輸出爲其平均值。　　樣例輸入: （輸入格式說明：5爲輸入數據的個數，3 4 0 0 2 是以空格隔開的5個整數）
 5 　　5
 6 　　3 4 0 0 2
 7 樣例輸出
 8 1
 9 樣例輸入
10 7
11 3 2 7 5 2 9 1
12 樣例輸出
13 4
14 */
15 #include <stdio.h>
16 int main()
17 {
18 int n,i,j,sum=0;
19 scanf("%d",&n);
20 for(i=0;i<n;i++)
21 {
22 scanf("%d",&j);
23 sum+=j;
24 }
25 printf("%d",sum/n);
26 return 0;
27 }

 1 /*
 2 算法訓練 肯定元音字母位置
 3 
 4 輸入一個字符串，編寫程序輸出該字符串中元音字母的首次出現位置，若是沒有元音字母輸出0。英語元音字母只有‘a’、‘e’、‘i’、‘o’、‘u’五個。
 5 樣例輸入
 6 hello
 7 樣例輸出
 8 2
 9 樣例輸入
10 apple
11 樣例輸出
12 1
13 樣例輸入
14 pmp
15 樣例輸出
16 0
17 */
18 #include <stdio.h>
19 #include <string.h>
20 char s[1000]={0};
21 int isyuanyin(char a)
22 {
23 switch(a)
24 {
25 case 'a':return 1;
26 case 'e':return 1;
27 case 'i':return 1;
28 case 'o':return 1;
29 case 'u':return 1;
30 }
31 return 0;
32 }
33 int main()
34 {
35 int l,i,num=0;
36 scanf("%s",s);
37 l=strlen(s);
38 for(i=0;i<l;i++)
39 if(isyuanyin(s[i]))
40 {
41 num=i+1;break;
42 }
43 printf("%d",num);
44 return 0;
45 }

 1 /*
 2 算法訓練 斜率計算
 3 
 4 　　輸入兩個點的座標，即p1 = (x1, y1)和p2=(x2, y2)，求過這兩個點的直線的斜率。若是斜率爲無窮大輸出「INF」。
 5 樣例輸入
 6 1 2
 7 2 4
 8 樣例輸出
 9 2
10 樣例輸入
11 1 2
12 1 4
13 樣例輸出
14 INF
15 樣例輸入
16 1 2
17 3 2
18 樣例輸出
19 0
20 */
21 #include <stdio.h>
22 int main(){
23   int a,b,c,d;
24   scanf("%d %d",&a,&b);
25   scanf("%d %d",&c,&d);
26   if(a==c)
27       printf("INF\n");
28   else 
29       printf("%d\n",(b-d)/(a-c));
30 
31   return 0;
32 }

 1 /*
 2 算法訓練 十進制數轉八進制數
 3 
 4 　　編寫函數把一個十進制數輸出其對應的八進制數。
 5 樣例輸入
 6 9274
 7 樣例輸出
 8 22072
 9 */
10 #include<stdio.h>
11 int main()
12 {
13     int r;
14     scanf("%d",&r);
15     printf("%o",r);
16     return 0;
17 }

 1 /*
 2 算法訓練 篩選號碼
 3 
 4 問題描述
 5 　　有n我的圍成一圈，順序排號（編號爲1到n）。從第1我的開始報數(從1到3報數)，凡報到3的人退出圈子。從下一我的開始繼續報數，直到剩下最後一我的，遊戲結束。
 6 　　問最後留下的是原來第幾號的那位。
 7 　　舉個例子，8我的圍成一圈：
 8 　　1 2 3 4 5 6 7 8
 9 　　第1次報數以後，3退出，剩下：
10 　　1 2 4 5 6 7 8    （如今從4開始報數）
11 　　第2次報數以後，6退出，剩下：
12 　　1 2 4 5 7 8     （如今從7開始報數）
13 　　第3次報數以後，1退出，剩下：
14 　　2 4 5 7 8     （如今從2開始報數）
15 　　第4次報數以後，5退出，剩下：
16 　　2 4 7 8     （如今從7開始報數）
17 　　第5次報數以後，2退出，剩下：
18 　　4 7 8     （如今從4開始報數）
19 　　第6次報數以後，8退出，剩下：
20 　　4 7     （如今從4開始報數）
21 　　最後一次報數以後，4退出，剩下：
22 　　7.
23 　　因此，最後留下來的人編號是7。
24 輸入格式
25 　　一個正整數n，(1<n<10000)
26 輸出格式
27 　　一個正整數，最後留下來的那我的的編號。
28 樣例輸入
29 8
30 樣例輸出
31 7
32 數據規模和約定
33 　　對於100%的數據，1<n<10000。
34 */
35 #include <stdio.h> 
36 #include <malloc.h> 
37 typedef struct form{ 
38     int num; 
39     int date; 
40     struct form *link;} 
41 del; 
42 del *creat(int n){ 
43 int i; 
44 del *head,*p1,*p2; 
45 head=(del *)malloc(sizeof(del)); 
46 p1=(del *)malloc(sizeof(del)); 
47 head->link=p1; 
48 for(i=1;i<=n-2;i++){p2=(del *)malloc(sizeof(del)); 
49 p1->link=p2; 
50 p1=p2;} 
51 p1->link=head; 
52 return(head); 
53 } 
54 void dateop(del *h,int n){ 
55     del *p; 
56     int i,j=1; 
57     p=h; 
58     for(i=1;i<=n;i++){ 
59     p->num=i; 
60     p->date=j;j++; 
61     if(j==4) j=1; 
62     p=p->link;} 
63 } 
64 int deal(del *h,int n){ 
65     del *k; 
66     int s; 
67     int count,j=1,i; 
68     count=n; 
69     k=h; 
70     while(count!=1){ 
71     if(j==3&&k->date!=0) {k->date=0;count--;} 
72 k=k->link; 
73     j++; 
74     if(k->date==0) j--; 
75 if(j==4) j=1; 
76     } 
77     k=h; 
78     for(i=1;i<=n;i++){ 
79     if(k->date!=0) {s=k->num;break;} 
80     k=k->link;} 
81     return(s);} 
82 int main(){ 
83     int x; 
84     int i; 
85     del *p; 
86     scanf("%d",&x); 
87     p=creat(x); 
88     dateop(p,x); 
89     x=deal(p,x); 
90     for(i=1;i<x;i++){ 
91     p=p->link;} 
92     printf("%d",p->num); 
93 return 0; 
94 }

 1 /*
 2 算法訓練 鏈接字符串
 3 
 4 　編程將兩個字符串鏈接起來。例如country與side相鏈接成爲countryside。
 5 　　輸入兩行，每行一個字符串（只包含小寫字母，長度不超過100）；輸出一行一個字符串。
 6 樣例輸入
 7 country
 8 side
 9 樣例輸出
10 countryside
11 */
12 #include<stdio.h>
13 #include<string.h>
14 int main()
15 {
16     char s1[202],s2[202];
17     scanf("%s",s1);
18     scanf("%s",s2);
19     strcat(s1,s2);
20     printf("%s",s1);
21     printf("\n");
22     return 0;
23 }

 1 /*
 2 算法訓練 統計字符次數
 3 
 4 　　輸入一個字符串(長度在100之內)，統計其中數字字符出現的次數。
 5 樣例輸入
 6 Ab100cd200
 7 樣例輸出
 8 6
 9 */
10 #include<stdio.h>
11 int main()
12 {
13     char a[101];
14     int i=0,s=0;
15     gets(a);
16     for(i=0;*(a+i)!='\0';i++)
17     {
18         if(*(a+i)>=48&&*(a+i)<=57)
19         s++;
20     }
21     printf("%d",s);
22 return 0;
23 }

 1 /*
 2 算法訓練 成績的等級輸出
 3 
 4 　　輸入一個百分制的成績t後，按下式輸出它的等級。等級爲：90~100爲A，80~89爲B，70~79爲C，60~69爲D，0~59爲E。
 5 樣例輸入
 6 98
 7 樣例輸出
 8 A
 9 */
10 #include<stdio.h>
11 int main()
12 {
13     int t;
14     scanf("%d",&t);
15     
16     if(t>=90 && t<=100)
17     printf("A\n");
18     
19     if(t>=80 && t<=89)
20     printf("B\n");
21     
22     if(t>=70 && t<=79)
23     printf("C\n");
24     
25     if(t>=60 && t<=69)
26     printf("D\n");
27     
28     if(t<60)
29     printf("E\n");
30     return 0;
31 }

 1 /*
 2 算法訓練 比較字符串
 3 
 4 　編程實現兩個字符串s1和s2的字典序比較。（保證每個字符串不是另外一個的前綴，且長度在100之內）。若s1和s2相等，輸出0；若它們不相等，則指出其第一個不一樣字符的ASCII碼的差值：若是s1>s2，則差值爲正；若是s1<s2，則差值爲負。
 5 樣例輸入
 6 java basic
 7 樣例輸出
 8 8
 9 */
10 #include<stdio.h>
11 #include<string.h>
12 int min(int a,int b)
13 {
14 return a>b?b:a;
15 }
16 int main()
17 {
18 char a[1000];
19 char b[1000];
20 scanf("%s",a);
21 scanf("%s",b);
22 int k=min(strlen(a),strlen(b)),i1;
23 int ok=1;
24 for(i1=0;i1<k;i1++)
25 {       if(a[i1]!=b[i1])
26         {   printf("%d\n",a[i1]-b[i1]);
27             ok=0;
28              break;
29          }
30 }
31 if(ok==1)
32 if(strlen(a)==strlen(b))
33     printf("0\n");
34 else if(strlen(a)>strlen(b))
35      printf("%d\n",a[i1]);
36  else 
37     printf("%d\n",b[i1]);
38 return 0;  
39 }

 33333333333

33333333333333

3333333333333

 1 /*
 2 算法訓練 最長字符串  
 3 時間限制：1.0s   內存限制：512.0MB
 4        
 5 　　求出5個字符串中最長的字符串。每一個字符串長度在100之內，且全爲小寫字母。
 6 樣例輸入
 7 one two three four five
 8 樣例輸出
 9 three
10 */
11 #include<stdio.h>
12 #include<string.h>
13 int main()
14 {
15     char str[5][100];
16     int len[5];
17     int i,j,t,max;
18     max=0;
19     for(i=0;i<5;i++)
20     {
21         scanf("%s",str[i]);
22         len[i]=strlen(str[i]);
23         if(len[i]>max)
24         {
25             max=len[i];
26             t=i;
27         }    
28     }
29     puts(str[t]);
30     return 0;
31 }

 1 /*
 2   算法訓練 字符串逆序  
 3 時間限制：1.0s   內存限制：512.0MB
 4        
 5 　　輸入一個字符串，長度在100之內，按相反次序輸出其中的全部字符。
 6 樣例輸入
 7 tsinghua
 8 樣例輸出
 9 auhgnist
10 */
11 #include <stdio.h>
12 #include <string.h>
13 #define MaxSize 100
14 
15 int main()
16 {
17     char str[MaxSize];
18     int lenth;
19     
20     gets(str);
21     lenth=strlen(str);
22     while(lenth--)
23     {
24         putchar(str[lenth]);
25     }
26     printf("\n");
27     
28     return 0;
29 }

 1 /*
 2   算法訓練 斷定數字  
 3 時間限制：1.0s   內存限制：512.0MB
 4        
 5 　　編寫函數，判斷某個給定字符是否爲數字。
 6 樣例輸入
 7 9
 8 樣例輸出
 9 yes
10 */
11 #include <stdio.h>
12 #include <stdlib.h>
13 
14 int main(int argc, char *argv[]) 
15 {
16     char x;
17     scanf("%c",&x);
18     if('0'<=x&&x<='9')
19     {
20         printf("yes");
21     }
22     else
23     {
24         printf("no");
25     }
26     return 0;
27 }

 1 /*
 2   算法訓練 最大值與最小值的計算  
 3 時間限制：1.0s   內存限制：512.0MB
 4        
 5 　　輸入11個整數，計算它們的最大值和最小值。
 6 樣例輸入
 7 0 1 2 3 4 5 6 7 8 9 10
 8 樣例輸出
 9 10 0
10 */
11 #include<stdio.h>
12 int main()
13 {
14     int n;
15     int a[11],i1,max=-234234,min=93759347;
16     for(i1=0;i1<11;i1++)
17     {
18         scanf("%d",&a[i1]);
19         if(max<a[i1])
20           max=a[i1];
21         if(min>a[i1])
22            min=a[i1];
23     }
24     printf("%d %d\n",max,min);
25     
26     return 0;
27 }