# 第七届蓝桥杯部分练习题答案(Java)

—————————————————————————————————————————————————————

—————————————————————————————————————————————————————

## 圆的面积

4

50.2654825

1 <= r <= 10000。

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。

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的倍数。

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字串

00000
00001
00010
00011
00100

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

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();
}
}
}

## 数列特征

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);
}
}

## 查找整数

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);
}
}


## 杨辉三角形

1
1 1
1 2 1
1 3 3 1

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<String, Character> map = new HashMap<String, Character>();
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大数查询

5
1 2 3 4 5
2
1 5 2
2 3 2

4
2

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 '+':
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");
}
}
}