算法-藍橋杯習題（一）

藍橋杯習題

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

http://blog.csdn.net/rodestillfaraway 

 

---

 

目錄

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

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

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

算法提升（waiting...）

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

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

 

---

 

藍橋杯練習系統評測數據

連接：

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

密碼: m2pa

 

---

 

入門訓練（All-4題）

 

 1 /*
 2 入門訓練 A+B問題
 3 
 4 問題描述
 5 輸入A、B，輸出A+B。
 6 說明：在「問題描述」這部分，會給出試題的意思，以及所要求的目標。
 7 輸入格式
 8 輸入的第一行包括兩個整數，由空格分隔，分別表示A、B。
 9 說明：「輸入格式」是描述在測試你的程序時，所給的輸入必定知足的格式。
10 
11 作題時你應該假設所給的輸入是必定知足輸入格式的要求的，因此你不須要對輸入的格式進行檢查。多餘的格式檢查可能會拔苗助長，使用你的程序錯誤。
12 
13 在測試的時候，系統會自動將輸入數據輸入到你的程序中，你不能給任何提示。好比，你在輸入的時候提示「請輸入A、B」之類的話是不須要的，這些多餘的輸出會使得你的程序被斷定爲錯誤。
14 
15 輸出格式
16 輸出一行，包括一個整數，表示A+B的值。
17 說明：「輸出格式」是要求你的程序在輸出結果的時候必須知足的格式。
18 
19 在輸出時，你的程序必須知足這個格式的要求，不能少任何內容，也不能多任何內容。若是你的內容和輸出格式要求的不同，你的程序會被判斷爲錯誤，包括你輸出了提示信息、中間調試信息、計時或者統計的信息等。
20 
21 樣例輸入
22 12 45
23 說明：「樣例輸入」給出了一組知足「輸入格式」要求的輸入的例子。
24 
25 這裏給出的輸入只是可能用來測試你的程序的一個輸入，在測試的時候，還會有更多的輸入用來測試你的程序。
26 
27 樣例輸出
28 57
29 說明：「樣例輸出」給出了一組知足「輸出格式」要求的輸出的例子。
30 
31 樣例輸出中的結果是和樣例輸入中的是對應的，所以，你可使用樣例的輸入輸出簡單的檢查你的程序。
32 
33 要特別指出的是，可以經過樣例輸入輸出的程序並不必定是正確的程序，在測試的時候，會用不少組數據進行測試，而不侷限於樣例數據。有可能一個程序經過了樣例數據，但測試的時候仍只能得0分，可能由於這個程序只在一些相似樣例的特例中正確，而不具備通用性，再測試更多數據時會出現錯誤。
34 
35 好比，對於本題，若是你寫一個程序無論輸入是什麼都輸入57，則樣例數據是對的，可是測試其餘數據，哪怕輸入是1和2，這個程序也輸出57，則對於其餘數據這個程序都不正確。
36 
37 數據規模與約定
38 -10000 <= A, B <= 10000。
39 說明：「數據規模與約定」中給出了試題中主要參數的範圍。
40 
41 這個範圍對於解題很是重要，不一樣的數據範圍會致使試題須要使用不一樣的解法來解決。好比本題中給的A、B範圍不大，可使用整型(int)來保存，若是範圍更大，超過int的範圍，則要考慮其餘方法來保存大數。
42 
43 有一些範圍在方便的時候是在「問題描述」中直接給的，因此在作題時不只要看這個範圍，還要注意問題描述。
44 */
45 #include <stdio.h>
46  
47 int main()
48 {
49     int A, B;
50     
51     scanf("%d%d", &A, &B);
52     printf("%d", A+B);
53     
54     return 0;
55 }
56 
57 /*
58 //參考代碼Java
59 import java.io.BufferedReader;
60 import java.io.IOException;
61 import java.io.InputStreamReader;
62 
63 class Main
64 {
65     public static void main(String[] args) throws IOException
66     {
67         args = new BufferedReader(new InputStreamReader(System.in)).readLine().split(" ");
68         System.out.println(Integer.parseInt(args[0])+Integer.parseInt(args[1]));
69     }
70 }
71 */

 1 /*
 2 入門訓練 Fibonacci數列
 3 
 4 問題描述
 5 Fibonacci數列的遞推公式爲：Fn=Fn-1+Fn-2，其中F1=F2=1。
 6 
 7 當n比較大時，Fn也很是大，如今咱們想知道，Fn除以10007的餘數是多少。
 8 
 9 輸入格式
10 輸入包含一個整數n。
11 輸出格式
12 輸出一行，包含一個整數，表示Fn除以10007的餘數。
13 說明：在本題中，答案是要求Fn除以10007的餘數，所以咱們只要能算出這個餘數便可，而不須要先計算出Fn的準確值，再將計算的結果除以10007取餘數，直接計算餘數每每比先算出原數再取餘簡單。
14 
15 樣例輸入
16 10
17 樣例輸出
18 55
19 樣例輸入
20 22
21 樣例輸出
22 7704
23 數據規模與約定
24 1 <= n <= 1,000,000。
25 */
26 #include <stdio.h>
27 main()
28 {
29     unsigned long s=0,f1=1,f2=1,f3=1,n=0;
30     scanf("%d",&n);
31     
32     if(n>2)
33     for(s=3;s<=n;s++)
34     {
35         f3=(f2+f1)%10007;
36         f1=f2;
37         f2=f3;
38     }
39 
40     printf("%d",f3);
41     return 0;
42 }
43 
44 /*
45 //參考代碼C語言
46 #include <stdlib.h>
47 #include <stdio.h>
48 #define MOD 10007
49 #define MAXN 1000001
50 int n, i, F[MAXN];
51 int main()
52 {
53     scanf("%d", &n);
54     F[1] = 1;
55     F[2] = 1;
56     for (i = 3; i <= n; ++i)
57         F[i] = (F[i-1] + F[i-2]) % MOD;
58     printf("%d\n", F[n]);
59     return 0;
60 }
61 
62 
63 //參考代碼Java語言
64 import java.io.BufferedReader;
65 import java.io.IOException;
66 import java.io.InputStreamReader;
67 public class Main {
68     public static void main(String[] args) throws IOException{
69         BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
70         String s=reader.readLine();
71         int n=Integer.valueOf(s);
72         int f1=1,f2=1,f3=0;
73         if(n<3){
74             System.out.print("1");
75             return;}
76         for(int i=3;i<=n;i++)
77         {if(f1>10007)f1=f1%10007;
78         if(f2>10007)f2=f2%10007;
79         f3=f1+f2;
80         f1=f2;
81         f2=f3;
82         }
83         System.out.print(f3%10007);
84         }
85         
86 }
87 */

 1 /*
 2 入門訓練 序列求和
 3 
 4 問題描述
 5 求1+2+3+...+n的值。
 6 輸入格式
 7 輸入包括一個整數n。
 8 輸出格式
 9 輸出一行，包括一個整數，表示1+2+3+...+n的值。
10 樣例輸入
11 4
12 樣例輸出
13 10
14 樣例輸入
15 100
16 說明：有一些試題會給出多組樣例輸入輸出以幫助你更好的作題。
17 
18 通常在提交以前全部這些樣例都須要測試經過才行，但這不表明這幾組樣例數據都正確了你的程序就是徹底正確的，潛在的錯誤可能仍然致使你的得分較低。
19 
20 樣例輸出
21 5050
22 數據規模與約定
23 1 <= n <= 1,000,000,000。
24 說明：請注意這裏的數據規模。
25 
26 本題直接的想法是直接使用一個循環來累加，然而，當數據規模很大時，這種「暴力」的方法每每會致使超時。此時你須要想一想其餘方法。你能夠試一試，若是使用1000000000做爲你的程序的輸入，你的程序是否是能在規定的上面規定的時限內運行出來。
27 
28 本題另外一個要值得注意的地方是答案的大小不在你的語言默認的整型(int)範圍內，若是使用整型來保存結果，會致使結果錯誤。
29 
30 若是你使用C++或C語言並且準備使用printf輸出結果，則你的格式字符串應該寫成%I64d以輸出long long類型的整數。
31 */
32 #include<stdio.h>
33 main()
34 {
35     long long n,s=0;
36     
37     scanf("%I64d",&n);
38     
40     s=(1+n)*n/2;
43     printf("%I64d",s);
44     
45     return 0;
46 }
47 
48 /*
49 //參考代碼C語言
50 #include <stdio.h>
51 int main()
52 {
53     int n;
54     long long ret = 0, tmp;
55     scanf("%d", &n);
56     tmp = n;
57     printf("%I64d", (1+tmp) * tmp / 2);
58     return 0;
59 }
60 
61 //參考代碼Java語言
62 import java.io.BufferedReader;
63 import java.io.IOException;
64 import java.io.InputStreamReader;
65 public class Main {
66     public static void main(String args[]) throws NumberFormatException, IOException{
67         BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
68         long i = Integer.parseInt(strin.readLine());
69         long sum = (1+i)*i/2;
70         System.out.println(sum);
71     }
72 }
73 */

 1 /*
 2 入門訓練 圓的面積
 3 
 4 問題描述
 5 給定圓的半徑r，求圓的面積。
 6 輸入格式
 7 輸入包含一個整數r，表示圓的半徑。
 8 輸出格式
 9 輸出一行，包含一個實數，四捨五入保留小數點後7位，表示圓的面積。
10 說明：在本題中，輸入是一個整數，可是輸出是一個實數。
11 
12 對於實數輸出的問題，請必定看清楚實數輸出的要求，好比本題中要求保留小數點後7位，則你的程序必須嚴格的輸出7位小數，輸出過多或者過少的小數位數都是不行的，都會被認爲錯誤。
13 
14 實數輸出的問題若是沒有特別說明，舍入都是按四捨五入進行。
15 
16 樣例輸入
17 4
18 樣例輸出
19 50.2654825
20 數據規模與約定
21 1 <= r <= 10000。
22 提示
23 本題對精度要求較高，請注意π的值應該取較精確的值。你可使用常量來表示π，好比PI=3.14159265358979323，也可使用數學公式來求π，好比PI=atan(1.0)*4。
24 */
25 #include <stdio.h>
26 #include <math.h>
27 #define PI atan(1.0)*4
28 
29 main()
30 {
31     int r=0;
32     double s=0;
33     scanf("%d",&r);
34     
35     s=PI*r*r;
36     printf("%.7f",s);
37     
38     return 0;
39 }
40 
41 
42 /*
43 //參考代碼C語言
44 #include <stdio.h>
45 #include <math.h>
46 
47 int main()
48 {
49     int r;
50     double s, PI;
51     scanf("%d", &r);
52     PI = atan(1.0) * 4;
53     s = PI * r * r;
54     printf("%.7lf", s);
55     return 0;
56 }
57 
58 
59 //參考代碼Java語言
60 import java.io.BufferedReader;
61 import java.io.IOException;
62 import java.io.InputStreamReader;
63 import java.math.BigDecimal;
64 
65 
66 
67 
68    
69 70 71    public class Main {   
72     public static void main(String[] args) throws IOException {
73         // TODO Auto-generated method stub
74             BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
75             BigDecimal  bg = new BigDecimal(bf.readLine());
76             BigDecimal value = bg.multiply(bg.multiply(new BigDecimal(Math.PI))).setScale(7,BigDecimal.ROUND_HALF_UP);
77             System.out.println(value);
78     }
79 }
80 */

 

