第七届蓝桥杯部分练习题答案(Java)
第七届蓝桥杯部分练习题答案(Java)
—————————————————————————————————————————————————————
今天闲来无事，把之前在蓝桥杯试题集中做的发给大家参考一下，其中（16进制转8进制非我所做）。欢迎广大博友阅览。如有发现错误，还望指教。不喜勿喷，如果发瑞我写代码的习惯不好，亦可以评论告知我，谢谢大家。
—————————————————————————————————————————————————————
圆的面积
问题描述
给定圆的半径r，求圆的面积。
输入格式
输入包含一个整数r，表示圆的半径。
输出格式
输出一行，包含一个实数，四舍五入保留小数点后7位，表示圆的面积。
样例输入
4
样例输出
50.2654825
数据规模与约定
1 <= r <= 10000。
提示
本题对精度要求较高，请注意π的值应该取较精确的值。你可以使用常量来表示π，比如PI=3.14159265358979323，也可以使用数学公式来求π，比如PI=atan(1.0)*4。
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = Integer.parseInt(in.nextLine());
double m = mianji(n);
System.out.printf("%.7f\n", m);
}
public static double mianji(int x) {
double m = (double) (Math.PI * x * x);
return m;
}
}Fibonacci数列
问题描述
Fibonacci数列的递推公式为：Fn=Fn-1+Fn-2，其中F1=F2=1。
当n比较大时，Fn也非常大，现在我们想知道，Fn除以10007的余数是多少。
输入格式
输入包含一个整数n。
输出格式
输出一行，包含一个整数，表示Fn除以10007的余数。
说明：在本题中，答案是要求Fn除以10007的余数，因此我们只要能算出这个余数即可，而不需要先计算出Fn的准确值，再将计算的结果除以10007取余数，直接计算余数往往比先算出原数再取余简单。
样例输入
10
样例输出
55
样例输入
22
样例输出
7704
数据规模与约定
1 <= n <= 1,000,000。
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
int[] x = new int[1000000];
for (int i = 0; i < x.length; i++) {
if (i == 0 || i == 1)
x[i] = 1;
else
x[i] = (x[i - 1] + x[i - 2]) % 10007;
}
Scanner in = new Scanner(System.in);
int n = Integer.parseInt(in.nextLine());
System.out.println(x[n - 1]);
}
}闰年判断
问题描述
给定一个年份，判断这一年是不是闰年。
当以下情况之一满足时，这一年是闰年：
1. 年份是4的倍数而不是100的倍数；
2. 年份是400的倍数。
其他的年份都不是闰年。
输入格式
输入包含一个整数y，表示当前的年份。
输出格式
输出一行，如果给定的年份是闰年，则输出yes，否则输出no。
样例输入
2013
样例输出
no
样例输入
2016
样例输出
yes
数据规模与约定
1990 <= y <= 2050。
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int y = in.nextInt();
if (y % 400 == 0 || (y % 100 != 0 && y % 4 == 0)) {
System.out.println("yes");
} else {
System.out.println("no");
}
}
}01字串
问题描述
对于长度为5位的一个01串，每一位都可能是0或1，一共有32种可能。它们的前几个是：
00000
00001
00010
00011
00100
请按从小到大的顺序输出这32种01串。
输出格式
输出32行，按从小到大的顺序每行一个长度为5的01串。
样例输出
00000
00001
00010
00011
<以下部分省略>
public class Main {
public static void main(String[] args) {
for (int i = 0; i < 32; i++) {
String s = "";
if (i < 2) {
System.out.println("0000" + Integer.toBinaryString(i));
} else if (i < 4) {
System.out.println("000" + Integer.toBinaryString(i));
} else if (i < 8) {
System.out.println("00" + Integer.toBinaryString(i));
} else if (i < 16) {
System.out.println("0" + Integer.toBinaryString(i));
} else {
System.out.println(Integer.toBinaryString(i));
}
}
}
}字母图形
问题描述
利用字母可以组成一些美丽的图形，下面给出了一个例子：
ABCDEFG
BABCDEF
CBABCDE
DCBABCD
EDCBABC
这是一个5行7列的图形，请找出这个图形的规律，并输出一个n行m列的图形。
输入格式
输入一行，包含两个整数n和m，分别表示你要输出的图形的行数的列数。
输出格式
输出n行，每个m个字符，为你的图形。
样例输入
5 7
样例输出
ABCDEFG
BABCDEF
CBABCDE
DCBABCD
EDCBABC
数据规模与约定
1 <= n, m <= 26。
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
int m = in.nextInt();
int[][] a = new int[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int abs = Math.abs(j - i);
char x = (char) ('A' + abs);
System.out.print(x);
}
System.out.println();
}
}
}数列特征
问题描述
给出n个数，找出这n个数的最大值，最小值，和。
输入格式
第一行为整数n，表示数的个数。
第二行有n个数，为给定的n个数，每个数的绝对值都小于10000。
输出格式
输出三行，每行一个整数。第一行表示这些数中的最大值，第二行表示这些数中的最小值，第三行表示这些数的和。
样例输入
5
1 3 -2 4 5
样例输出
5
-2
3
数据规模与约定
1 <= n <= 10000。
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int min = Integer.MAX_VALUE, max = Integer.MIN_VALUE, sum = 0, n = in.nextInt();
int[] a = new int[n];
for (int i = 0; i < n; i++) {
a[i] = in.nextInt();
}
for (int i = 0; i < a.length; i++) {
if (min > a[i]) {
min = a[i];
}
if (max < a[i]) {
max = a[i];
}
sum += a[i];
}
System.out.println(max);
System.out.println(min);
System.out.println(sum);
}
}查找整数
问题描述
给出一个包含n个整数的数列，问整数a在数列中的第一次出现是第几个。
输入格式
第一行包含一个整数n。
第二行包含n个非负整数，为给定的数列，数列中的每个数都不大于10000。
第三行包含一个整数a，为待查找的数。
输出格式
如果a在数列中出现了，输出它第一次出现的位置(位置从1开始编号)，否则输出-1。
样例输入
6
1 9 4 8 3 9
9
样例输出
2
数据规模与约定
1 <= n <= 1000。
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
int[] a = new int[n];
for (int i = 0; i < n; i++) {
a[i] = in.nextInt();
}
int x = in.nextInt();
for (int i = 0; i < a.length; i++) {
if (a[i] == x) {
System.out.println(i + 1);
return;
}
}
System.out.println(-1);
}
}
杨辉三角形
问题描述
杨辉三角形又称Pascal三角形，它的第i+1行是(a+b)i的展开式的系数。它的一个重要性质是：三角形中的每个数字等于它两肩上的数字相加。下面给出了杨辉三角形的前4行：
1
1 1
1 2 1
1 3 3 1
给出n，输出它的前n行。
输入格式
输入包含一个数n。
输出格式
输出杨辉三角形的前n行。每一行从这一行的第一个数开始依次输出，中间使用一个空格分隔。请不要在前面输出多余的空格。
样例输入
4
样例输出
1
1 1
1 2 1
1 3 3 1
数据规模与约定
1 <= n <= 34。
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
int[][] a = new int[n][n];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (j == 0 || j == i) {
a[i][j] = 1;
} else if (j > 0 && j < i) {
a[i][j] = a[i - 1][j - 1] + a[i - 1][j];
} else {
a[i][j] = 0;
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (a[i][j] != 0) {
System.out.print(a[i][j]);
if (j < i) {
System.out.print(" ");
}
}
}
System.out.println();
}
}
}特殊的数字
问题描述
153是一个非常特殊的数，它等于它的每位数字的立方和，即153=1*1*1+5*5*5+3*3*3。编程求所有满足这种条件的三位十进制数。
输出格式
按从小到大的顺序输出满足条件的三位十进制数，每个数占一行。
public class Main {
public static void main(String[] args) {
for (int i = 100; i <= 999; i++) {
int n1 = i / 100;
int n2 = (i % 100) / 10;
int n3 = i % 10;
if (n1 * n1 * n1 + n2 * n2 * n2 + n3 * n3 * n3 == i) {
System.out.println(i);
}
}
}
}回文数
问题描述
1221是一个非常特殊的数，它从左边读和从右边读是一样的，编程求所有这样的四位十进制数。
输出格式
按从小到大的顺序输出满足条件的四位十进制数。
public class Main {
public static void main(String[] args) {
for (int i = 10; i < 100; i++) {
int j = i / 10 + (i % 10) * 10;
if (i % 10 == 0) {
System.out.println(i + "0" + j);
} else {
System.out.println(i + "" + j);
}
}
}
}特殊回文数
问题描述
123321是一个非常特殊的数，它从左边读和从右边读是一样的。
输入一个正整数n， 编程求所有这样的五位和六位十进制数，满足各位数字之和等于n 。
输入格式
输入一行，包含一个正整数n。
输出格式
按从小到大的顺序输出满足条件的整数，每个整数占一行。
样例输入
52
样例输出
899998
989989
998899
数据规模和约定
1<=n<=54。
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
DOIT(n);
}
public static void DOIT(int n) {
for (int i = 100; i <= 999; i++) {
int n1 = (i + "").charAt(0) - '0';
int n2 = (i + "").charAt(1) - '0';
int n3 = (i + "").charAt(2) - '0';
if (n1 * 2 + n2 * 2 + n3 == n) {
System.out.println("" + n1 + n2 + n3 + n2 + n1);
}
}
for (int i = 100; i <= 999; i++) {
int n1 = (i + "").charAt(0) - '0';
int n2 = (i + "").charAt(1) - '0';
int n3 = (i + "").charAt(2) - '0';
if (n1 * 2 + n2 * 2 + n3 * 2 == n) {
System.out.println("" + n1 + n2 + n3 + n3 + n2 + n1);
}
}
}
}十进制转十六进制
问题描述
十六进制数是在程序设计时经常要使用到的一种整数的表示方式。它有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
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int a = in.nextInt();
System.out.println(Integer.toHexString(a).toUpperCase());
}
}十六进制转十进制
问题描述
从键盘输入一个不超过8位的正的十六进制数字符串，将它转换为正的十进制数后输出。
注：十六进制数中的10~15分别用大写的英文字母A、B、C、D、E、F表示。
样例输入
FFFF
样例输出
65535
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
String a = in.next();
long i = Long.parseLong(a, 16);
System.out.println(i);
}
}十六进制转八进制
问题描述
给定n个十六进制正整数，输出它们对应的八进制数。
输入格式
输入的第一行为一个正整数n （1<=n<=10）。
接下来n行，每行一个由0~9、大写字母A~F组成的字符串，表示要转换的十六进制正整数，每个十六进制数长度不超过100000。
输出格式
输出n行，每行为输入对应的八进制正整数。
注意
输入的十六进制数不会有前导0，比如012A。
输出的八进制数也不能有前导0。
样例输入
2
39
123ABC
样例输出
71
4435274
提示
先将十六进制数转换成某进制数，再由某进制数转换成八进制。
import java.util.HashMap;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
String a[] = new String[n];
String b[] = new String[n];
for (int i = 0; i < a.length; i++) {
a[i] = in.next();
b[i] = "";
}
for (int i = 0; i < a.length; i++) {
b[i] = hexToOctal(a[i]);
System.out.println(b[i]);
}
}
public static String hexToBinary(String hexNum) {
char[] chs = { '0', '1' };
String str = new String("0123456789ABCDEF");
char[] charArray = hexNum.toUpperCase().toCharArray();
int pos = charArray.length * 4;
char[] binaryArray = new char[pos];
for (int i = charArray.length - 1; i >= 0; i--) {
int temp = str.indexOf(charArray[i]);
for (int j = 0; j < 4; j++) {
binaryArray[--pos] = chs[temp & 1];
temp = temp >>> 1;
}
}
return new String(binaryArray);
}
public static String binaryHandle(String binary) {
String str = binary.substring(binary.indexOf('1'));
int len = str.length();
if (len % 3 == 0)
return str;
else if (len % 3 == 1)
return "00" + str;
else
return "0" + str;
}
public static String hexToOctal(String str) {
String s = hexToBinary(str);
String s1 = binaryHandle(s);
return binaryToOctal(s1);
}
public static String binaryToOctal(String binary) {
HashMap map = new HashMap();
map.put("000", '0');
map.put("001", '1');
map.put("010", '2');
map.put("011", '3');
map.put("100", '4');
map.put("101", '5');
map.put("110", '6');
map.put("111", '7');
int pos = binary.length() / 3;
char[] octArray = new char[pos];
for (int i = binary.length(); i > 0; i -= 3) {
String s = binary.substring(i - 3, i);
octArray[--pos] = map.get(s);
}
return new String(octArray);
}
} 数列排序
问题描述
给定一个长度为n的数列，将这个数列按从小到大的顺序排列。1<=n<=200
输入格式
第一行为一个整数n。
第二行包含n个整数，为待排序的数，每个整数的绝对值小于10000。
输出格式
输出一行，按从小到大的顺序输出排序后的数列。
样例输入
5
8 3 6 4 9
样例输出
3 4 6 8 9
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
int[] a = new int[n];
for (int i = 0; i < a.length; i++) {
a[i] = in.nextInt();
}
for (int i = 0; i < a.length; i++) {
int temp = a[i];
int j;
for (j = i - 1; j >= 0; j--) {
if (a[j] > temp) {
a[j + 1] = a[j];
} else {
break;
}
}
a[j + 1] = temp;
}
for (int i = 0; i < a.length; i++) {
System.out.print(a[i] + " ");
}
}
}区间k大数查询
问题描述
给定一个序列，每次询问序列中第l个数到第r个数中第K大的数是哪个。
输入格式
第一行包含一个数n，表示序列长度。
第二行包含n个正整数，表示给定的序列。
第三个包含一个正整数m，表示询问个数。
接下来m行，每行三个数l,r,K，表示询问序列从左往右第l个数到第r个数中，从大往小第K大的数是哪个。序列元素从1开始标号。
输出格式
总共输出m行，每行一个数，表示询问的答案。
样例输入
5
1 2 3 4 5
2
1 5 2
2 3 2
样例输出
4
2
数据规模与约定
对于30%的数据，n,m<=100；
对于100%的数据，n,m<=1000；
保证k<=(r-l+1)，序列中的数<=106。
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
int[] a = new int[n];
for (int i = 0; i < a.length; i++) {
a[i] = in.nextInt();
}
int m = in.nextInt();
int[][] b = new int[m][3];
for (int i = 0; i < m; i++) {
for (int j = 0; j < 3; j++) {
b[i][j] = in.nextInt();
}
}
for (int i = 0; i < m; i++) {
int l = b[i][0], r = b[i][1], K = b[i][2];
int x = r - l + 1;
int[] c = new int[x];
for (int j = 0; j < x; j++) {
c[j] = a[l - 1];
l++;
}
paiXu(c);
System.out.println(c[K - 1]);
}
}
public static int[] paiXu(int a[]) {
for (int i = 0; i < a.length; i++) {
int temp = a[i];
int j;
for (j = i - 1; j >= 0; j--) {
if (a[j] < temp) {
a[j + 1] = a[j];
} else {
break;
}
}
a[j + 1] = temp;
}
return a;
}
}Anagrams问题
问题描述
Anagrams指的是具有如下特性的两个单词：在这两个单词当中，每一个英文字母（不区分大小写）所出现的次数都是相同的。例如，“Unclear”和“Nuclear”、“Rimon”和“MinOR”都是Anagrams。编写一个程序，输入两个单词，然后判断一下，这两个单词是否是Anagrams。每一个单词的长度不会超过80个字符，而且是大小写无关的。
输入格式：输入有两行，分别为两个单词。
输出格式：输出只有一个字母Y或N，分别表示Yes和No。
输入输出样例
样例输入
Unclear
Nuclear
样例输出
Y
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
String s1 = in.next();
String s2 = in.next();
if (s1.length() != s2.length()) {
System.out.println("N");
} else {
s1 = s1.toUpperCase();
s2 = s2.toUpperCase();
int[] a = new int[s1.length()];
int[] b = new int[s2.length()];
for (int i = 0; i < a.length; i++) {
a[i] = s1.charAt(i) - 'A';
b[i] = s2.charAt(i) - 'A';
}
for (int i = 0; i < b.length; i++) {
for (int j = i + 1; j < b.length; j++) {
if (a[i] > a[j]) {
int temp = a[i];
a[i] = a[j];
a[j] = temp;
}
if (b[i] > b[j]) {
int temp = b[i];
b[i] = b[j];
b[j] = temp;
}
}
}
for (int i = 0; i < b.length; i++) {
if (a[i] != b[i]) {
System.out.println("N");
return;
}
}
System.out.println("Y");
}
}
}前缀表达式
问题描述
编写一个程序，以字符串方式输入一个前缀表达式，然后计算它的值。输入格式为：“运算符 对象1 对象2”，其中，运算符为“+”（加法）、“-”（减法）、“*”（乘法）或“/”（除法），运算对象为不超过10的整数，它们之间用一个空格隔开。要求：对于加、减、乘、除这四种运算，分别设计相应的函数来实现。
输入格式：输入只有一行，即一个前缀表达式字符串。
输出格式：输出相应的计算结果（如果是除法，直接采用c语言的“/”运算符，结果为整数）。
输入输出样例
样例输入
+ 5 2
样例输出
7
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
String s = in.next();
int a = in.nextInt();
int b = in.nextInt();
char c = s.charAt(0);
switch (c) {
case '+':
add(a, b);
break;
case '-':
minus(a, b);
break;
case '*':
multiply(a, b);
break;
case '/':
rid(a, b);
break;
default:
break;
}
}
public static void add(int a, int b) {
System.out.println(a + b);
}
public static void minus(int a, int b) {
System.out.println(a - b);
}
public static void multiply(int a, int b) {
System.out.println(a * b);
}
public static void rid(int a, int b) {
System.out.println(a / b);
}
}排序
问题描述
编写一个程序，输入3个整数，然后程序将对这三个整数按照从大到小进行排列。
输入格式：输入只有一行，即三个整数，中间用空格隔开。
输出格式：输出只有一行，即排序后的结果。
输入输出样例
样例输入
9 2 30
样例输出
30 9 2
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int[] a = { in.nextInt(), in.nextInt(), in.nextInt() };
for (int i = 0; i < a.length; i++) {
for (int j = i + 1; j < a.length; j++) {
if (a[i] < a[j]) {
int temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
}
for (int i = 0; i < a.length; i++) {
System.out.print(a[i] + " ");
}
}
}图形显示
问题描述
编写一个程序，首先输入一个整数，例如5，然后在屏幕上显示如下的图形（5表示行数）：
* * * * *
* * * *
* * *
* *
*
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
System.out.print("* ");
}
System.out.println();
}
}
}未名湖边的烦恼
问题描述
每年冬天，北大未名湖上都是滑冰的好地方。北大体育组准备了许多冰鞋，可是人太多了，每天下午收工后，常常一双冰鞋都不剩。
每天早上，租鞋窗口都会排起长龙，假设有还鞋的m个，有需要租鞋的n个。现在的问题是，这些人有多少种排法，可以避免出现体育组没有冰鞋可租的尴尬场面。（两个同样需求的人（比如都是租鞋或都是还鞋）交换位置是同一种排法）
输入格式
两个整数，表示m和n
输出格式
一个整数，表示队伍的排法的方案数。
样例输入
3 2
样例输出
5
数据规模和约定
m,n∈［0,18］
问题分析
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int m = in.nextInt(), n = in.nextInt();
System.out.println(make(m, n));
}
public static int make(int m, int n) {
if (m < n) {
return 0;
} else if (n == 0) {
return 1;
}
return make(m - 1, n) + make(m, n - 1);
}
}P1103
编程实现两个复数的运算。设有两个复数 和 ，则他们的运算公式为：
要求：（1）定义一个结构体类型来描述复数。
（2）复数之间的加法、减法、乘法和除法分别用不用的函数来实现。
（3）必须使用结构体指针的方法把函数的计算结果返回。
说明：用户输入：运算符号(+,-,*,/) a b c d.
输出：a+bi，输出时不管a,b是小于0或等于0都按该格式输出，输出时a,b都保留两位。
输入：
- 2.5 3.6 1.5 4.9
输出：
1.00+-1.30i
public class Main {
public static void main(String[] arg) {
Scanner in = new Scanner(System.in);
String x = in.next();
float a = in.nextFloat(), b = in.nextFloat(), c = in.nextFloat(), d = in.nextFloat();
if (x.equals("+")) {
System.out.println(String.format("%.2f", (a + c)) + "+" + String.format("%.2f", (b + d)) + "i");
} else if (x.equals("-")) {
System.out.println(String.format("%.2f", (a - c)) + "+" + String.format("%.2f", (b - d)) + "i");
} else if (x.equals("*")) {
System.out.println(
String.format("%.2f", (a * c - b * d)) + "+" + String.format("%.2f", (a * d + b * c)) + "i");
} else if (x.equals("/")) {
System.out.println(String.format("%.2f", (a * c + b * d) / (c * c + d * d)) + "+"
+ String.format("%.2f", (b * c - a * d) / (c * c + d * d)) + "i");
}
}
}