蓝桥杯基础练习

最新推荐文章于 2023-01-09 15:47:48 发布

原创最新推荐文章于 2023-01-09 15:47:48 发布 · 559 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#java

java 同时被 2 个专栏收录

29 篇文章

订阅专栏

蓝桥杯

8 篇文章

订阅专栏

1. 基础练习闰年判断

问题描述

给定一个年份，判断这一年是不是闰年。

当以下情况之一满足时，这一年是闰年：

1. 年份是4的倍数而不是100的倍数；

2. 年份是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 input = new Scanner(System.in);
		int year = input.nextInt();
		if(year>=1990 &&year<=2050){
			if((year % 4==0 &&year%100!=0) ||(year%400==0))
				System.out.println("yes");
			else
				System.out.println("no");
		}
	}
}

重点在于判断是否是闰年的语句:if((year % 4==0 &&year%100!=0) ||(year%400==0))

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 a=0;a<2;a++)
			for(int b=0;b<2;b++)
				for(int c=0;c<2;c++)
					for(int d=0;d<2;d++)
						for(int e=0;e<2;e++)
							System.out.println("" + a + "" + b + "" + c + "" + d + "" + e);	
	}
}

方法一：可以使用五层循环将这五位进行排列输出

方法二：将五位01字串转换成二进制数，0~31依次输出转换为二进制数，

注意运用%05d来保证输出的字串为5位右对齐，用0来补齐，对应使用printf进行格式化输出；

十进制转换成二进制是利用Integer.toBinaryString(i)，再利用Integer.parseInt()将字符串转换为整型

public class Main {
	public static void main(String[] args){
		for(int i=0;i<32;i++){
			int c=Integer.parseInt(Integer.toBinaryString(i));
			System.out.printf("%05d\n",c);
		}
	}
}

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。

import java.util.Scanner;

public class Main {
	public static void main(String[] args){
		Scanner input = new Scanner(System.in);
		int n = input.nextInt();
		int m = input.nextInt();
		if(n<=26&&m<=26){
			for(int i = 0;i<n;i++){
				for(int j = 0;j<m;j++){
					char str = (char)(Math.abs(i-j)+'A');
					System.out.print(str);
				}
				System.out.println("");
			}
		}
	}
}

char str = (char)(Math.abs(i-j)+'A');关键是观察出行数和列数之差的绝对值控制着数组中某位置的字母。

import java.util.Scanner;

public class Main {
	public static void main(String[] args){
		Scanner input = new Scanner(System.in);
		int n = input.nextInt();
		int m = input.nextInt();
		char f[][]= new char[26][26];
		int i=0,j=0;
		for(i=0;i<n;i++){
			char str = 'A';
			for(j=i;j<m;j++){
				f[i][j] = str++;
			}
			str = 'A';
			for(j=i-1;j>=0;j--){
				f[i][j] = ++str;
			}
		}
		
		for(i=0;i<n;i++){
			for(j=0;j<m;j++){
				System.out.print(f[i][j]);
			}
			System.out.println("");
		}	
	}
}

从一开始就要注意数据的规模与约定，限制二维数组的大小char f[][]= new char[26][26];

先存储数组，再输出数组符号；

存储数组分为两个循环，即将数组分成两部分：第一个循环从A开始向右输出每一行的上三角矩阵部分，第二个循环从右向左输出剩余部分。

System.out.println("");控制换行。

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 input = new Scanner(System.in);
		int n = input.nextInt();
		int i=0;
		int f[] = new int[10000];
		for(i = 0;i<n;i++){
			f[i]=input.nextInt();
		}
		int max = f[0];
		int min = f[0];
		int sum = 0;
		for(i=0;i<n;i++){
			if(f[i]>max)
				max = f[i];
			if(f[i]<min)
				min = f[i];
			sum = sum+f[i];
		}
		System.out.println(max);
		System.out.println(min);
		System.out.println(sum);	
	}
}

先将数组中的第一个元素设置为最大值和最小值分别存入max和min，然后将数组中的数值和max与min中的数值进行比较，即进行线性查找，同时计算所有元素的和。通过设置int f[] = new int[10000];满足数据规模与约定。

5. 基础练习查找整数

问题描述

给出一个包含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 input = new Scanner(System.in);
		int n = input.nextInt();
		int f[] = new int[1000];
		int i,j,flag=0;
		for(i = 0;i<n;i++){
			f[i] = input.nextInt();
		}
		int a = input.nextInt();
		for(j = 0;j<n;j++){
			if(a == f[j]){
				flag = j+1;
				break;
			}	
		}
		if(flag > 0)
			System.out.println(flag);
		else
			System.out.println(flag-1);
	}		
}