基礎練習(PartA-13題)

 

 

 1 /*
 2 基礎練習 閏年判斷
 3 
 4 問題描述
 5 給定一個年份，判斷這一年是否是閏年。
 6 
 7 當如下狀況之一知足時，這一年是閏年：
 8 
 9 1. 年份是4的倍數而不是100的倍數；
10 
11 2. 年份是400的倍數。
12 
13 其餘的年份都不是閏年。
14 
15 輸入格式
16 輸入包含一個整數y，表示當前的年份。
17 輸出格式
18 輸出一行，若是給定的年份是閏年，則輸出yes，不然輸出no。
19 說明：當試題指定你輸出一個字符串做爲結果（好比本題的yes或者no，你須要嚴格按照試題中給定的大小寫，寫錯大小寫將不得分。
20 
21 樣例輸入
22 2013
23 樣例輸出
24 no
25 樣例輸入
26 2016
27 樣例輸出
28 yes
29 數據規模與約定
30 1990 <= y <= 2050。
31 */
32 #include<stdio.h>
33 main()
34 {
35     int y;
36     scanf("%d",&y);
37 
38     if(y%4==0&&y%100!=0||y%400==0)
39         printf("yes\n");
40     else
41         printf("no\n");
42         
43     return 0;
44 }

 1 /*  2 基礎練習 01字串  3  4 問題描述  5 對於長度爲5位的一個01串，每一位均可能是0或1，一共有32種可能。它們的前幾個是：  6  7 00000  8  9 00001 10 11 00010 12 13 00011 14 15 00100 16 17 請按從小到大的順序輸出這32種01串。 18 19 輸入格式 20 本試題沒有輸入。 21 輸出格式 22 輸出32行，按從小到大的順序每行一個長度爲5的01串。 23 樣例輸出 24 00000 25 00001 26 00010 27 00011 28 <如下部分省略> 29 */ 30 #include<stdio.h> 31 main() 32 { 33 int a,b,c,d,e; 34 35 for(e=0;e<=1;e++) 36 for(d=0;d<=1;d++) 37 for(c=0;c<=1;c++) 38 for(b=0;b<=1;b++) 39 for(a=0;a<=1;a++) 40 printf("%d%d%d%d%d\n",e,d,c,b,a); 41 42 return 0; 43 }

 1 /*
 2 基礎練習 字母圖形
 3 
 4 問題描述
 5 利用字母能夠組成一些美麗的圖形，下面給出了一個例子：
 6 
 7 ABCDEFG
 8 
 9 BABCDEF
10 
11 CBABCDE
12 
13 DCBABCD
14 
15 EDCBABC
16 
17 這是一個5行7列的圖形，請找出這個圖形的規律，並輸出一個n行m列的圖形。
18 
19 輸入格式
20 輸入一行，包含兩個整數n和m，分別表示你要輸出的圖形的行數的列數。
21 輸出格式
22 輸出n行，每一個m個字符，爲你的圖形。
23 樣例輸入
24 5 7
25 樣例輸出
26 ABCDEFG
27 BABCDEF
28 CBABCDE
29 DCBABCD
30 EDCBABC
31 數據規模與約定
32 1 <= n, m <= 26。
33 */
34 #include <stdio.h>
35 #include <math.h>
36 
37 main()
38 {
39     int n,m,j,k;
40     scanf("%d %d",&n,&m);
41     if(n>=1&&m<=26)
42     for(j=0;j<n;j++)
43     {
44         for(k=0;k<m;k++)
45         printf("%c",65+abs(j-k));
46         printf("\n");
47     }
48     return 0;
49 }
50 /*
51 #include <stdio.h>
52 #include <stdlib.h>
53 #define MAXSIZE 26
54 
55 //輸出
56 void Print(char matrix[MAXSIZE][MAXSIZE],int n,int m)
57 {
58     int i,j;
59     for(i=0;i<n;i++)
60     {
61         for(j=0;j<m;j++)
62         {
63             printf("%c",matrix[i][j]);
64         }
65         printf("\n");
66     }
67 }
68 
69 //實現字母圖形
70 void Drawing(int n,int m)
71 {
72     int i,j;
73     int point=0;
74     char str;
75     char matrix[MAXSIZE][MAXSIZE];
76     for(i=0;i<n;i++)
77     {
78         str='A';
79         for(j=i;j<m;j++)
80         {
81             matrix[i][j]=str++;
82         }
83         str='A';
84         for(j=i-1;j>=0;j--)
85         {
86             matrix[i][j]=++str;
87         }
88     }
89     Print(matrix,n,m);
90 }
91 int main()
92 {
93     int n,m;
94     scanf("%d%d",&n,&m);
95     Drawing(n,m);
96     return 0;
97 }
98 */

 1 /*
 2 基礎練習 數列特徵
 3 
 4 問題描述
 5 給出n個數，找出這n個數的最大值，最小值，和。
 6 
 7 輸入格式
 8 第一行爲整數n，表示數的個數。
 9 
10 第二行有n個數，爲給定的n個數，每一個數的絕對值都小於10000。
11 
12 輸出格式
13 輸出三行，每行一個整數。第一行表示這些數中的最大值，第二行表示這些數中的最小值，第三行表示這些數的和。
14 樣例輸入
15 5
16 1 3 -2 4 5
17 樣例輸出
18 5
19 -2
20 11
21 數據規模與約定
22 1 <= n <= 10000。
23 */
24 #include <stdio.h>
25 #define MaxSize 10000
26 
27 main()
28 {
29     int n;
30     int sum=0,min=MaxSize,max=-MaxSize;
31     
32     scanf("%d",&n);
33     while(n--)
34     {
35         int temp,st;
36         scanf("%d",&temp);
37         
38         if(temp>max)
39         {
40             max=temp;
41         }
42         if(temp<min)
43         {
44             min=temp;
45         }
46         sum+=temp;
47     }
48     printf("%d\n%d\n%d\n",max,min,sum);
49     
50     return 0;
51 }

 1 /*
 2 基礎練習 查找整數
 3 
 4 問題描述
 5 給出一個包含n個整數的數列，問整數a在數列中的第一次出現是第幾個。
 6 
 7 輸入格式
 8 第一行包含一個整數n。
 9 
10 第二行包含n個非負整數，爲給定的數列，數列中的每一個數都不大於10000。
11 
12 第三行包含一個整數a，爲待查找的數。
13 
14 輸出格式
15 若是a在數列中出現了，輸出它第一次出現的位置(位置從1開始編號)，不然輸出-1。
16 樣例輸入
17 6
18 1 9 4 8 3 9
19 9
20 樣例輸出
21 2
22 數據規模與約定
23 1 <= n <= 1000。
24 */
25 #include<stdio.h>
26 #define MaxSize 1000+5
27 
28 main()
29 {
30     int n,i,a[MaxSize],s,m=0;
31     scanf("%d",&n);
32 
33     for(i=0;i<n;i++)
34     {
35         scanf("%d ",&a[i]);
36     } 
37     
38     scanf("%d",&s);
39     for(i=0;i<n;i++)
40     {
41         if(s==a[i])
42         {
43             printf("%d\n",i+1);
44             return 0;
45         }
46     }
47     
48     printf("-1\n");
49 
50     return 0;    
51 }

 1 /*
 2 基礎練習 迴文數
 3 
 4 問題描述
 5 　　1221是一個很是特殊的數，它從左邊讀和從右邊讀是同樣的，編程求全部這樣的四位十進制數。
 6 輸出格式
 7 　　按從小到大的順序輸出知足條件的四位十進制數。
 8 */
 9 #include<stdio.h>
