蓝桥杯Java试题汇总.doc

1. 历届试题 核桃的数量
问题描述
小张是软件项目经理，他带领3个开发组。工期紧，今天都在加班呢。为鼓舞士气，小张打算给每个组发一袋核桃（据传言能补脑）。他的要求是：
1. 各组的核桃数量必须相同
2. 各组内必须能平分核桃（当然是不能打碎的）
3. 尽量提供满足1,2条件的最小数量（节约闹革命嘛）
输入格式
输入包含三个正整数a, b, c，表示每个组正在加班的人数，用空格分开（a,b,c<30）
输出格式
输出一个正整数，表示每袋核桃的数量。
样例输入1
2 4 5
样例输出1
20
样例输入2
3 1 1
样例输出2
3
JAVA
源代码
1 import java.util.Scanner;
2 public class Main {
3
4 public static void main(String[] args){
5 Scanner sc=new Scanner(System.in);
6 int a=sc.nextInt();
7 int b=sc.nextInt();
8 int c=sc.nextInt();
9 int i;
10 for(i=1;;i++){
11 if(i%a==0&&i%b==0&&i%c==0)
12
13 break;
14 }
15 System.out.println(i);
16
}}

2. 基础练习 Sine之舞
时间限制：1.0s 内存限制：512.0MB