必须考虑所要查找的数并不在该数列的情况，对此进行处理：若不存在该数，则输出为-1。

break的用法，在找到第一个与数相匹配的位置时应该跳出for循环，只有一层循环用break即可；

如果有多层循环需要直接跳出则使用return；

continue只是结束了本次的循环，跳过其后面的语句直接执行下一次循环，并没有跳出总的循环。

6.基础练习杨辉三角形

问题描述

杨辉三角形又称Pascal三角形，它的第i+1行是(a+b)i的展开式的系数。

它的一个重要性质是：三角形中的每个数字等于它两肩上的数字相加。

下面给出了杨辉三角形的前4行：

1 1

1 2 1

1 3 3 1

给出n，输出它的前n行。

输入格式

输入包含一个数n。

输出格式

输出杨辉三角形的前n行。每一行从这一行的第一个数开始依次输出，中间使用一个空格分隔。请不要在前面输出多余的空格。

样例输入

4

样例输出

数据规模与约定

1 <= n <= 34。

import java.util.Scanner;

public class Main {
	public static void main(String[] args){
		Scanner input = new Scanner(System.in);
		int n = input.nextInt();
		int f[][] = new int[34][34];
		int i,j=0;
		for(i = 0;i < n;i++){
			for(j = 0;j <= i;j++){
				if((j == 0 )|| (i == j)){
					f[i][j] = 1;
				}
				else
					f[i][j] = f[i-1][j-1]+f[i-1][j];
			}
		}
		
		for(i = 0;i < n; i++){
			for(j = 0;j <= i;j++){
				System.out.print(f[i][j]+" ");
			}
			System.out.println();
		}
	}
}

二维数组要先进行存储，再进行输出，需要两个for循环，一定要注意第二层循环中j<=i；

再有需要每个数字之间用空格隔开的条件不要忘记；

杨辉三角形的关键在于：第0列以及行数和列数相等的位置处的数均为1，而其余元素满足f[i][j] = f[i-1][j-1]+f[i-1][j];的条件。

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 < 1000;i++){
			int k = i%10;
			int t = i/10%10;
			int h = i/100;
			int sum = h*h*h + t*t*t + k*k*k;
			if(i == sum){
				System.out.println(i);				
			}				
		}
	}			
}

考察三位数各个数位的取法。

8.基础练习回文数

问题描述

　　1221是一个非常特殊的数，它从左边读和从右边读是一样的，编程求所有这样的四位十进制数。

输出格式

　　按从小到大的顺序输出满足条件的四位十进制数。

public class Main {
	public static void main(String[] args){
		for(int i = 1000; i < 10000;i++){
			int a = i/1000;
			int b = i/100%10;
			int c = i/10%10;
			int d = i%10;
			if(a == d && b == c)
				System.out.println(i);
		}
	}			
}

与第7题一样的套路，考察各个数位的取法，最后加一个判断就可以。

这是直接从所有的四位数中依次选择输出符合条件的数字。

有人还用了第二种方法，将四位数所对应的倒序数和原数进行比较，如果相等则为回文数，运用到了字符串的相关知识。

public class Main {
	public static void main(String[] args){
		String str ;
		for(int i = 1000;i<10000;i++){
			str = String.valueOf(i);
			StringBuilder s = new StringBuilder(str);
			s.reverse();
			String f = new String(s);
			if(f.equals(str)){
				System.out.println(i);
			}
		}
	}		
}

利用str = String.valueOf(i);将数字转化为字符串

必须将String转变成StringBuilder，下面才可以使用reverse()进行取反；

最后再将StringBuilder转化成String类型，和原来转化的字符串进行对等比较，

注意字符串的对等比较应该使用f.equals(str)，而我们经常使用的==是用来判断数字的；

相比较之下，还是第一种方法比较简便，CPU和内存的使用都比较低。

9.基础练习特殊回文数

问题描述

　　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 input = new Scanner(System.in);
		int n = input.nextInt();
		for(int i = 10000;i < 100000;i++){
			int a = i/10000;
			int b = i/1000%10;
			int c = i/100%10;
			int d = i/10%10;
			int e = i%10;
			if(a==e && b==d && (a+b+c+d+e)==n)
				System.out.println(i);
		}
		for(int j = 100000;j < 1000000;j++){
			int a = j/100000;
			int b = j/10000%10;
			int c = j/1000%10 ;
			int d = j/100%10;
			int e = j/10%10;
			int f = j%10;
			if(a==f && b==e && c==d && (a+b+c+d+e+f) ==n)
				System.out.println(j);
		}	
	}		
}