10 main()
11 {
12     int a,b,i;
13     for(a=1;a<=9;a++)
14     for(b=0;b<=9;b++)
15     {
16         printf("%d%d%d%d\n",a,b,b,a);
17     }
18     return 0;
19 }
20 
21 /*
22 #include<stdio.h>
23 int main()
24 {
25  int a,b,c,d,i;
26  for(i=1000;i<=9999;i++)
27  {  
28    a=i/1000;
29    b=i/100%10;
30    c=i/10%10;
31    d=i%10;
32   if(a==d&&b==c)
33     printf("%d\n",i);
34  }
35 return 0;
36 }
37 */

 1 /*
 2 基礎練習 特殊迴文數
 3 
 4 問題描述
 5 　　123321是一個很是特殊的數，它從左邊讀和從右邊讀是同樣的。
 6 　　輸入一個正整數n， 編程求全部這樣的五位和六位十進制數，知足各位數字之和等於n 。
 7 輸入格式
 8 　　輸入一行，包含一個正整數n。
 9 輸出格式
10 　　按從小到大的順序輸出知足條件的整數，每一個整數佔一行。
11 樣例輸入
12 52
13 樣例輸出
14 899998
15 989989
16 998899
17 數據規模和約定
18 　　1<=n<=54。
19 */
20 #include<stdio.h>
21 main()
22 {
23     int n,a,b,c;
24     scanf("%d",&n);
25 
26     for(a=1;a<=9;a++)
27     for(b=0;b<=9;b++)
28     for(c=0;c<=9;c++)
29     {
30         if(n==2*a+2*b+c)
31         printf("%d%d%d%d%d\n",a,b,c,b,a);
32     }
33     for(a=1;a<=9;a++)
34     for(b=0;b<=9;b++)
35     for(c=0;c<=9;c++)
36     {
37         if(n==2*a+2*b+2*c)
38         printf("%d%d%d%d%d%d\n",a,b,c,c,b,a);
39     }
40 
41     return 0;
42 }
43 /*
44 #include<stdio.h>
45 int main()
46 {
47     int a,b,c,d,e,f,t,all;
48     scanf("%d",&t);
49     for(a=1;a<10;a++)
50         for(b=0;b<10;b++)
51             for(c=0;c<10;c++)
52                 for(d=0;d<10;d++)
53                     for(e=0;e<10;e++)
54                     {
55                         if(a==e)
56                             if(b==d)
57                                 {
58                                     all=a+b+c+d+e;
59                                     if(all==t)
60                                     printf("%d\n",a*10000+b*1000+c*100+d*10+e);
61                                 }
62                     }
63     for(a=1;a<10;a++)
64         for(b=0;b<10;b++)
65             for(c=0;c<10;c++)
66                 for(d=0;d<10;d++)
67                     for(e=0;e<10;e++)
68                         for(f=0;f<10;f++)
69                         {
70                             if(a==f)
71                                 if(b==e)
72                                     if(c==d)
73                                     {
74                                         all=a+b+c+d+e+f;
75                                         if(all==t)
76                                             printf("%d\n",a*100000+b*10000+c*1000+d*100+e*10+f);
77                                     }
78                         }
79                     
80     return 0;
81 }
82 
83 */

 1 /*
 2 基礎練習 十進制轉十六進制
 3 
 4 問題描述
 5 　　十六進制數是在程序設計時常常要使用到的一種整數的表示方式。它有0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F共16個符號，分別表示十進制數的0至15。十六進制的計數方法是滿16進1，因此十進制數16在十六進制中是10，而十進制的17在十六進制中是11，以此類推，十進制的30在十六進制中是1E。
 6 　　給出一個非負整數，將它表示成十六進制的形式。
 7 輸入格式
 8 　　輸入包含一個非負整數a，表示要轉換的數。0<=a<=2147483647
 9 輸出格式
10 　　輸出這個整數的16進製表示
11 樣例輸入
12 30
13 樣例輸出
14 1E
15 */
16 #include<stdio.h>
17 main()
18 {
19     int a;
20     scanf("%d",&a);
21     if(0<=a&&a<=2147483647)
22     printf("%X",a);
23     return 0;
24 }
25 /*
26 #include <stdio.h>
27 #include <stdlib.h>
28 char data[]={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
29 
30 //輸出
31 void Print(char *num,int n)
32 {
33     int i;
34     for(i=n-1;i>=0;i--) printf("%c",num[i]);
35     printf("\0");
36     printf("\n");
37 }
38 
39 //將十六進制數轉換爲十進制數
40 int Transform(char *num,long long value)
41 {
42     int n=0;
43     while(value>=16)
44     {
45         num[n++]=data[value%16];
46         value/=16;
47     }
48     num[n++]=data[value%16];
49     return n;
50 }
51 
52 int main()
53 {
54     long long value;
55     char num[10];
56     int n;
57     scanf("%I64d",&value);
58     n=Transform(num,value);
59     Print(num,n);
60     return 0;
61 }
62 */

 1 /*
 2 基礎練習 十六進制轉十進制
 3 
 4 問題描述
 5 　　從鍵盤輸入一個不超過8位的正的十六進制數字符串，將它轉換爲正的十進制數後輸出。
 6 　　注：十六進制數中的10~15分別用大寫的英文字母A、B、C、D、E、F表示。
 7 樣例輸入
 8 FFFF
 9 樣例輸出
10 65535
11 */
12 #include<stdio.h>
13 #include<string.h>
14 
15 int main()
16 {
17     char a[9];
18     int i;
19     unsigned int n=1,b=0;
20     scanf("%s",a);
21     
22     for(i=strlen(a)-1;i>=0;i--)
23     {
24         if(a[i]<='9')
25         b+=(a[i]-'0')*n;
26         else
27         b+=(a[i]-'A'+10)*n;
28         n=16*n;
29     }
30     printf("%u\n",b);
31     return 0;
32 }
33 /*
34 #include<stdio.h>
35 #include<string.h> 
36 #include<math.h>
37 int main()
38 { 
39  double sum=0,x;
40  char a[8];
41  int len,i=0;
42  gets(a);
43  len=strlen(a);
44  while(len)
45  {
46   if(a[len-1]>='A'&&a[len-1]<='F')
47     x=(a[len-1]-'7')*pow(16,i++);
48   else
49       x=(a[len-1]-'0')*pow(16,i++);
50   sum+=x;
51   len--;
52  }
53  printf("%.0lf",sum);
54 
55  return 0;
56  
57  }
58 */

  1 /*
  2 基礎練習 十六進制轉八進制
  3 
  4 問題描述
  5 　　給定n個十六進制正整數，輸出它們對應的八進制數。
  6 輸入格式
  7 　　輸入的第一行爲一個正整數n （1<=n<=10）。
  8 　　接下來n行，每行一個由0~九、大寫字母A~F組成的字符串，表示要轉換的十六進制正整數，每一個十六進制數長度不超過100000。
  9 輸出格式
 10 　　輸出n行，每行爲輸入對應的八進制正整數。
 11 注意
 12 　　輸入的十六進制數不會有前導0，好比012A。
 13 　　輸出的八進制數也不能有前導0。
 14 樣例輸入
 15 2
 16 39
 17 123ABC
 18 樣例輸出
 19 71
 20 4435274
 21 提示
 22 　　先將十六進制數轉換成某進制數，再由某進制數轉換成八進制。
 23 */
 24 #include <cstdio>
 25 #include <iostream>
 26 #include <cstring>
 27 #include <string>
 28 #include <cmath>
 29 #include <algorithm>
 30 #include <set>
 31 using namespace std;
 32 char str[100005], num;
 33 void Fun(int i, int state)
 34 {
 35 int temp;
 36 if(i < 0)
 37 {
 38 if(num != 0)
 39 {
 40 printf("%d", num);
 41 }
 42 return;
 43 }
 44 if(state != 3)
 45 {
 46 temp = str[i] >= '0' && str[i] <= '9' ? str[i] - '0' : str[i] - 'A' + 10;
 47 temp <<= state;
 48 num |= temp;
 49 temp = num;
 50 num >>= 3;
 51 Fun(i - 1, state + 1);
 52 printf("%d", (temp & 1) + (temp & 2) + (temp & 4));
 53 }
 54 else
 55 {
 56 temp = num;
 57 num >>= 3;
 58 Fun(i, 0);
 59 printf("%d", (temp & 1) + (temp & 2) + (temp & 4));
 60 }
 61 }
 62 int main()
 63 {
 64 int n;
 65 scanf("%d", &n);
 66 while(n--)
 67 {
 68 num = 0;
 69 scanf("%s", str);
 70 Fun(strlen(str) - 1, 0);
 71 printf("\n");
 72 }
 73 return 0;
 74 }
 75 /*
 76 #include <stdio.h>
 77 #include <stdlib.h>
 78 #include <string.h>
 79 
 80 #define MaxSize 100000
 81 
 82 void saveB(char *b,char c3,char c2,char c1,char c0,int start)
 83 {
 84     b[start]=c3;
 85     b[start+1]=c2;
 86     b[start+2]=c1;
 87     b[start+3]=c0;
 88 }
 89 int htob(char *h,char *b)
 90 {
 91     int i,j;
 92     int hl=strlen(h);
 93     for(i=0;i<hl;i++)
 94         switch(h[i])
 95         {
 96             case '0':
 97                 {
 98                     saveB(b,'0','0','0','0',4*i);
 99                     break;
100                 }
101             case '1':
102                 {
103                     saveB(b,'0','0','0','1',4*i);
104                     break;
105                 }
106             case '2':
107                 {
108                     saveB(b,'0','0','1','0',4*i);
109                     break;
110                 }
111             case '3':
112                 {
113                     saveB(b,'0','0','1','1',4*i);
114                     break;
115                 }
116             case '4':
117                 {
118                     saveB(b,'0','1','0','0',4*i);
119                     break;
120                 }
121             case '5':
122                 {
123                     saveB(b,'0','1','0','1',4*i);
124                     break;
125                 }
126             case '6':
127                 {
128                     saveB(b,'0','1','1','0',4*i);
129                     break;
130                 }
131             case '7':
132                 {
133                     saveB(b,'0','1','1','1',4*i);
134                     break;
135                 }
136             case '8':
137                 {
138                     saveB(b,'1','0','0','0',4*i);
139                     break;
140                 }
141             case '9':
142                 {
143                     saveB(b,'1','0','0','1',4*i);
144                     break;
145                 }
146             case 'A':
147                 {
148                     saveB(b,'1','0','1','0',4*i);
149                     break;
150                 }
151             case 'B':
152                 {
153                     saveB(b,'1','0','1','1',4*i);
154                     break;
155                 }
156             case 'C':
157                 {
158                     saveB(b,'1','1','0','0',4*i);
159                     break;
160                 }
161             case 'D':
162                 {
163                     saveB(b,'1','1','0','1',4*i);
164                     break;
165                 }
166             case 'E':
167                 {
168                     saveB(b,'1','1','1','0',4*i);
169                     break;
170                 }
171             case 'F':
172                 {
173                     saveB(b,'1','1','1','1',4*i);
174                     break;
175                 }
176         }
177     return 4*hl;
178 }
179 int btoo(char *b,char *o,int bl)
180 {
181     int i,j;
182     int ol;
183     int value;
184     if(bl%3==0)
185         ol=bl/3;
186     else
187         ol=bl/3+1;
188     j=bl-1;
189     for(i=ol-1;i>=0;i--)
190     {
191         if(i>0)
192             o[i]=b[j]-48+(b[j-1]-48)*2+(b[j-2]-48)*4+48;
193         else
194         {
195             switch(j)
196             {
197                 case 2:
198                     o[i]=b[j]-48+(b[j-1]-48)*2+(b[j-2]-48)*4+48;
199                     break;
200                 case 1:
201                     o[i]=b[j]-48+(b[j-1]-48)*2+48;
202                     break;
203                 case 0:
204                     o[i]=b[j];
205                     break;
206             }
207 
208         }
209         j=j-3;
210     }
211     return ol;
212 }
213 void printO(char *o,int ol)
214 {
215     int i=0;
216     if(o[0]=='0')
217         i=1;
218     for(;i<ol;i++)
219     {
220         printf("%c",o[i]);
221     }
222     printf("\n");
223 }
224 main()
225 {
226     char h[MaxSize];
227     char b[4*MaxSize];
228     char o[4*MaxSize/3+1];
229     int n,i,bl,ol;
230     scanf("%d",&n);
231     getchar();
232     for(i=0;i<n;i++)
233     {
234         gets(h);
235         bl=htob(h,b);
236         ol=btoo(b,o,bl);
237         
238         printO(o,ol);
239     }
240 }
241 
242 */

  1 /*
  2 基礎練習 數列排序
  3 
  4 問題描述
  5 　　給定一個長度爲n的數列，將這個數列按從小到大的順序排列。1<=n<=200
  6 輸入格式
  7 　　第一行爲一個整數n。
  8 　　第二行包含n個整數，爲待排序的數，每一個整數的絕對值小於10000。
  9 輸出格式
 10 　　輸出一行，按從小到大的順序輸出排序後的數列。
 11 樣例輸入
 12 5
 13 8 3 6 4 9
 14 樣例輸出
 15 3 4 6 8 9
 16 */
 17 #include <stdio.h>
 18 
 19 int main()
 20 {
 21     int n,i,j,s,a[200];
 22     
 23     scanf("%d",&n);
 24 
 25     for(i=1;i<=n;i++)
 26     {
 27         scanf("%d",&a[i]);
 28     }
 29     
 30     i=n+1;
 31      
 32     while(i--)
 33     for(j=1;j<i;j++)
 34     {
 35         if(a[j]>a[j+1])
 36         {
 37             s=a[j+1];
 38             a[j+1]=a[j];
 39             a[j]=s;
 40         }
 41     }
 42     
 43     for(i=1;i<=n;i++)
 44     printf("%d ",a[i]);
 45     
 46     return 0;
 47 }
 48 /*
 49 #include <stdio.h>
 50 #include <stdlib.h>
 51 void Print(int *data,int n)
 52 {
 53     int i;
 54     for(i=0;i<n;i++)
 55     {
 56         printf("%d ",data[i]);
 57     }
 58     printf("\n");
 59 }
 60 
 61 int Split(int *data,int pre,int rear)
 62 {
 63     int value=data[pre];
 64     while(pre<rear)
 65     {
 66         while(data[rear]>=value && pre<rear) rear--;
 67         data[pre]=data[rear];
 68         while(data[pre]<value && pre<rear) pre++;
 69         data[rear]=data[pre];
 70     }
 71     data[pre]=value;
 72     return pre;
 73 }
 74 
 75 //快速排序
 76 void QuickSort(int *data,int pre,int rear)
 77 {
 78     if(pre<rear)
 79     {
 80         int mid=Split(data,pre,rear);
 81         QuickSort(data,pre,mid-1);
 82         QuickSort(data,mid+1,rear);
 83     }
 84 }
 85 
 86 int main()
 87 {
 88     int i;
 89     int n;
 90     int *data;
 91     scanf("%d",&n);
 92     data=(int *)malloc(sizeof(int)*n);
 93     for(i=0;i<n;i++)
 94     {
 95         scanf("%d",&data[i]);
 96     }
 97     QuickSort(data,0,n-1);
 98     Print(data,n);
 99     return 0;
100 }
101 */

 

