蓝桥杯 基础练习
题源 👉 蓝桥杯试题集
BASIC-01 A+B问题
问题描述
输入A、B，输出A+B。
数据规模与约定
-10000 <= A, B <= 10000。
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
int b = sc.nextInt();
System.out.println(a+b);
}
}
BASIC-13 数列排序
问题描述
给定一个长度为n的数列，将这个数列按从小到大的顺序排列。1<=n<=200
输入格式
第一行为一个整数n。
第二行包含n个整数，为待排序的数，每个整数的绝对值小于10000。
输出格式
输出一行，按从小到大的顺序输出排序后的数列。
样例输入
5
8 3 6 4 9
样例输出
3 4 6 8 9
// 排序算法：冒泡、快排...等等
// 偷懒的话可以直接用Arrays.sort(arr)
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
// 输入第一行
int n = sc.nextInt();
// 输入数列
int[] arr = new int[n];
for(int i = 0; i < n; i++) {
arr[i] = sc.nextInt();
}
// 排序
Arrays.sort(arr);
// 输出数组
for(int i = 0; i < n; i++) {
System.out.print(arr[i] + " ");
}
}
}
BASIC-12 十六进制转八进制
问题描述
给定n个十六进制正整数，输出它们对应的八进制数。
输入格式
输入的第一行为一个正整数n （1<=n<=10）。
接下来n行，每行一个由09、大写字母AF组成的字符串，表示要转换的十六进制正整数，每个十六进制数长度不超过100000。
输出格式
输出n行，每行为输入对应的八进制正整数。
-
【注意】
输入的十六进制数不会有前导0，比如012A。
输出的八进制数也不能有前导0。
样例输入
2
39
123ABC
样例输出
71
4435274
【提示】
先将十六进制数转换成某进制数，再由某进制数转换成八进制。
// 实际题目应该是要先将16进制转为2进制，再转为8进制。
// 但是又偷懒，取了巧直接用BigInteger转化为8进制
import java.math.BigInteger;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
// 输入第一行
int n = sc.nextInt();
String arr[] = new String[n];
// 输入十六进制数
for(int i = 0; i < n; i++) {
String temp16 = sc.next();
// 利用BigInteger转化为8进制
String temp8 = new BigInteger(temp16,16).toString(8);
arr[i] = temp8;
}
// 输出
for(int i = 0; i < n; i++) {
System.out.println(arr[i]);
}
}
}
BASIC-11 十六进制转十进制
问题描述
从键盘输入一个不超过8位的正的十六进制数字符串，将它转换为正的十进制数后输出。
注：十六进制数中的10~15分别用大写的英文字母A、B、C、D、E、F表示。
样例输入
FFFF
样例输出
65535
import java.math.BigInteger;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String temp16 = sc.next();
String temp = new BigInteger(temp16,16).toString(10);
System.out.println(temp);
}
}
BASIC-10 十进制转十六进制
问题描述
十六进制数是在程序设计时经常要使用到的一种整数的表示方式。它有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.math.BigInteger;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String temp10 = sc.next();
String temp16 = new BigInteger(temp10).toString(16).toUpperCase();
System.out.println(temp16);
}
}
有点坑的是，这题的十六进制要用 .toUpperCase()转为大写的，不然算作不对…
BASIC-12、11、10三种是同类型，都用了Java的BigInteger简单粗暴地完成转换了，先这么着吧。
BASIC-9 特殊回文数
问题描述
123321是一个非常特殊的数，它从左边读和从右边读是一样的。
输入一个正整数n， 编程求所有这样的五位和六位十进制数，满足各位数字之和等于n 。
输入格式
输入一行，包含一个正整数n。
输出格式
按从小到大的顺序输出满足条件的整数，每个整数占一行。
样例输入
52
样例输出
899998
989989
998899
数据规模和约定
1<=n<=54
由于要求的是五位和六位十进制数，可以暴力枚举找出 10000~999999 内所有符合要求的情况
- 用一个循环遍历范围内的数，通过计算个、十、百、千、万、十万位上的数，判断是否符合约束条件（即相加为 n ）；
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
for(int i = 10000; i <= 999999; i++) {
if(i < 100000) { // i为五位数
int g = i % 10; // 个位
int s = i / 10 % 10; // 十位
int b = i / 100 % 10; // 百位
int q = i / 1000 % 10; // 千位
int w = i / 10000 % 10; // 万位
if(g == w && s == q && g+s+b+q+w == n)
System.out.println(i);
}else { // i为六位数
int g = i % 10; // 个位
int s = i / 10 % 10; // 十位
int b = i / 100 % 10; // 百位
int q = i / 1000 % 10; // 千位
int w = i / 10000 % 10; // 万位
int sw = i / 100000 % 10; // 十万位
if(g == sw && s == w && b == q && g+s+b+q+w+sw == n) {
System.out.println(i);
}
}
}
}
}
- 用多层循环操作各位上的数找到满足条件的情况。
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
// 五位数
for (int i = 1; i < 10; i++) { // 操作个位数，最小为1
for (int j = 0; j < 10; j++) { // 操作十位数
for (int k = 0; k < 10; k++) { // 操作百位数
if(2*(i+j)+k == n) { // 回文数各位相加满足n
// int temp = i + j*10 + k*100 + j*1000 + i*10000;
int temp = i*10001 + j*1010 + k*100;
System.out.println(temp);
}
}
}
}
// 六位数
for (int i = 1; i < 10; i++) { // 操作个位数，最小为1
for (int j = 0; j < 10; j++) { // 操作十位数
for (int k = 0; k < 10; k++) { // 操作百位数
if(2*(i+j+k) == n) { // 回文数各位相加满足n
// int temp = i + j*10 + k*100 + k*1000 + j*10000 + i*100000;
int temp = i*100001 + j*10010 + k*1100;
System.out.println(temp);
}
}
}
}
}
}
BASIC-8 回文数
问题描述
1221是一个非常特殊的数，它从左边读和从右边读是一样的，编程求所有这样的四位十进制数。
输出格式
按从小到大的顺序输出满足条件的四位十进制数。
- 就是把四位十进制数中是回文数的都按顺序输出，遍历枚举即可。
public class Main {
public static void main(String[] args) {
for (int i = 1000; i <= 9999; i++) {
int g = i % 10; // 个
int s = i / 10 % 10; // 十
int b = i / 100 % 10; // 百
int q = i / 1000 % 10; // 千
if(g == q && s == b)
System.out.println(i);
}
}
}
- 控制位数的话
public class Main {
public static void main(String[] args) {
for (int i = 1; i < 10; i++) {
for(int j = 0; j < 10; j++) {
// int temp = i + j*10 + j*100 + i*1000;
int temp = i * 1001 + j * 110;
System.out.println(temp);
}
}
}
}
BASIC-9 和 BASIC-8 还有下面的 BASIC-7 是一样的套路.
BASIC-7 特殊的数字
问题描述
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 g = i % 10;
int s = i / 10 % 10;
int b = i / 100 % 10;
if (g*g*g+s*s*s+b*b*b == i)
System.out.println(i);
}
}
}
BASIC-6 杨辉三角形
问题描述
杨辉三角形又称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 sc = new Scanner(System.in);
int n = sc.nextInt();
// 存储计算杨辉三角
int[][] arr = new int[n][n];
for (int i = 0; i < n; i++) {
arr[i][0] = 1;
if (i == 0) {
continue;
}
for (int j = 1; j <= i; j++) {
arr[i][j] = arr[i-1][j-1] + arr[i-1][j];
}
}
// 输出杨辉三角
for (int i = 0; i < n; i++) {
for (int j = 0; j <= i; j++)
System.out.print(arr[i][j]+" ");
System.out.println();
}
}
}
BASIC-5 查找整数
问题描述
给出一个包含n个整数的数列，问整数a在数列中的第一次出现是第几个。
输入格式
第一行包含一个整数n。
第二行包含n个非负整数，为给定的数列，数列中的每个数都不大于10000。
第三行包含一个整数a，为待查找的数。
输出格式
如果a在数列中出现了，输出它第一次出现的位置(位置从1开始编号)，否则输出-1。
样例输入
6
1 9 4 8 3 9
9
样例输出
2
数据规模与约定
1 <= n <= 1000
直接遍历，设一个标识符 flag 判断是否找到了target值：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int[] arr = new int[n];
for(int i = 0; i < n; i++)
arr[i] = sc.nextInt();
int target = sc.nextInt();
int flag = 0;
// 查找
for(int i = 0; i < n; i++) {
if(arr[i] == target) {
System.out.println(i+1);
flag = 1;
break;
}
}
if (flag == 0)
System.out.println(-1);
}
}
BASIC-4 数列特征
问题描述
给出n个数，找出这n个数的最大值，最小值，和。
输入格式
第一行为整数n，表示数的个数。
第二行有n个数，为给定的n个数，每个数的绝对值都小于10000。
输出格式
输出三行，每行一个整数。第一行表示这些数中的最大值，第二行表示这些数中的最小值，第三行表示这些数的和。
样例输入
5
1 3 -2 4 5
样例输出
5
-2
11
数据规模与约定
1 <= n <= 10000
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int max = 0,min = 0,sum = 0;
for(int i = 0; i < n; i++) {
int temp = sc.nextInt();
if(i == 0)
max = min = temp;
if(temp > max)
max = temp;
else if(temp < min)
min = temp;
sum += temp;
}
System.out.println(max);
System.out.println(min);
System.out.println(sum);
}
}
BASIC-3 字母图形
问题描述
利用字母可以组成一些美丽的图形，下面给出了一个例子：
ABCDEFG
BABCDEF
CBABCDE
DCBABCD
EDCBABC
这是一个5行7列的图形，请找出这个图形的规律，并输出一个n行m列的图形。
输入格式
输入一行，包含两个整数n和m，分别表示你要输出的图形的行数的列数。
输出格式
输出n行，每个m个字符，为你的图形。
样例输入
5 7
样例输出
ABCDEFG
BABCDEF
CBABCDE
DCBABCD
EDCBABC
数据规模与约定
1 <= n, m <= 26
第 i 行 i 列位置上字母均为 A，其他位置字母与其离 A的距离绝对值 有关：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int m = sc.nextInt();
for(int i = 0; i < n; i++) {
for(int j = 0; j < m; j++) {
// ‘A’的ASCII码为65,直接用‘A’也行
char temp = (char)(65 + Math.abs(j - i));
System.out.print(temp);
}
System.out.println();
}
}
}
BASIC-2 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 temp = Integer.toString(i, 2);
int d = Math.abs(temp.length() - 5);
while(d != 0) {
System.out.print('0');
d--;
}
System.out.print(temp);
System.out.println();
}
}
}
可以借助Integer.parseInt(）转换成int型，再用printf格式化输出
public class Main {
public static void main(String[] args) {
for(int i = 0; i < 32; i++) {
// String temp = Integer.toString(i, 2);
// int a = Integer.parseInt(temp);
int a = Integer.parseInt(Integer.toString(i, 2));
System.out.printf("%05d\n",a);
}
}
}
BASIC-1 闰年判断
问题描述
给定一个年份，判断这一年是不是闰年。
当以下情况之一满足时，这一年是闰年：
年份是4的倍数而不是100的倍数；
年份是400的倍数。
其他的年份都不是闰年。
输入格式
输入包含一个整数y，表示当前的年份。
输出格式
输出一行，如果给定的年份是闰年，则输出yes，否则输出no。
说明：当试题指定你输出一个字符串作为结果（比如本题的yes或者no，你需要严格按照试题中给定的大小写，写错大小写将不得分。
样例输入
2013
样例输出
no
样例输入
2016
样例输出
yes
数据规模与约定
1990 <= y <= 2050
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int year = sc.nextInt();
if((year % 4 == 0 && year % 100 != 0) || year % 400 == 0)
System.out.println("yes");
else
System.out.println("no");
}
}
BASIC-04 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
- 要计算只包含加法、减法和乘法的整数表达式除以正整数n的余数，可以在每步计算之后对n取余，结果不变。
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int f1 = 1, f2 = 1;
int fn = 0;
if(n == 1 || n == 2)
System.out.println(1);
else {
for(int i = 3; i <= n; i++) {
fn = (f1 + f2) % 10007;
f1 = f2;
f2 = fn;
}
System.out.println(fn);
}
}
}
用递归会占用较大内存。
BASIC-03 圆的面积
问题描述
给定圆的半径r，求圆的面积。
输入格式
输入包含一个整数r，表示圆的半径。
输出格式
输出一行，包含一个实数，四舍五入保留小数点后7位，表示圆的面积。
说明：在本题中，输入是一个整数，但是输出是一个实数。
对于实数输出的问题，请一定看清楚实数输出的要求，比如本题中要求保留小数点后7位，则你的程序必须严格的输出7位小数，输出过多或者过少的小数位数都是不行的，都会被认为错误。
实数输出的问题如果没有特别说明，舍入都是按四舍五入进行。
样例输入
4
样例输出
50.2654825
数据规模与约定
1 <= r <= 10000。
提示
本题对精度要求较高，请注意π的值应该取较精确的值。你可以使用常量来表示π，比如PI=3.14159265358979323，也可以使用数学公式来求π，比如PI=atan(1.0)*4。
import java.util.Scanner;
public class Main {
final static double PI = 3.14159265358979323;
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int r = sc.nextInt();
System.out.printf("%.7f",Area(r));
}
public static double Area(int r) {
double area = PI * r * r;
return area;
}
}
BASIC-02 序列求和
问题描述
求1+2+3+…+n的值。
输入格式
输入包括一个整数n。
输出格式
输出一行，包括一个整数，表示1+2+3+…+n的值。
样例输入
4
样例输出
10
样例输入
100
说明：
有一些试题会给出多组样例输入输出以帮助你更好的做题。
一般在提交之前所有这些样例都需要测试通过才行，但这不代表这几组样例数据都正确了你的程序就是完全正确的，潜在的错误可能仍然导致你的得分较低。
样例输出
5050
数据规模与约定
1 <= n <= 1,000,000,000。
说明：
请注意这里的数据规模。
本题直接的想法是直接使用一个循环来累加，然而，当数据规模很大时，这种“暴力”的方法往往会导致超时。此时你需要想想其他方法。你可以试一试，如果使用1000000000作为你的程序的输入，你的程序是不是能在规定的上面规定的时限内运行出来。
本题另一个要值得注意的地方是答案的大小不在你的语言默认的整型(int)范围内，如果使用整型来保存结果，会导致结果错误。
如果你使用C++或C语言而且准备使用printf输出结果，则你的格式字符串应该写成%I64d以输出long long类型的整数。
主要是最后说明当中提到的整型范围问题，使用 Long就🆗了。
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
Long temp = (long)(1 + n) * n / 2;
System.out.println(temp);
}
}
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