将五位数和六位数的判断分开进行，然后再用if语句进行判断输出符合条件的数。

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.util.Scanner;

public class Main {
	public static void main(String[] args){
		Scanner input = new Scanner(System.in);
		int a = input.nextInt();
		int k = 0;
		char m;
		String str = "";
		
		if (a == 0)
			str = "0";
		
		while(a%16 != 0 || a/16 != 0){
			k = a%16;
			if(k/10 == 1)
				m = (char)(65 + k%10);
			else
				m = (char)(48 + k);
			str = m + str;
			a = a / 16;
		}
		System.out.println(str);			                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
	}			
}

注意输入的十进制数为0的情况，单独讨论，不能漏掉。

采用while循环，注意循环条件a%16 != 0 || a/16 != 0，将要转化成的十六进制数用字符串的格式输出

注意10->A，11->B，...，15->F转化。

11.基础练习十六进制转十进制

问题描述

　　从键盘输入一个不超过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 input = new Scanner(System.in);
		String str = input.next();
		double out = 0;
		int m = 0;
		
		for(int i = 0;i < str.length();i++){
			char k = str.charAt(i);
			if((int)k >= 65)
				m = (int)k -65 + 10;
			else
				m = (int)(k)- 48;
			out = m * Math.pow(16, str.length()-i-1)+out;
		}
		
		System.out.println((long)out);
	}			
}

利用char k = str.charAt(i);依次取出字符串的每一位字符；

将取出的字符根据ASCII表转化为十进制，0~9对应48~57，A~F对应65~70,

再将十进制数转化为真正意义上0~15，根据对应数位乘以16的幂次，利用for循环相加；

一定要注意将最后输出的结果转化为数据类型long，long数据类型是64位有符号的java原始数据类型。当对整数的计算结果可能超出int数据类型的范围时进行使用。long的数据类型范围是（-2^63~2^63-1）。

import java.util.Scanner;

public class Main {
	public static void main(String[] args){
		Scanner input = new Scanner(System.in);
		while(input.hasNext()){
			String str = input.nextLine();
			System.out.println(Long.parseLong(str,16));
		}
	}	
}

首先，next()一定要读取到有效字符后才可以结束输入，对输入有效字符之前遇到的空格键、Tab键或Enter键等结束符，next()方法会自动将其去掉，只有在输入有效字符之后，next()方法才将其后输入的空格键、Tab键或Enter键等视为分隔符或结束符。简单地说，next()查找并返回来自此扫描器的下一个完整标记。完整标记的前后是与分隔模式匹配的输入信息，所以next方法不能得到带空格的字符串

nextLine()方法的结束符只是Enter键，即nextLine()方法返回的是Enter键之前的所有字符，它是可以得到带空格的字符串的。

import java.util.Scanner;

public class Main {
	public static void main(String[] args){
		Scanner input = new Scanner(System.in);
                String str = input.next();
                System.out.print(Long.valueOf(str,16));      
	}	
}

Long.ParseLong(String)方法，将 string 参数解析为有符号十进制，返回一个long的result基本类型值

Long.ValueOf(String) ,方法得到的值非常相似。只是最后被转换为一个Long的包装类。

hasNext()和Next()效果其实是一样的，系统都会等待输入下一个字符，只是返回值不同,hasNext()会返回true，next()返回输入的字符。

以上进行了直接用java类来将十六进制转化为十进制两组代码的比较。注重细节的积累！

12. 基础练习十六进制转八进制

问题描述
　　给定n个十六进制正整数，输出它们对应的八进制数。

输入格式
　　输入的第一行为一个正整数n （1<=n<=10）。
　　接下来n行，每行一个由0~9、大写字母A~F组成的字符串，表示要转换的十六进制正整数，每个十六进制数长度不超过100000。

输出格式
　　输出n行，每行为输入对应的八进制正整数。

　　【注意】
　　输入的十六进制数不会有前导0，比如012A。
　　输出的八进制数也不能有前导0。

样例输入
　　2
　　39
　　123ABC

样例输出
　　71
　　4435274

　　【提示】

　　先将十六进制数转换成某进制数，再由某进制数转换成八进制。

import java.util.Scanner;

public class Main {
	public static void main(String[] args){
		Scanner input = new Scanner(System.in);
		int n = input.nextInt();
		String strHex[] = new String[n];
		for(int i=0;i<n;i++){
			strHex[i] = input.next();
		}
		input.close();
		
		for(int i=0;i<n;i++){
			String strBinary = toBinary(strHex[i]);
			int len_strBin = strBinary.length();
			if(len_strBin % 3 == 1)
				strBinary = "00"+strBinary;
			if(len_strBin % 3 == 2)
				strBinary = "0"+strBinary;
			String strOctal = toOctal(strBinary);
			System.out.println(strOctal);
			
		}
		
	}