基礎練習(PartB-17題)

 

 1 /*
 2 基礎練習 時間轉換
 3 
 4 問題描述
 5 　　給定一個以秒爲單位的時間t，要求用「<H>:<M>:<S>」的格式來表示這個時間。<H>表示時間，<M>表示分鐘，而<S>表示秒，它們都是整數且沒有前導的「0」。例如，若t=0，則應輸出是「0:0:0」；若t=3661，則輸出「1:1:1」。
 6 輸入格式
 7 　　輸入只有一行，是一個整數t（0<=t<=86399）。
 8 輸出格式
 9 　　輸出只有一行，是以「<H>:<M>:<S>」的格式所表示的時間，不包括引號。
10 樣例輸入
11 0
12 樣例輸出
13 0:0:0
14 樣例輸入
15 5436
16 樣例輸出
17 1:30:36
18 */
19 #include<stdio.h>
20  
21  int main()
22 {
23   int a,b,c,d;
24   scanf("%d",&a);
25 
26   b=(int)(a/3600);
27   c=(int)(a%3600)/60;
28   d=(int)((a%3600)%60);
29   printf("%d:%d:%d",b,c,d);
30   return 0;
31   
32 }

 1 /*
 2 基礎練習 字符串對比
 3 
 4 問題描述
 5 　　給定兩個僅由大寫字母或小寫字母組成的字符串(長度介於1到10之間)，它們之間的關
 6 
 7 系是如下4中狀況之一：
 8 　　1：兩個字符串長度不等。好比 Beijing 和 Hebei
 9 　　2：兩個字符串不只長度相等，並且相應位置上的字符徹底一致(區分大小寫)，好比 
10 
11 Beijing 和 Beijing
12 　　3：兩個字符串長度相等，相應位置上的字符僅在不區分大小寫的前提下才能達到完
13 
14 全一致（也就是說，它並不知足狀況2）。好比 beijing 和 BEIjing
15 　　4：兩個字符串長度相等，可是即便是不區分大小寫也不能使這兩個字符串一致。比
16 
17 如 Beijing 和 Nanjing
18 　　編程判斷輸入的兩個字符串之間的關係屬於這四類中的哪一類，給出所屬的類的編號
19 
20 。
21 輸入格式
22 　　包括兩行，每行都是一個字符串
23 輸出格式
24 　　僅有一個數字，代表這兩個字符串的關係編號
25 樣例輸入
26 BEIjing
27 beiJing
28 樣例輸出
29 3
30 */
31 #include<stdio.h>
32 #include<string.h>
33 int main()
34 {
35     char a[10],b[10],i,n,l=2;
36     gets(a);gets(b);
37     n=strlen(a);
38     if(strlen(b)!=n)l=1;
39     else
40     {
41     for(i=0;i<n;i++)
42     if(a[i]==b[i]||a[i]==b[i]+32||a[i]+32==b[i])
43         if(a[i]!=b[i])l=3;
44         else ;else {l=4;break;}
45     }
46 printf("%d",l);
47 return 0;
48 }  

 1 /*
 2 基礎練習 分解質因數
 3 
 4 問題描述
 5 　　求出區間[a,b]中全部整數的質因數分解。
 6 輸入格式
 7 　　輸入兩個整數a，b。
 8 輸出格式
 9 　　每行輸出一個數的分解，形如k=a1*a2*a3...(a1<=a2<=a3...，k也是從小到大的)(具體可看樣例)
10 樣例輸入
11 3 10
12 樣例輸出
13 3=3
14 4=2*2
15 5=5
16 6=2*3
17 7=7
18 8=2*2*2
19 9=3*3
20 10=2*5
21 提示
22 　　先篩出全部素數，而後再分解。
23 數據規模和約定
24 　　2<=a<=b<=10000
25 */
26 #include<stdio.h>
27 #include<math.h>
28 int main()
29 {
30     long int b,i,k,m,n,w = 0;
31     scanf("%ld%ld",&m,&n);
32     for(i = m;i<=n;i++)
33     {
34         printf("%ld=",i);
35         b = i;k = 2;
36         while(k<=sqrt(i))
37         {
38             if(b%k==0)
39             {
40                 b = b/k;
41                 if(b>1)
42                 {
43                     printf("%ld*",k);continue;
44                 }   
45                 if(b==1) printf("%ld\n",k);
46             }
47             k++;
48         }
49         if(b>1&&b<i) printf("%ld\n",b);
50         if(b==i)
51         {
52             printf("%d\n",i);w++;
53         }     
54     }
55     return 0;
56 }

 1 /*
 2 基礎練習 矩陣乘法
 3 
 4 問題描述
 5 　　給定一個N階矩陣A，輸出A的M次冪（M是非負整數）
 6 　　例如：
 7 　　A =
 8 　　1 2
 9 　　3 4
10 　　A的2次冪
11 　　7 10
12 　　15 22
13 輸入格式
14 　　第一行是一個正整數N、M（1<=N<=30, 0<=M<=5），表示矩陣A的階數和要求的冪
15 
16 數
17 　　接下來N行，每行N個絕對值不超過10的非負整數，描述矩陣A的值
18 輸出格式
19 　　輸出共N行，每行N個整數，表示A的M次冪所對應的矩陣。相鄰的數之間用一個空格
20 
21 隔開
22 樣例輸入
23 2 2
24 1 2
25 3 4
26 樣例輸出
27 7 10
28 15 22
29 */
30 #include <stdio.h>
31 #include <string.h>
32 #define N 100
33 int A[N][N],t[N][N],r[N][N];
34 int main()
35 {
36     int n,m,i,j,k;
37     scanf("%d%d",&n,&m);
38     for(i=0;i<n;i++)
39         for(j=0;j<n;j++)
40             scanf("%d",&A[i][j]);
41     for(i=0;i<n;i++) 
42          r[i][i]=1;//單位矩陣，如同數的乘法中的1
43     while(m--)
44     {
45         memset(t,0,sizeof(t));
46         for(i=0;i<n;i++)
47             for(j=0;j<n;j++)
48                 for(k=0;k<n;k++)
49                     t[i][j]+=r[i][k]*A[k][j];
50         for(i=0;i<n;i++)
51             for(j=0;j<n;j++)
52                  r[i][j]=t[i][j];
53     }
54     for(i=0;i<n;i++)
55     {
56         for(j=0;j<n-1;j++)
57             printf("%d ",r[i][j]);    
58         printf("%d\n",r[i][j]);    
59     }
60     return 0;
61 }

 1 /*
 2 基礎練習 矩形面積交
 3 
 4 問題描述
 5 　　平面上有兩個矩形，它們的邊平行於直角座標系的X軸或Y軸。對於每一個矩形，咱們
 6 
 7 給出它的一對相對頂點的座標，請你編程算出兩個矩形的交的面積。
 8 輸入格式
 9 　　輸入僅包含兩行，每行描述一個矩形。
10 　　在每行中，給出矩形的一對相對頂點的座標，每一個點的座標都用兩個絕對值不超過
11 
12 10^7的實數表示。
13 輸出格式
14 　　輸出僅包含一個實數，爲交的面積，保留到小數後兩位。
15 樣例輸入
16 1 1 3 3
17 2 2 4 4
18 樣例輸出
19 1.00
20 */
21 #include <stdio.h>
22 #define max(x,y) ((x)>(y)?(x):(y))
23 #define min(x,y) ((x)<(y)?(x):(y))
24 int main()
25 {
26     double x1,y1,x2,y2;//矩形1 
27     double x3,y3,x4,y4;//矩形2    
28     double m1,n1;//交集左上角座標 
29     double m2,n2;//交集右下角座標 
30     scanf("%lf%lf%lf%lf",&x1,&y1,&x2,&y2);
31     scanf("%lf%lf%lf%lf",&x3,&y3,&x4,&y4);
32     m1=max(min(x1,x2),min(x3,x4));
33     n1=max(min(y1,y2),min(y3,y4));
34     m2=min(max(x1,x2),max(x3,x4));
35     n2=min(max(y1,y2),max(y3,y4));
36     if(m2>m1&&n2>n1)  
37         printf("%.2f\n",(m2-m1)*(n2-n1));    
38     else 
39         printf("0.00\n");
40     return 0;
41 }

 1 /*
 2 基礎練習 完美的代價
 3 
 4 問題描述
 5 　　迴文串，是一種特殊的字符串，它從左往右讀和從右往左讀是同樣的。小龍龍認爲回
 6 
 7 文串纔是完美的。如今給你一個串，它不必定是迴文的，請你計算最少的交換次數使得該
 8 
 9 串變成一個完美的迴文串。
10 　　交換的定義是：交換兩個相鄰的字符
11 　　例如mamad
12 　　第一次交換 ad : mamda
13 　　第二次交換 md : madma
14 　　第三次交換 ma : madam (迴文！完美！)
15 輸入格式
16 　　第一行是一個整數N，表示接下來的字符串的長度(N <= 8000)
17 　　第二行是一個字符串，長度爲N.只包含小寫字母
18 輸出格式
19 　　若是可能，輸出最少的交換次數。
20 　　不然輸出Impossible
21 樣例輸入
22 5
23 mamad
24 樣例輸出
25 3
26 */
27 #include<stdio.h>  
28 int changes(char s[],char x,int n); 
29 char x='0'; 
30 int main(void) 
31 { 
32    int n,i,k=0,b[26]={0},j; 
33    char y,s[8000]={0}; 
34    scanf("%d",&n); 
35    getchar(); 
36    for(i=0;i<n;i++) 
37    scanf("%c",&s[i]); 
38    for(i=0;i<n;i++)
39    { 
40        j=s[i]-'a'; 
41        b[j]++; 
42    } 
43    for(j=0;j<26;j++)
44    { 
45        if(b[j]%2!=0)
46        { 
47            k++; 
48            x=j+'a';
49            
50       } 
51    } 
52    if(k>=2) 
53    printf("Impossible\n"); 
54    else 
55    printf("%d\n",changes(s,x,n)); 
56    return 0; 
57 }  
58 
59 int changes(char s[],char x,int n) 
60 { 
61     int i,change=0,j,k; 
62     for(i=0;i<n/2;i++)
63     { 
64        if(s[i]==x)
65        { 
66          for(j=i;j<n-i-1;j++) 
67          if(s[n-i-1]==s[j]) 
68          break; 
69          change+=j-i; 
70          for(k=j;k>i;k--) 
71          s[k]=s[k-1]; 
72          s[i]=s[n-i-1]; 
73        }
74        else 
75        { 
76        for(j=n-i-1;j>=i;j--) 
77        if(s[i]==s[j]) 
78        break; 
79        change+=n-i-1-j; 
80        for(k=j;k<n-i-1;k++) 
81        s[k]=s[k+1]; 
82        s[n-i-1]=s[i]; 
83        }
84     }  
85     return change; 
86 }  

 1 /*
 2 基礎練習 數的讀法
 3 
 4 問題描述
 5 　　Tom教授正在給研究生講授一門關於基因的課程，有一件事情讓他頗爲頭疼：一條染
 6 
 7 色體上有成千上萬個鹼基對，它們從0開始編號，到幾百萬，幾千萬，甚至上億。
 8 　　好比說，在對學生講解第1234567009號位置上的鹼基時，光看着數字是很難準確的念
 9 
10 出來的。
11 　　因此，他迫切地須要一個系統，而後當他輸入12 3456 7009時，會給出相應的念法：
12 　　十二億三千四百五十六萬七千零九
13 　　用漢語拼音表示爲
14 　　shi er yi san qian si bai wu shi liu wan qi qian ling jiu
15 　　這樣他只須要照着念就能夠了。
16 　　你的任務是幫他設計這樣一個系統：給定一個阿拉伯數字串，你幫他按照中文讀寫的
17 
18 規範轉爲漢語拼音字串，相鄰的兩個音節用一個空格符格開。
19 　　注意必須嚴格按照規範，好比說「10010」讀做「yi wan ling yi shi」而不是「yi wan 
20 
21 ling shi」，「100000」讀做「shi wan」而不是「yi shi wan」，「2000」讀做「er qian」而
22 
23 不是「liang qian」。
24 輸入格式
25 　　有一個數字串，數值大小不超過2,000,000,000。
26 輸出格式
27 　　是一個由小寫英文字母，逗號和空格組成的字符串，表示該數的英文讀法。
28 樣例輸入
29 1234567009
30 樣例輸出
31 shi er yi san qian si bai wu shi liu wan qi qian ling jiu
32 */
33 #include<stdio.h>
34 #include<string.h>
35 int main()
36 {
37     char a[100];int i,j,k,l;
38     char b[20][10]={"ling","yi","er","san","si","wu","liu","qi","ba","jiu"};
39     char c[20][10]={"","","shi","bai","qian","wan","shi","bai","qian","yi","shi"};
40     gets(a);
41     l=strlen(a);
42     for(i=0;i<l;i++){
43         j=a[i]-48;
44         if(j==0){if(i<l-1)if(a[i+1]!=48)printf("%s ",b[j]);}
45         else 
46         if((l-i==2||l-i==6||l-i==10)&&j==1)printf("%s ",c[l-i]);
47         else if(a[i-1]==48&&j==1)printf("%s ",c[l-i]);
48         else printf("%s %s ",b[j],c[l-i]);
49     }
50     printf("\n");
51     return 0;
52 }

 1 /*
 2 基礎練習 Sine之舞
 3 
 4 問題描述
 5 　　最近FJ爲他的奶牛們開設了數學分析課，FJ知道若要學好這門課，必須有一個好的三
 6 
 7 角函數基本功。因此他準備和奶牛們作一個「Sine之舞」的遊戲，寓教於樂，提升奶牛們
 8 
 9 的計算能力。
10 　　不妨設
11 　　An=sin(1–sin(2+sin(3–sin(4+...sin(n))...)
12 　　Sn=(...(A1+n)A2+n-1)A3+...+2)An+1
13 　　FJ想讓奶牛們計算Sn的值，請你幫助FJ打印出Sn的完整表達式，以方便奶牛們作題。
14 輸入格式
15 　　僅有一個數：N<201。
16 輸出格式
17 　　請輸出相應的表達式Sn，以一個換行符結束。輸出中不得含有多餘的空格或換行、回
18 
19 車符。
20 樣例輸入
21 3
22 樣例輸出
23 ((sin(1)+3)sin(1–sin(2))+2)sin(1–sin(2+sin(3)))+1
24 */
25 #include <stdio.h>
26 
27 void printA(int n, int k)
28 {
29     if (n == k)
30         printf("sin(%d)", n);
31     else
32     {
33         printf("sin(%d", n);
34         printf(n % 2 == 0 ? "+" : "-");
35         printA(n + 1, k);
36         printf(")");
37     }
38 }
39 
40 void printS(int n, int k)
41 {
42     if (n == 1)
43     {
44         printA(1, n);
45         printf("+%d", k - n);
46     }
47     else
48     {
49         printf("(");
50         printS(n - 1, k);
51         printf(")");
52         printA(1, n);
53         printf("+%d", k - n);
54     }
55 }
56 
57 int main()
58 {
59     int N;
60     scanf("%d", &N);
61     printS(N, N + 1);
62     printf("\n");
63     return 0;
64 }

 1 /*
 2 基礎練習 FJ的字符串
 3 
 4 問題描述
 5 　　FJ在沙盤上寫了這樣一些字符串：
 6 　　A1 = 「A」
 7 　　A2 = 「ABA」
 8 　　A3 = 「ABACABA」
 9 　　A4 = 「ABACABADABACABA」
10 　　… …
11 　　你能找出其中的規律並寫全部的數列AN嗎？
12 輸入格式
13 　　僅有一個數：N ≤ 26。
14 輸出格式
15 　　請輸出相應的字符串AN，以一個換行符結束。輸出中不得含有多餘的空格或換行、
16 
17 回車符。
18 樣例輸入
19 3
20 樣例輸出
21 ABACABA
22 */
23 #include<stdio.h>
24 void f(int a)
25 {
26     if(a==0)printf("%c",'A');
27     else 
28     {
29         f(a-1);
30         printf("%c",a+'A');
31         f(a-1);
32     }
33 }
34 int main()
35 {
36     int a;scanf("%d",&a);f(a-1);printf("\n");
37     return 0;
38 }

 1 /*
 2 基礎練習 芯片測試
 3 
 4 問題描述
 5 　　有n（2≤n≤20）塊芯片，有好有壞，已知好芯片比壞芯片多。
 6 　　每一個芯片都能用來測試其餘芯片。用好芯片測試其餘芯片時，能正確給出被測試芯片
 7 
 8 是好仍是壞。而用壞芯片測試其餘芯片時，會隨機給出好或是壞的測試結果（即此結果與
 9 
10 被測試芯片實際的好壞無關）。
11 　　給出全部芯片的測試結果，問哪些芯片是好芯片。
12 輸入格式
13 　　輸入數據第一行爲一個整數n，表示芯片個數。
14 　　第二行到第n+1行爲n*n的一張表，每行n個數據。表中的每一個數據爲0或1，在這n行
15 
16 中的第i行第j列（1≤i, j≤n）的數據表示用第i塊芯片測試第j塊芯片時獲得的測試結果，1
17 
18 表示好，0表示壞，i=j時一概爲1（並不表示該芯片對自己的測試結果。芯片不能對自己
19 
20 進行測試）。
21 輸出格式
22 　　按從小到大的順序輸出全部好芯片的編號
23 樣例輸入
24 3
25 1 0 1
26 0 1 0
27 1 0 1
28 樣例輸出
29 1 3
30 */
31 #include<stdio.h>
32 #include<string.h>
33 int main()
34 {
35     int a[50][50];int i,j,n,s;scanf("%d",&n);
36      for(j=0;j<n;j++)for(i=0;i<n;i++)scanf("%d",&a[i][j]);
37     for(j=0;j<n;j++){s=0;for(i=0;i<n;i++)s=s+a[j][i];if(s>n/2.0)printf("%d ",j+1);}
38     return 0;
39 }

 1 /*
 2 基礎練習 龜兔賽跑預測
 3 
 4 問題描述
 5 　　話說這個世界上有各類各樣的兔子和烏龜，可是研究發現，全部的兔子和烏龜都有一個共同的特色——喜歡賽跑。因而世界上各個角落都不斷在發生着烏龜和兔子的比賽，小華對此很感興趣，因而決定研究不一樣兔子和烏龜的賽跑。他發現，兔子雖然跑比烏龜快，但它們有衆所周知的毛病——驕傲且懶惰，因而在與烏龜的比賽中，一旦任一秒結束後兔子發現本身領先t米或以上，它們就會停下來休息s秒。對於不一樣的兔子，t，s的數值是不一樣的，可是全部的烏龜倒是一致——它們不到終點決不中止。
 6 　　然而有些比賽至關漫長，全程觀看會耗費大量時間，而小華髮現只要在每場比賽開始後記錄下兔子和烏龜的數據——兔子的速度v1（表示每秒兔子能跑v1米），烏龜的速度v2，以及兔子對應的t，s值，以及賽道的長度l——就能預測出比賽的結果。可是小華很懶，不想經過手工計算推測出比賽的結果，因而他找到了你——清華大學計算機系的高才生——請求幫助，請你寫一個程序，對於輸入的一場比賽的數據v1，v2，t，s，l，預測該場比賽的結果。
 7 輸入格式
 8 　　輸入只有一行，包含用空格隔開的五個正整數v1，v2，t，s，l，其中(v1,v2<=100;t<=300;s<=10;l<=10000且爲v1,v2的公倍數)
 9 輸出格式
10 　　輸出包含兩行，第一行輸出比賽結果——一個大寫字母「T」或「R」或「D」，分別表示烏龜獲勝，兔子獲勝，或者二者同時到達終點。
11 　　第二行輸出一個正整數，表示獲勝者（或者雙方同時）到達終點所耗費的時間（秒數）。
12 樣例輸入
13 10 5 5 2 20
14 樣例輸出
15 D
16 4
17 樣例輸入
18 10 5 5 1 20
19 樣例輸出
20 R
21 3
22 樣例輸入
23 10 5 5 3 20
24 樣例輸出
25 T
26 4 
27 */
28 #include<stdio.h>
29 int main()
30 {
31     int v1,v2,t,s,l,s1=0,s2=0,i=0;
32     scanf("%d %d %d %d %d",&v1,&v2,&t,&s,&l);
33     while(s1<l&&s2<l)
34     {
35         s1+=v1;
36         s2+=v2;
37         i++;
38         if(s1==l||s2==l)break;
39         if(s1-s2>=t)s1-=v1*s;
40     }
41     if(s1>s2)      printf("R\n");
42     else if(s2>s1) printf("T\n");
43     else           printf("D\n");
44     printf("%d",i);
45     return 0;
46 }

 1 /*
 2 基礎練習 回形取數  
 3 
 4 問題描述
 5 　　回形取數就是沿矩陣的邊取數，若當前方向上無數可取或已經取過，則左轉90度。一開始位於矩陣左上角，方向向下。
 6 輸入格式
 7 　　輸入第一行是兩個不超過200的正整數m, n，表示矩陣的行和列。接下來m行每行n個整數，表示這個矩陣。
 8 輸出格式
 9 　　輸出只有一行，共mn個數，爲輸入矩陣回形取數獲得的結果。數之間用一個空格分隔，行末不要有多餘的空格。
10 樣例輸入
11 3 3
12 1 2 3
13 4 5 6
14 7 8 9
15 樣例輸出
16 1 4 7 8 9 6 3 2 5
17 樣例輸入
18 3 2
19 1 2
20 3 4
21 5 6
22 樣例輸出
23 1 3 5 6 4 2
24 */
25 #include <stdio.h>
26 #include <string.h>
27 
28 #define MAX_N 200
29 int m,n;
30 int a[MAX_N][MAX_N],b[MAX_N][MAX_N];
31 int s=0;
32 void solve(int i,int j)
33 {
34     if(i<m && i>=0 && j<n && j>=0 && b[i][j] == 0)
35     {
36         printf("%d ",a[i][j]);
37         b[i][j] = 1;
38     
39     }
40     else
41     {
42         s++;
43         return ;
44     }
45     if(s%4 == 0)
46     solve(i+1,j);
47     if(s%4 == 1)
48     solve(i,j+1);
49     if(s%4 == 2)
50     solve(i-1,j);
51     if(s%4 == 3)
52     solve(i,j-1);
53     if(s%4 == 0)
54     solve(i+1,j);
55     if(s%4 == 1)
56     solve(i,j+1);
57     if(s%4 == 2)
58     solve(i-1,j);
59     if(s%4 == 3)
60     solve(i,j-1);
61 
62     return ;
63 }
64 
65 int main()
66 {
67     memset(b,0,sizeof(b));
68     scanf("%d%d",&m,&n);
69     int i,j;
70     for(i=0; i<m; i++)
71         for(j=0; j<n; j++)
72             scanf("%d",&a[i][j]);
73     solve(0,0);
74     puts("");
75     return 0;
76 }

 1 #include<stdio.h>
 2 #include<string.h>
 3 int main()
 4 {
 5     int h,m;
 6     char g[50][50]={"zero","one","two","three","four","five","six","seven","eight","nine","ten","eleven","twelve","thirteen","fourteen","fifteen","sixteen","seventeen","eighteen","nineteen","twenty"};
 7     char s[10][10]={"twenty","thirty","forty","fifty"};
 8     scanf("%d%d",&h,&m);
 9     if(m==0)if(h<21)printf("%s o'clock",g[h]);else {printf("%s %s o'clock",s[h/10-2],g[h%10]);}
10     else {
11         if(h<21)printf("%s ",g[h]);else {printf("%s %s ",s[h/10-2],g[h%10]);}
12         if(m<21)printf("%s ",g[m]);else {printf("%s %s ",s[m/10-2],g[m%10]);}
13         }
14     printf("\n");
15 return 0;
16 }

 1 /*
 2 基礎練習 2n皇后問題
 3 
 4 問題描述
 5 　　給定一個n*n的棋盤，棋盤中有一些位置不能放皇后。如今要向棋盤中放入n個黑皇后
 6 
 7 和n個白皇后，使任意的兩個黑皇后都不在同一行、同一列或同一條對角線上，任意的兩
 8 
 9 個白皇后都不在同一行、同一列或同一條對角線上。問總共有多少种放法？n小於等於8。
10 輸入格式
11 　　輸入的第一行爲一個整數n，表示棋盤的大小。
12 　　接下來n行，每行n個0或1的整數，若是一個整數爲1，表示對應的位置能夠放皇后，
13 
14 若是一個整數爲0，表示對應的位置不能夠放皇后。
15 輸出格式
16 　　輸出一個整數，表示總共有多少种放法。
17 樣例輸入
18 4
19 1 1 1 1
20 1 1 1 1
21 1 1 1 1
22 1 1 1 1
23 樣例輸出
24 2
25 樣例輸入
26 4
27 1 0 1 1
28 1 1 1 1
29 1 1 1 1
30 1 1 1 1
31 樣例輸出
32 0
33 */
34 #include<stdio.h>
35 
36 int sum=0;
37 
38 int p(int n,int x,int y,int m[][8],int s)
39 {
40     int i,j;
41     for(i=x-1;i>=0;i--)
42     {
43         if(m[i][y]==s)return 0;
44     }
45     for(i=x-1,j=y-1;i>=0&&j>=0;i--,j--)
46     {
47         if(m[i][j]==s)return 0;
48     }
49     for(i=x-1,j=y+1;i>=0&&j<n;i--,j++)
50     {
51         if(m[i][j]==s)return 0;
52     }
53     return 1;
54 }
55 
56 int h(int n,int x,int m[][8],int s)
57 {
58     int i;
59     if(x==n)
60     {
61         if(s==2)h(n,0,m,3);
62         else sum++;
63         return 0;
64     }
65     for(i=0;i<n;i++)
66     {
67         if(m[x][i]!=1)continue;
68         if(p(n,x,i,m,s))m[x][i]=s;
69         else continue;
70         h(n,x+1,m,s);
71         m[x][i]=1;
72     }
73     return 0;
74 }
75 
76 int main()
77 {
78     int n,m[8][8],i,j;
79     
80     scanf("%d",&n);
81     for(i=0;i<n;i++)
82     {
83         for(j=0;j<n;j++)
84         {
85             scanf("%d",&m[i][j]);
86         }
87     }
88     h(n,0,m,2);
89     printf("%d",sum);
90 
91     return 0;
92 }

