算法-蓝桥杯习题

 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     
39     if(n%2==0)
40     s=(1+n)*n/2;
41     else
42     s=(1+n)*n/2+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 public class Main {
67 
68     /**
69      * @param args
70      * @throws IOException 
71      */
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 */

  1 /*
  2 基础练习 十六进制转八进制
  3 
  4 问题描述
  5 　　给定n个十六进制正整数，输出它们对应的八进制数。
  6 输入格式
  7 　　输入的第一行为一个正整数n （1<=n<=10）。
  8 　　接下来n行，每行一个由0~9、大写字母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 */