部分习题答案_百度文库
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
部分习题答案
上传于||暂无简介
阅读已结束，如果下载本文需要使用0下载券
想免费下载更多文档？
定制HR最喜欢的简历
下载文档到电脑，查找使用更方便
还剩26页未读，继续阅读
定制HR最喜欢的简历
你可能喜欢《Java语言程序设计》复习题_百度文库
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
《Java语言程序设计》复习题
上传于||文档简介
&&f​u​x​i
阅读已结束，如果下载本文需要使用1下载券
想免费下载本文？
定制HR最喜欢的简历
下载文档到电脑，查找使用更方便
还剩3页未读，继续阅读
定制HR最喜欢的简历
你可能喜欢第七届蓝桥杯部分练习题答案(Java)
—————————————————————————————————————————————————————
今天闲来无事，把之前在蓝桥杯试题集中做的发给大家参考一下，其中（16进制转8进制非我所做）。欢迎广大博友阅览。如有发现错误，还望指教。不喜勿喷，如果发瑞我写代码的习惯不好，亦可以评论告知我，谢谢大家。
—————————————————————————————————————————————————————
给定圆的半径r，求圆的面积。
输入包含一个整数r，表示圆的半径。
输出一行，包含一个实数，四舍五入保留小数点后7位，表示圆的面积。
50.2654825
数据规模与约定
1 &= r &= 10000。
本题对精度要求较高，请注意π的值应该取较精确的值。你可以使用常量来表示π，比如PI=3.79323，也可以使用数学公式来求π，比如PI=atan(1.0)*4。
import java.util.S
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);
Fibonacci数列
Fibonacci数列的递推公式为：Fn=Fn-1+Fn-2，其中F1=F2=1。
当n比较大时，Fn也非常大，现在我们想知道，Fn除以10007的余数是多少。
输入包含一个整数n。
输出一行，包含一个整数，表示Fn除以10007的余数。
说明：在本题中，答案是要求Fn除以10007的余数，因此我们只要能算出这个余数即可，而不需要先计算出Fn的准确值，再将计算的结果除以10007取余数，直接计算余数往往比先算出原数再取余简单。
数据规模与约定
1 &= n &= 1,000,000。
import java.util.S
public class Main {
public static void main(String[] args) {
int[] x = new int[1000000];
for (int i = 0; i & x. i++) {
if (i == 0 || i == 1)
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。
数据规模与约定
1990 &= y &= 2050。
import java.util.S
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");
System.out.println("no");
对于长度为5位的一个01串，每一位都可能是0或1，一共有32种可能。它们的前几个是：
请按从小到大的顺序输出这32种01串。
输出32行，按从小到大的顺序每行一个长度为5的01串。
&以下部分省略&
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));
System.out.println(Integer.toBinaryString(i));
利用字母可以组成一些美丽的图形，下面给出了一个例子：
这是一个5行7列的图形，请找出这个图形的规律，并输出一个n行m列的图形。
输入一行，包含两个整数n和m，分别表示你要输出的图形的行数的列数。
输出n行，每个m个字符，为你的图形。
数据规模与约定
1 &= n, m &= 26。
import java.util.S
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 & i++) {
for (int j = 0; j & 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。
输出三行，每行一个整数。第一行表示这些数中的最大值，第二行表示这些数中的最小值，第三行表示这些数的和。
1 3 -2 4 5
数据规模与约定
1 &= n &= 10000。
import java.util.S
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 & i++) {
a[i] = in.nextInt();
for (int i = 0; i & a. 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。
1 9 4 8 3 9
数据规模与约定
1 &= n &= 1000。
import java.util.S
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 & i++) {
a[i] = in.nextInt();
int x = in.nextInt();
for (int i = 0; i & a. i++) {
if (a[i] == x) {
System.out.println(i + 1);
System.out.println(-1);
杨辉三角形
杨辉三角形又称Pascal三角形，它的第i+1行是(a+b)i的展开式的系数。它的一个重要性质是：三角形中的每个数字等于它两肩上的数字相加。下面给出了杨辉三角形的前4行：
给出n，输出它的前n行。
输入包含一个数n。
输出杨辉三角形的前n行。每一行从这一行的第一个数开始依次输出，中间使用一个空格分隔。请不要在前面输出多余的空格。
数据规模与约定
1 &= n &= 34。
import java.util.S
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 & i++) {
for (int j = 0; j & 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];
a[i][j] = 0;
for (int i = 0; i & i++) {
for (int j = 0; j & 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);
System.out.println(i + "" + j);
特殊回文数
　　123321是一个非常特殊的数，它从左边读和从右边读是一样的。
　　输入一个正整数n， 编程求所有这样的五位和六位十进制数，满足各位数字之和等于n 。
　　输入一行，包含一个正整数n。
　　按从小到大的顺序输出满足条件的整数，每个整数占一行。
数据规模和约定
　　1&=n&=54。
import java.util.S
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
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&=
　　输出这个整数的16进制表示
import java.util.S
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表示。
import java.util.S
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。
　　先将十六进制数转换成某进制数，再由某进制数转换成八进制。
import java.util.HashM
import java.util.S
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. i++) {
a[i] = in.next();
b[i] = "";
for (int i = 0; i & a. 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("ABCDEF");
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)
else if (len % 3 == 1)
return "00" +
return "0" +
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。
　　输出一行，按从小到大的顺序输出排序后的数列。
import java.util.S
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. i++) {
a[i] = in.nextInt();
for (int i = 0; i & a. i++) {
int temp = a[i];
for (j = i - 1; j &= 0; j--) {
if (a[j] & temp) {
a[j + 1] = a[j];
a[j + 1] =
for (int i = 0; i & a. i++) {
System.out.print(a[i] + "
区间k大数查询
给定一个序列，每次询问序列中第l个数到第r个数中第K大的数是哪个。
第一行包含一个数n，表示序列长度。
第二行包含n个正整数，表示给定的序列。
第三个包含一个正整数m，表示询问个数。
接下来m行，每行三个数l,r,K，表示询问序列从左往右第l个数到第r个数中，从大往小第K大的数是哪个。序列元素从1开始标号。
总共输出m行，每行一个数，表示询问的答案。
数据规模与约定
对于30%的数据，n,m&=100；
对于100%的数据，n,m&=1000；
保证k&=(r-l+1)，序列中的数&=106。
import java.util.S
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. i++) {
a[i] = in.nextInt();
int m = in.nextInt();
int[][] b = new int[m][3];
for (int i = 0; i & i++) {
for (int j = 0; j & 3; j++) {
b[i][j] = in.nextInt();
for (int i = 0; i & 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 & j++) {
c[j] = a[l - 1];
System.out.println(c[K - 1]);
public static int[] paiXu(int a[]) {
for (int i = 0; i & a. i++) {
int temp = a[i];
for (j = i - 1; j &= 0; j--) {
if (a[j] & temp) {
a[j + 1] = a[j];
a[j + 1] =
Anagrams问题
　　Anagrams指的是具有如下特性的两个单词：在这两个单词当中，每一个英文字母（不区分大小写）所出现的次数都是相同的。例如，“Unclear”和“Nuclear”、“Rimon”和“MinOR”都是Anagrams。编写一个程序，输入两个单词，然后判断一下，这两个单词是否是Anagrams。每一个单词的长度不会超过80个字符，而且是大小写无关的。
　　输入格式：输入有两行，分别为两个单词。
　　输出格式：输出只有一个字母Y或N，分别表示Yes和No。
　　输入输出样例
import java.util.S
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");
s1 = s1.toUpperCase();
s2 = s2.toUpperCase();
int[] a = new int[s1.length()];
int[] b = new int[s2.length()];
for (int i = 0; i & a. i++) {
a[i] = s1.charAt(i) - 'A';
b[i] = s2.charAt(i) - 'A';
for (int i = 0; i & b. i++) {
for (int j = i + 1; j & b. j++) {
if (a[i] & a[j]) {
int temp = a[i];
a[i] = a[j];
if (b[i] & b[j]) {
int temp = b[i];
b[i] = b[j];
for (int i = 0; i & b. i++) {
if (a[i] != b[i]) {
System.out.println("N");
System.out.println("Y");
前缀表达式
　　编写一个程序，以字符串方式输入一个前缀表达式，然后计算它的值。输入格式为：“运算符 对象1 对象2”，其中，运算符为“+”（加法）、“-”（减法）、“*”（乘法）或“/”（除法），运算对象为不超过10的整数，它们之间用一个空格隔开。要求：对于加、减、乘、除这四种运算，分别设计相应的函数来实现。
　　输入格式：输入只有一行，即一个前缀表达式字符串。
　　输出格式：输出相应的计算结果（如果是除法，直接采用c语言的“/”运算符，结果为整数）。
　　输入输出样例
import java.util.S
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) {
add(a, b);
minus(a, b);
multiply(a, b);
rid(a, b);
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个整数，然后程序将对这三个整数按照从大到小进行排列。
　　输入格式：输入只有一行，即三个整数，中间用空格隔开。
　　输出格式：输出只有一行，即排序后的结果。
　　输入输出样例
import java.util.S
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. i++) {
for (int j = i + 1; j & a. j++) {
if (a[i] & a[j]) {
int temp = a[i];
a[i] = a[j];
for (int i = 0; i & a. i++) {
System.out.print(a[i] + " ");
　　编写一个程序，首先输入一个整数，例如5，然后在屏幕上显示如下的图形（5表示行数）：
　　* * * * *
　　* * * *
import java.util.S
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
for (int i = 0; i & i++) {
for (int j = j & j++) {
System.out.print("* ");
System.out.println();
未名湖边的烦恼
　　每年冬天，北大未名湖上都是滑冰的好地方。北大体育组准备了许多冰鞋，可是人太多了，每天下午收工后，常常一双冰鞋都不剩。
　　每天早上，租鞋窗口都会排起长龙，假设有还鞋的m个，有需要租鞋的n个。现在的问题是，这些人有多少种排法，可以避免出现体育组没有冰鞋可租的尴尬场面。（两个同样需求的人（比如都是租鞋或都是还鞋）交换位置是同一种排法）
　　两个整数，表示m和n
　　一个整数，表示队伍的排法的方案数。
数据规模和约定
　　m,n∈［0,18］
　　问题分析
import java.util.S
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) {
} else if (n == 0) {
return make(m - 1, n) + make(m, n - 1);
　　编程实现两个复数的运算。设有两个复数 和 ，则他们的运算公式为：
　　要求：（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")
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：561次
排名：千里之外java基础例题_百度文库
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
java基础例题
上传于||文档简介
&&编​程​基​础​,​从​最​简​单​的​例​子​入​手​!​希​望​对​大​家​有​帮​助​!
阅读已结束，如果下载本文需要使用1下载券
想免费下载本文？
定制HR最喜欢的简历
下载文档到电脑，查找使用更方便
还剩3页未读，继续阅读
定制HR最喜欢的简历
你可能喜欢java课后题_百度文库
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
java课后题
上传于||暂无简介
阅读已结束，如果下载本文需要使用0下载券
想免费下载更多文档？
定制HR最喜欢的简历
下载文档到电脑，查找使用更方便
还剩60页未读，继续阅读
定制HR最喜欢的简历
你可能喜欢