/*
基礎練習 Huffuman樹 
 
問題描述
　　Huffman樹在編碼中有着普遍的應用。在這裏，咱們只關心Huffman樹的構造過程。
　　給出一列數{pi}={p0, p1, …, pn-1}，用這列數構造Huffman樹的過程以下：
　　1. 找到{pi}中最小的兩個數，設爲pa和pb，將pa和pb從{pi}中刪除掉，而後將它們的

和加入到{pi}中。這個過程的費用記爲pa + pb。
　　2. 重複步驟1，直到{pi}中只剩下一個數。
　　在上面的操做過程當中，把全部的費用相加，就獲得了構造Huffman樹的總費用。
　　本題任務：對於給定的一個數列，如今請你求出用該數列構造Huffman樹的總費用。

　　例如，對於數列{pi}={5, 3, 8, 2, 9}，Huffman樹的構造過程以下：
　　1. 找到{5, 3, 8, 2, 9}中最小的兩個數，分別是2和3，從{pi}中刪除它們並將和5加入，

獲得{5, 8, 9, 5}，費用爲5。
　　2. 找到{5, 8, 9, 5}中最小的兩個數，分別是5和5，從{pi}中刪除它們並將和10加入，得

到{8, 9, 10}，費用爲10。
　　3. 找到{8, 9, 10}中最小的兩個數，分別是8和9，從{pi}中刪除它們並將和17加入，得

到{10, 17}，費用爲17。
　　4. 找到{10, 17}中最小的兩個數，分別是10和17，從{pi}中刪除它們並將和27加入，得

到{27}，費用爲27。
　　5. 如今，數列中只剩下一個數27，構造過程結束，總費用爲5+10+17+27=59。
輸入格式
　　輸入的第一行包含一個正整數n（n<=100）。
　　接下來是n個正整數，表示p0, p1, …, pn-1，每一個數不超過1000。
輸出格式
　　輸出用這些數構造Huffman樹的總費用。
樣例輸入
5
5 3 8 2 9
樣例輸出
59
*/
#include <stdio.h>