	private static String toBinary(String strHex) {
		// TODO Auto-generated method stub
		int len = strHex.length();
		StringBuffer s = new StringBuffer();
		for(int i = 0;i<len;i++){
			switch(strHex.charAt(i)){
			case '0':s.append("0000");break;
			case '1':s.append("0001");break;
			case '2':s.append("0010");break;
			case '3':s.append("0011");break;
			case '4':s.append("0100");break;
			case '5':s.append("0101");break;
			case '6':s.append("0110");break;
			case '7':s.append("0111");break;
			case '8':s.append("1000");break;
			case '9':s.append("1001");break;
			case 'A':s.append("1010");break;
			case 'B':s.append("1011");break;
			case 'C':s.append("1100");break;
			case 'D':s.append("1101");break;
			case 'E':s.append("1110");break;
			case 'F':s.append("1111");break;
			default:break;
			}
		}
		return s.toString();
	}

	private static String toOctal(String strBinary) {
		// TODO Auto-generated method stub
		int len = strBinary.length();
		int k;
		StringBuffer s = new StringBuffer();
		if(strBinary.substring(0,3).equals("000"))
			k = 3;
		else
			k = 0;
		for(int i = k;i<len-2;i+=3){
			switch (strBinary.substring(i,i+3)){
			case "000":s.append("0");break;
			case "001":s.append("1");break;
			case "010":s.append("2");break;
			case "011":s.append("3");break;
			case "100":s.append("4");break;
			case "101":s.append("5");break;
			case "110":s.append("6");break;
			case "111":s.append("7");break;
			default:break;
			}
		}
		return s.toString();
	}
}

构造toBinary()和toOctal()两种方法，分别返回一个字符串对象s.toString()；

十六进制转化成二进制的时候，利用 strHex.charAt(i);依次取出字符串的每一位字符；在for循环的作用下转化为二进制；

注意：在返回的二进制字符串里面，前面的0会舍弃，而二进制转化为八进制需要从右向左每三位二进制数转化为一位八进制数，为保证正确的变换，最后一组二进制数要注意补0操作：

if(len_strBin % 3 == 1)

strBinary = "00"+strBinary;
if(len_strBin % 3 == 2)

strBinary = "0"+strBinary;

二进制转化成八进制的时候，要先利用substring(0,3)取出前三位判断是否为“000”的形式，如果是则不算在八进制数里面。

利用strBinary.substring(i,i+3)三位三位地转换。

使用StringBuffer类中的append方法，追加内容到当前StringBuffer对象的末尾，类似于字符串的连接。

注意：在java中单引号中的内容是char类型为单个字符，双引号中的内容是String类型为字符串。

char是基本类型，而String可以是一个类，直接调用其里面的方法。

String、StringBuffer与StringBuilder之间的区别：StringBuffer和StringBuilder类是可以替代String类的一种处理字符串的解决方案。一般来讲，只要是使用字符串的地方，都可以使用StringBufferr和StringBuilder类，而这两个类比String更灵活，他们可以添加、插入或追加新的内容，但是String对象一旦创建，其值也就确定了。

速度上：String<StringBuffer<StringBuilder；

安全上：StringBuffer线程安全，StringBuilder线程不安全。

13. 基础练习数列排序

问题描述

　　给定一个长度为n的数列，将这个数列按从小到大的顺序排列。1<=n<=200

输入格式

　　第一行为一个整数n。
　　第二行包含n个整数，为待排序的数，每个整数的绝对值小于10000。

输出格式

　　输出一行，按从小到大的顺序输出排序后的数列。

样例输入

5
8 3 6 4 9

样例输出

3 4 6 8 9

import java.util.Arrays;
import java.util.Scanner;

public class Main {
	public static void main(String[] args){
		Scanner input = new Scanner(System.in);
		int n = input.nextInt();
		int f[] = new int[n];
		for(int i=0;i<n;i++){
			f[i]=input.nextInt();
		}
		Arrays.sort(f);
		for(int i=0; i<n; i++){  
            System.out.print(f[i]+" ");  
        }  
	}
}

分为两步，先将元素存储进数组，使用Arrays.sort(int[] a)对数组内的元素从小到大进行排序，然后依次输出。

Arrays.sort(int[] a, int fromIndex, int toIndex)这种形式是对数组进行部分排序，

即对数组a的下标从fromIndex到toIndex-1的元素排序，注意：下标为toIndex的元素不参与排序！