问题描述
　　最近FJ为他的奶牛们开设了数学分析课，FJ知道若要学好这门课，必须有一个好的三角函数基本功。所以他准备和奶牛们做一个“Sine之舞”的游戏，寓教于乐，提高奶牛们的计算能力。
　　不妨设
　　An=sin(1–sin(2+sin(3–sin(4+...sin(n))...)
　　Sn=(...(A1+n)A2+n-1)A3+...+2)An+1
　　FJ想让奶牛们计算Sn的值，请你帮助FJ打印出Sn的完整表达式，以方便奶牛们做题。
输入格式
　　仅有一个数：N<201。
输出格式
　　请输出相应的表达式Sn，以一个换行符结束。输出中不得含有多余的空格或换行、回车符。
样例输入
3
样例输出
((sin(1)+3)sin(1–sin(2))+2)sin(1–sin(2+sin(3)))+1
语言
JAVA
源代码
17 import java.util.Scanner;
18 public class Main {
19 private static int m;
20 public static void main(String[] args){
21 Scanner sc=new Scanner(System.in);
22 m=sc.nextInt();
23 for(int i=0;i
25 }
26 Sn(1);
27 }
28 public static void An(int n,int k){
29 if(n==k){
30 System.out.print("sin("+n);
31 }else if(n%2!=0){
32 System.out.print("sin("+n+"-");
33 }else{
34 System.out.print("sin("+n+"+")
35 ; }
36 if(n2 if(n!=m){
43 System.out.print("+"+(m-n+1)+")");
44 }else{
45 System.out.print("+"+(m-n+1));
46 }
47 if(n编译信息
无
3. 基础练习 FJ的字符串
时间限制：1.0s 内存限制：512.0MB

问题描述
　　FJ在沙盘上写了这样一些字符串：
　　A1 = “A”
　　A2 = “ABA”
　　A3 = “ABACABA”
　　A4 = “ABACABADABACABA”
　　… …
　　你能找出其中的规律并写所有的数列AN吗？
输入格式
　　仅有一个数：N ≤ 26。
输出格式
　　请输出相应的字符串AN，以一个换行符结束。输出中不得含有多余的空格或换行、回车符。
样例输入
3
样例输出
ABACABA
言
JAVA
源代码

50 import java.util.Scanner;
51 public class Main {
52 public static char[] c = {'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O',
53 'P','Q','R','S','T','U','V','W','X','Y','Z'};
54 public static void main(String[] args){
55 Scanner scan = new ScannerSystem.in);
56 int n=scan.nextInt();
57 print(n); }
58 private static void print(int n){
59 if(n == 1){
60 System.out.print("A");
61 }
62 else{
63 print(n - 1);
64 System.out.print(c[n - 1]);
print(n - 1); } }}
4. 基础练习 芯片测试
时间限制：1.0s 内存限制：512.0MB

问题描述
　　有n（2≤n≤20）块芯片，有好有坏，已知好芯片比坏芯片多。
　　每个芯片都能用来测试其他芯片。用好芯片测试其他芯片时，能正确给出被测试芯片是好还是坏。而用坏芯片测试其他芯片时，会随机给出好或是坏的测试结果（即此结果与被测试芯片实际的好坏无关）。
　　给出所有芯片的测试结果，问哪些芯片是好芯片。
输入格式
　　输入数据第一行为一个整数n，表示芯片个数。
　　第二行到第n+1行为n*n的一张表，每行n个数据。表中的每个数据为0或1，在这n行中的第i行第j列（1≤i, j≤n）的数据表示用第i块芯片测试第j块芯片时得到的测试结果，1表示好，0表示坏，i=j时一律为1（并不表示该芯片对本身的测试结果。芯片不能对本身进行测试）。
输出格式
　　按从小到大的顺序输出所有好芯片的编号
样例输入
3
1 0 1
0 1 0
1 0 1
样例输出
1 3
语言
JAVA
源代码
65 import java.util.*;
66 public class Main {
67 public static void main(String[] args) {
68 Scanner sc=new Scanner(System.in);
69 int n=sc.nextInt();
70 int[][] a=new int[n][n];
71 for(int i=0;i
78 for(int k=0;kn/2){
84 System.out.print((k+1)+" ");}
85 }
}}
5. 基础练习 龟兔赛跑预测
时间限制：1.0s 内存限制：512.0MB

问题描述
　　话说这个世界上有各种各样的兔子和乌龟，但是研究发现，所有的兔子和乌龟都有一个共同的特点——喜欢赛跑。于是世界上各个角落都不断在发生着乌龟和兔子的比赛，小华对此很感兴趣，于是决定研究不同兔子和乌龟的赛跑。他发现，兔子虽然跑比乌龟快，但它们有众所周知的毛病——骄傲且懒惰，于是在与乌龟的比赛中，一旦任一秒结束后兔子发现自己领先t米或以上，它们就会停下来休息s秒。对于不同的兔子，t，s的数值是不同的，但是所有的乌龟却是一致——它们不到终点决不停止。
　　然而有些比赛相当漫长，全程观看会耗费大量时间，而小华发现只要在每场比赛开始后记录下兔子和乌龟的数据——兔子的速度v1（表示每秒兔子能跑v1米），乌龟的速度v2，以及兔子对应的t，s值，以及赛道的长度l——就能预测出比赛的结果。但是小华很懒，不想通过手工计算推测出比赛的结果，于是他找到了你——清华大学计算机系的高才生——请求帮助，请你写一个程序，对于输入的一场比赛的数据v1，v2，t，s，l，预测该场比赛的结果。
输入格式
　　输入只有一行，包含用空格隔开的五个正整数v1，v2，t，s，l，其中(v1,v2<=100;t<=300;s<=10;l<=10000且为v1,v2的公倍数)
输出格式
　　输出包含两行，第一行输出比赛结果——一个大写字母“T”或“R”或“D”，分别表示乌龟获胜，兔子获胜，或者两者同时到达终点。
　　第二行输出一个正整数表示获胜者（或者双方同时）到达终点所耗费的时间（秒数）。
样例输入
10 5 5 2 20
样例输出
D
4
样例输入
10 5 5 1 20
样例输出
R
3
样例输入
10 5 5 3 20
样例输出
T
4
语言
JAVA
源代码
import java.util.Scanner; public class Main { public static void main(String[] args){ Scanner sc=new Scanner(System.in); int num[]=new int[5]; for(int i=0;i<5;i++) num[i]=sc.nextInt(); int sum1=0,sum2=0,time=1; for(int t=1;t<=num[4]/num[0];time++){ sum1+=num[0]*t; sum2+=num[1]*t; if(sum1==num[4]||sum2==num[4]) break; if(sum1-sum2>=num[2]){ sum2+=num[1]*num[3]; time+=num[3]; } } if(sum2>sum1){ System.out.println("T"); System.out.println(num[4]/num[1]); } else if(sum2 else{ System.out.println("D"); System.out.println(num[4]/num[1]); } } }
6.
基础练习 报时助手
时间限制：1.0s 内存限制：512.0MB

问题描述
　　给定当前的时间，请用英文的读法将它读出来。
　　时间用时h和分m表示，在英文的读法中，读一个时间的方法是：
　　如果m为0，则将时读出来，然后加上“o'clock”，如3:00读作“three o'clock”。
　　如果m不为0，则将时读出来，然后将分读出来，如5:30读作“five thirty”。
　　时和分的读法使用的是英文数字的读法，其中0~20读作：
　　0:zero, 1: one, 2:two, 3:three, 4:four, 5:five, 6:six, 7:seven, 8:eight, 9:nine, 10:ten, 11:eleven, 12:twelve, 13:thirteen, 14:fourteen, 15:fifteen, 16:sixteen, 17:seventeen, 18:eighteen, 19:nineteen, 20:twenty。
　　30读作thirty，40读作forty，50读作fifty。
　　对于大于20小于60的数字，首先读整十的数，然后再加上个位数。如31首先读30再加1的读法，读作“thirty one”。
　　按上面的规则21:54读作“twenty one fifty four”，9:07读作“nine seven”，0:15读作“zero fifteen”。
输入格式
　　输入包含两个非负整数h和m，表示时间的时和分。非零的数字前没有前导0。h小于24，m小于60。
输出格式
　　输出时间时刻的英文。
样例输入
0 15
样例输出
zero fifteen
86 import java.util.Scanner;
87 public class Main {
88 public static String[] time1={"zero","one","two","three","four","five","six","seven","eight","nine", "ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen","twenty"};
89 public static String[] time2={"twenty","thirty","forty","fifty"};
90 public static void main(String[] args){
91 Scanner sc=new Scanner(System.in);
92 while(sc.hasNext()){
93 int h=sc.nextInt();
94 int m=sc.nextInt();
95 if(h<=20){
96 System.out.print(time1[h]);
97 }else{
98 System.out.print("twenty"+" "+time1[h-20]);
99 } if(m==0){
100 System.out.println(" "+"o'clock");
101 }else{ if(m<20){
102 System.out.print(" "+time1[m]);
103 }else{
104 int a=m/10;//十位
105 int b=m%10;//个位
106 if(b==0)
107 System.out.print(" "+time2[a-2]);
108 else
109 System.out.print(" "+time2[a-2]+" "+time1[b]);
110 }
111 }
112 System.out.println();
113 }
114 }
115
116
117 }
7. 基础练习 Huffuman树
时间限制：1.0s 内存限制：512.0MB

问题描述
　　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
语言
JAVA
源代码
118 import java.util.*;
119 public class Main{
120 public static void main(String args[]){
121 Scanner sc=new Scanner(System.in);
122 while(sc.hasNext()){
123 int n=sc.nextInt();
124 int[] a=new int[n];
125 for(int i=0;isum=0;
130 while(n>1){
131 Arrays.sort(a);
132 k=a[0]+a[1];
133 sum=sum+k;
134 a[0]=k;
135 a[1]=Integer.MAX_VALUE;
136 n--;
137
138 }
139 System.out.print(sum);
140 }
141 }
}

8. 基础练习 高精度加法
时间限制：1.0s 内存限制：512.0MB

问题描述
　　输入两个整数a和b，输出这两个整数的和。a和b都不超过100位。
算法描述
　　由于a和b都比较大，所以不能直接使用语言中的标准数据类型来存储。对于这种问题，一般使用数组来处理。
　　定义一个数组A，A[0]用于存储a的个位，A[1]用于存储a的十位，依此类推。同样可以用一个数组B来存储b。
　　计算c = a + b的时候，首先将A[0]与B[0]相加，如果有进位产生，则把进位（即和的十位数）存入r，把和的个位数存入C[0]，即C[0]等于(A[0]+B[0])%10。然后计算A[1]与B[1]相加，这时还应将低位进上来的值r也加起来，即C[1]应该是A[1]、B[1]和r三个数的和．如果又有进位产生，则仍可将新的进位存入到r中，和的个位存到C[1]中。依此类推，即可求出C的所有位。
　　最后将C输出即可。
输入格式
　　输入包括两行，第一行为一个非负整数a，第二行为一个非负整数b。两个整数都不超过100位，两数的最高位都不是0。
输出格式
　　输出一行，表示a + b的值。
样例输入
20100122201001221234567890
2010012220100122
样例输出
20100122203011233454668012
语言
JAVA
源代码
142 import java.util.*;
143 import java.math.*;
144 public class Main{
145 public static void main(String args[]){
146 Scanner sc=new Scanner(System.in);
147 while(sc.hasNext()){
148 String s1=sc.next();
149 String s2=sc.next();
150 BigInteger n1=new BigInteger(s1);
151 BigInteger n2=new BigInteger(s2);
152 System.out.println(n1.add(n2));
153 }
154
155 }
}
9.问题描述
　　输入一个正整数n，输出n!的值。
　　其中n!=1*2*3*…*n。
算法描述
　　n!可能很大，而计算机能表示的整数范围有限，需要使用高精度计算的方法。使用一个数组A来表示一个大整数a，A[0]表示a的个位，A[1]表示a的十位，依次类推。
　　将a乘以一个整数k变为将数组A的每一个元素都乘以k，请注意处理相应的进位。
　　首先将a设为1，然后乘2，乘3，当乘到n时，即得到了n!的值。
输入格式
　　输入包含一个正整数n，n<=1000。
输出格式
　　输出n!的准确值。
样例输入
10
样例输出
3628800
JAVA
源代码
156 import java.util.Arrays;
157 import java.util.Scanner;
158 public class Main {
159 static int max =10000;
160 public static void main(String[] args) {
161 int A[] = new int[max];
162 Scanner input = new Scanner(System.in);
163 int n = input.nextInt();
164 A[0] = 1;
165 int count = 0;
166 for(int i=1;i<=n;i++){
167 int ge = 0,sum;
168 for(int j=0;j<=count;j++){
169 if((i*A[j]+ge)/10!=0){
170 sum = A[j]*i + ge;
171 A[j] = sum%10;
172 ge = sum/10;
173 if(j==count){
174 count++;
175 continue ;
176 }
177 }
178 else{
179 A[j] = i*A[j] + ge;
180 ge = 0;
181 }
182 }
183 }
184
185 for(int i=count;i>=0;i--){
186 System.out.print(A[i]);
187 } }}

10. 基础练习 数列排序
时间限制：1.0s 内存限制：512.0MB

问题描述
　　给定一个长度为n的数列，将这个数列按从小到大的顺序排列。1<=n<=200
输入格式
　　第一行为一个整数n。
　　第二行包含n个整数，为待排序的数，每个整数的绝对值小于10000。
输出格式
　　输出一行，按从小到大的顺序输出排序后的数列。
样例输入
5
8 3 6 4 9
样例输出
3 4 6 8 9
语言
JAVA
源代码
188 import java.util.*;
189 public class Main{
190 public static void main(String[] args) {
191 Scanner sc = new Scanner(System.in) ;
192 int n=sc.nextInt();
193 int[] a=new int[n];
194 while(sc.hasNextInt()){
195
196 for(int i=0;i for(int i=0;iVA
源代码
205 import java.util.*;
206 public class Main {
207 public static void main(String[] args) {
208 Scanner sc=new Scanner(System.in);
209 String s=sc.next();
210 System.out.println(Long.parseLong(s,16));
}}

12. 基础练习 十进制转十六进制
时间限制：1.0s 内存限制：512.0MB

问题描述
　　十六进制数是在程序设计时经常要使用到的一种整数的表示方式。它有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。
　　给出一个非负整数，将它表示成十六进制的形式。
输入格式
　　输入包含一个非负整数a，表示要转换的数。0<=a<=2147483647
输出格式
　　输出这个整数的16进制表示
样例输入
30
样例输出
1E
语言
JAVA
源代码
211 import java.util.*;
212 public class Main {
213 public static void main(String args[]){
214 Scanner sc=new Scanner(System.in);
215 int n=sc.nextInt();
216 System.out.println(Trans(n));
217 }
218 public static String Trans(int n){
219 String s="0123456789ABCDEF";
220 StringBuffer str=new StringBuffer();
221 for(int i=0;n>=16;i++){
222 int a=n%16;
223 n/=16;
224 str.append(s.charAt(a));
225
226