typedef struct
{
    int a[100];
    int len;
}huf;

int sum=0;

int del(huf* in,int t)
{
    int i,j;
    for(i=0;i<in->len && in->a[i]!=t;i++);
    for(;i<in->len-1;i++)
        in->a[i]=in->a[i+1];
    in->len--;
    return 1;
}

int add(huf* in,int t)
{
    in->a[in->len]=t;
    in->len++;
}

int find_two_mins(huf* in)
{
    int i,j,t;
    int mina,minb;

    for(i=0;i<in->len-1;i++)
        for(j=i+1;j<in->len;j++)
            if(in->a[i]>in->a[j])
            {
                t=in->a[i];
                in->a[i]=in->a[j];
                in->a[j]=t;
            }
    mina=in->a[0];
    minb=in->a[1];
    del(in,mina);
    del(in,minb);
    add(in,mina+minb);
    return mina+minb;
}

int main()
{
    huf in;
    int i,j,n;
    scanf("%d",&n);
    in.len=n;
    for(i=0;i<n;i++)
        scanf("%d",&in.a[i]);

    while(1)
    {
        if(in.len==2)
        {
            sum=sum+in.a[0]+in.a[1];
            break;
        }
        sum+=find_two_mins(&in);
    }
    printf("%d",sum);

    return 0;
}

  1 /*
  2 基礎練習 高精度加法
  3 
  4 問題描述
  5 　　輸入兩個整數a和b，輸出這兩個整數的和。a和b都不超過100位。
  6 算法描述
  7 　　因爲a和b都比較大，因此不能直接使用語言中的標準數據類型來存儲。對於這種問題
  8 
  9 ，通常使用數組來處理。
 10 　　定義一個數組A，A[0]用於存儲a的個位，A[1]用於存儲a的十位，依此類推。一樣能夠
 11 
 12 用一個數組B來存儲b。
 13 　　計算c = a + b的時候，首先將A[0]與B[0]相加，若是有進位產生，則把進位（即和的
 14 
 15 十位數）存入r，把和的個位數存入C[0]，即C[0]等於(A[0]+B[0])%10。而後計算A[1]與B[1]
 16 
 17 相加，這時還應將低位進上來的值r也加起來，即C[1]應該是A[1]、B[1]和r三個數的和．如
 18 
 19 果又有進位產生，則仍可將新的進位存入到r中，和的個位存到C[1]中。依此類推，便可求
 20 
 21 出C的全部位。
 22 　　最後將C輸出便可。
 23 輸入格式
 24 　　輸入包括兩行，第一行爲一個非負整數a，第二行爲一個非負整數b。兩個整數都不超
 25 
 26 過100位，兩數的最高位都不是0。
 27 輸出格式
 28 　　輸出一行，表示a + b的值。
 29 樣例輸入
 30 20100122201001221234567890
 31 2010012220100122
 32 樣例輸出
 33 20100122203011233454668012
 34 */
 35 #include <stdio.h>
 36 #include <string.h>
 37 #define MaxSize 100+5
 38 
 39 //逆序輸出數組，不輸出前導0 
 40 void printArray(int P[])
 41 {
 42     int i=MaxSize-1;
 43     
 44     while(!P[i])
 45     {
 46         i--;
 47     }
 48     
 49     while(i>=0)
 50     {
 51         printf("%d",P[i]);
 52         i--;
 53     }
 54     
 55     printf("\n");
 56     
 57     return ;
 58 }
 59 
 60 //高數相加 
 61 void getResult(char a[],char b[],int c[],int a_lenth,int b_lenth)
 62 {
 63     int next=0,i=0;
 64      
 65     while(a_lenth&&b_lenth)
 66     {
 67         c[i++]=((a[--a_lenth]-'0')+(b[--b_lenth]-'0')+next)%10;
 68         next=((a[a_lenth]-'0')+(b[b_lenth]-'0')+next)/10;
 69     }
 70     
 71     if(a_lenth==b_lenth)
 72     {
 73         c[i++]=next;
 74     }
 75     
 76     while(a_lenth)
 77     {
 78         c[i++]=(a[--a_lenth]-'0'+next)%10;
 79         next=(a[a_lenth]-'0'+next)/10;
 80     }
 81     
 82     return ;
 83 }
 84 
 85 main()
 86 {
 87     char A[MaxSize],B[MaxSize];
 88     int C[MaxSize];
 89     
 90     memset(C,0,sizeof(C));
 91     
 92     gets(A);
 93     gets(B);
 94     
 95     if(strlen(A)>=strlen(B))
 96     getResult(A,B,C,strlen(A),strlen(B));
 97     else
 98     getResult(B,A,C,strlen(B),strlen(A));
 99     
100     printArray(C);
101     
102     return 0;
103 }
104 /*
105 #include<stdio.h>
106 #include<string.h>
107 #include<stdlib.h>
108 void f(char a[],char b[])
109 {
110     int w=200,i,j,la,lb;
111     la=strlen(a);lb=strlen(b);
112     char c[200];
113     for(i=la;i<w;i++)a[i]=48;
114     for(i=lb;i<w;i++)b[i]=48;
115     a[w-1]=0;b[w-1]=0;
116     for(i=0;i<la;i++)c[i]=a[i];
117     for(i=0;i<w-1-la;i++)a[i]=48;j=0;
118     for(i=w-1-la;i<w-1;i++){a[i]=c[j];j++;}
119 
120     for(i=0;i<lb;i++)c[i]=b[i];
121     for(i=0;i<w-1-lb;i++)b[i]=48;j=0;
122     for(i=w-1-lb;i<w-1;i++){b[i]=c[j];j++;}
123 
124     for(i=w;i>=0;i--)
125     {
126         j=a[i]+b[i]-96;
127         if(j>9)a[i-1]=a[i-1]+j/10;
128         c[i]=j%10+48;
129     }
130     c[w-1]=0;
131     for(i=0;i<w;i++)if(c[i]!='0')break;
132     for(;i<w-1;i++)printf("%c",c[i]);printf("\n");
133 }
134 
135 int main()
136 {
137     char a[200],b[200];gets(a);gets(b);
138     f(a,b);
139 return 0;
140 }
141 
142 */

  1 /*
  2 基礎練習 階乘計算
  3 
  4 問題描述
  5 　　輸入一個正整數n，輸出n!的值。
  6 　　其中n!=1*2*3*…*n。
  7 算法描述
  8 　　n!可能很大，而計算機能表示的整數範圍有限，須要使用高精度計算的方法。使用一個數組A來表示一個大整數a，A[0]表示a的個位，A[1]表示a的十位，依次類推。
  9 　　將a乘以一個整數k變爲將數組A的每個元素都乘以k，請注意處理相應的進位。
 10 　　首先將a設爲1，而後乘2，乘3，當乘到n時，即獲得了n!的值。
 11 輸入格式
 12 　　輸入包含一個正整數n，n<=1000。
 13 輸出格式
 14 　　輸出n!的準確值。
 15 樣例輸入
 16 10
 17 樣例輸出
 18 3628800
 19 */
 20 #include <stdio.h>
 21 #include <string.h>
 22 #define MaxSize 3000+5
 23 
 24 void resultProduct(int P[],int num)
 25 {
 26     int i,tp=0,st=0;
 27     
 28     for(i=0;i<MaxSize;i++)
 29     {
 30         st=tp;
 31         tp=(P[i]*num+st)/10;
 32         P[i]=(P[i]*num+st)%10;
 33     }
 34 
 35     return ;
 36 }
 37 
 38 void printArray(int P[])
 39 {
 40     int i=MaxSize-1;
 41     
 42     while(!P[i])
 43     {
 44         i--;
 45     }
 46     
 47     while(i>=0)
 48     {
 49         printf("%d",P[i]);
 50         i--;
 51     }
 52     
 53     printf("\n");
 54     
 55     return ;
 56 }
 57 
 58 main()
 59 {
 60     int A[MaxSize],n;
 61     int i;
 62     
 63     //數組清零且個位初始化爲1 
 64     memset(A,0,MaxSize*sizeof(int)); 
 65     A[0]=1;
 66 
 67     scanf("%d",&n);
 68     //用i依次乘以數組A 
 69     for(i=2;i<=n;i++)
 70     {
 71         resultProduct(A,i);
 72     }
 73     
 74     printArray(A);
 75     printf("\n");    
 76 
 77     return 0;
 78 }
 79 /*
 80 #include <stdio.h>
 81 #define N 10000
 82 int main()
 83 {
 84     int a[N]={1};
 85     int k=0,l=1,n;
 86     int i,j;
 87     scanf("%d",&n);
 88     for(i=1;i<=n;i++)
 89     {
 90         for(j=0;j<l;j++)
 91         {
 92             a[j]=a[j]*i+k;
 93             k=a[j]/10000;
 94             a[j]=a[j]%10000;
 95         }
 96         if(k)
 97         {
 98             a[j]=k;
 99             l++;
100             k=0;
101         }
102     }
103     printf("%d",a[l-1]);
104     for(i=l-2;i>=0;i--)
105         printf("%04d",a[i]);
106     printf("\n");
107     return 0;
108 }
109 */

 

GoToTheNextPart