蓝桥杯基础练习

一、闰年判断【此题题目已经给出了闰年的计算方法，直接按照题目给出的提示即可得出结果】

问题描述

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

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

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

　　2. 年份是400的倍数。

　　其他的年份都不是闰年。

输入格式

　　输入包含一个整数y，表示当前的年份。

输出格式

　　输出一行，如果给定的年份是闰年，则输出yes，否则输出no。

　　说明：当试题指定你输出一个字符串作为结果（比如本题的yes或者no，你需要严格按照试题中给定的大小写，写错大小写将不得分。

样例输入

　　2013

样例输出

　　no

样例输入

　　2016

样例输出

　　yes

数据规模与约定

　　1990 <= y <= 2050。

 1 import java.util.Scanner;

 2 

 3 public class Main {

 4 

 5     public static void main(String[] args) {

 6         Scanner mScanner = new Scanner(System.in);

 7         int m = mScanner.nextInt();

 8         

 9         Main mMain1 = new Main();

10         

11         if (mMain1.check(m)) {

12             System.out.println("yes");

13         }else{

14             System.out.println("no");

15         }

16     

17     }

18     

19     public boolean check(int m){

20         if (m%1000==0) {

21             return true;

22         }else if(m%4==0){

23             return true;

24         }else{

25             return false;

26         }

27     }

28 

29 }

 

二、01字串【此题直接循环输出即可，进行暴力破解】

问题描述

　　对于长度为5位的一个01串，每一位都可能是0或1，一共有32种可能。它们的前几个是：

　　00000

　　00001

　　00010

　　00011

　　00100

　　请按从小到大的顺序输出这32种01串。

输入格式

　　本试题没有输入。

输出格式

　　输出32行，按从小到大的顺序每行一个长度为5的01串。

样例输出

　　00000
　　00001
　　00010
　　00011
　　<以下部分省略>

 1 public class Main {

 2     public static void main(String[] args) {

 3         int a;

 4         int b;

 5         int c;

 6         int d;

 7         int e;

 8 

 9         for (a = 0; a < 2; ++a)

10             for (b = 0; b < 2; ++b)

11                 for (c = 0; c < 2; ++c)

12                     for (d = 0; d < 2; ++d)

13                         for (e = 0; e < 2; ++e)

14                             System.out.println(a + "" + b + "" + c + "" + d +

15                                 "" + e);

16     }

17 }

 

三、字母图形【此题有点巧妙之处，就是先建立了一个一位数组arr，在数组中存储了26*2-1个整数，分别是：25，24，23，……，2，1，0，1，2，……，23，24，25   然后通过carr[i] = (char)(arr[i]+'A');把整型数组转化为char型字符串，最后通过循环来巧妙的输出用户输入的图】

问题描述

　　利用字母可以组成一些美丽的图形，下面给出了一个例子：

　　ABCDEFG

　　BABCDEF

　　CBABCDE

　　DCBABCD

　　EDCBABC

　　这是一个5行7列的图形，请找出这个图形的规律，并输出一个n行m列的图形。

输入格式

　　输入一行，包含两个整数n和m，分别表示你要输出的图形的行数的列数。

输出格式

　　输出n行，每个m个字符，为你的图形。

样例输入

　　5 7

样例输出

　　ABCDEFG
　　BABCDEF
　　CBABCDE
　　DCBABCD
　　EDCBABC

数据规模与约定

　　1 <= n, m <= 26。

 1 import java.util.Scanner;

 2 

 3 public class Main {

 4     public static void main(String[] args) {

 5         Scanner scanner = new Scanner(System.in);

 6         String[] sarr = scanner.nextLine().split(" ");

 7 

 8         init(Integer.parseInt(sarr[0]), Integer.parseInt(sarr[1]));

 9     }

10 

11     public static void init(int m, int n) {

12         int[] arr = new int[(26 * 2) - 1];

13 

14         for (int i = 0; i < arr.length; i++) {

15             if (i < 26) {

16                 arr[i] = 25 - i; //25,24 ,,,0

17             } else {

18                 arr[i] = i - 26 + 1; //1,2,,,25

19             }

20         }

21 

22         char[] carr = new char[arr.length];

23 

24         for (int i = 0; i < arr.length; i++) {

25             carr[i] = (char) (arr[i] + 'A');

26         }

27 

28         int p = 25;

29 

30         for (int i = 0; i < m; i++) {

31             for (int j = 0; j < n; j++) {

32                 System.out.print(carr[p + j]);

33             }

34 

35             p--;

36             System.out.println();

37         }

38     }

39 }

 

四、数列特征【这个题是我第一次做的时候的，先在发现这样做有点麻烦了，求最大值，最小值可以直接使用系统的求最大值，最小值的函数】

问题描述

　　给出n个数，找出这n个数的最大值，最小值，和。

输入格式

　　第一行为整数n，表示数的个数。

　　第二行有n个数，为给定的n个数，每个数的绝对值都小于10000。

输出格式

　　输出三行，每行一个整数。第一行表示这些数中的最大值，第二行表示这些数中的最小值，第三行表示这些数的和。

样例输入

　　5
　　1 3 -2 4 5

样例输出

　　5
　　-2
　　11

数据规模与约定

　　1 <= n <= 10000。

 1 import java.util.Scanner;

 2 

 3 public class Main {

 4 

 5     public static void main(String[] args) {

 6         Scanner mScanner = new Scanner(System.in);

 7         int num;

 8         num = mScanner.nextInt();

 9         int[] arr = new int[num];

10         for (int i = 0; i < arr.length; i++) {

11             arr[i] = mScanner.nextInt();

12         }

13         int max = getMax(arr);

14         int min = getMin(arr);

15         int sum = getSum(arr);

16         System.out.println(max);

17         System.out.println(min);

18         System.out.println(sum);

19 

20     }

21 

22     public static int getMax(int[] arr) {

23         int tmp = arr[0];

24         for (int i = 1; i < arr.length; i++) {

25             if (arr[i] > tmp) {

26                 tmp = arr[i];

27             }

28         }

29         return tmp;

30     }

31     

32     public static int getMin(int[] arr) {

33         int tmp = arr[0];

34         for (int i = 1; i < arr.length; i++) {

35             if (arr[i] < tmp) {

36                 tmp = arr[i];

37             }

38         }

39         return tmp;

40     }

41 

42     public static int getSum(int[] arr) {

43         int tmp = 0;

44         for (int i = 0; i < arr.length; i++) {

45             tmp = tmp + arr[i];

46         }

47         return tmp;

48     }

49 

50 }

 

五、查找整数【这个题也没有难度，但是需要注意的是如果该数不在数列中存在的时候的返回值是1，而不是其他值】

问题描述

　　给出一个包含n个整数的数列，问整数a在数列中的第一次出现是第几个。

输入格式

　　第一行包含一个整数n。

　　第二行包含n个非负整数，为给定的数列，数列中的每个数都不大于10000。

　　第三行包含一个整数a，为待查找的数。

输出格式

　　如果a在数列中出现了，输出它第一次出现的位置(位置从1开始编号)，否则输出-1。

样例输入

　　6
　　1 9 4 8 3 9
　　9

样例输出

　　2

数据规模与约定

　　1 <= n <= 1000。

 1 import java.util.Scanner;

 2 

 3 public class Main {

 4     public static void main(String[] args) {

 5         Scanner mScanner = new Scanner(System.in);

 6         int num;

 7         num = mScanner.nextInt();

 8         int[] arr = new int[num];

 9         for (int i = 0; i < arr.length; i++) {

10             arr[i] = mScanner.nextInt();

11         }

12         int s = mScanner.nextInt();

13         System.out.println(getIndexs(arr, s));

14     }

15 

16     public static int getIndexs(int[] arr, int s) {

17         int a = -1;

18         for (int i = 0; i < arr.length; i++) {

19             if (arr[i] == s) {

20                 a = i + 1;

21                 break;

22             }

23         }

24 

25         return a;

26     }

27 }

 

六、杨辉三角形【杨辉三角是一个比较经典的问题，如果找到规律的话，做出此题也不是问题，但是这个题需要注意的是，每行的两个数之间有一个空格隔开的，不然的话是没有分的】

问题描述

杨辉三角形又称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。

 1 import java.util.Scanner;

 2 

 3 public class Main {

 4 

 5     public static void main(String[] args) {

 6         int i = 1;

 7         Scanner mScanner = new Scanner(System.in);

 8         int n = mScanner.nextInt();

 9         int yh[] = new int[n];

10         for (i = 0; i < yh.length; i++) {

11             yh[i] = 1;

12             for (int j = i - 1; j > 0; j--) {

13                 yh[j] = yh[j - 1] + yh[j];

14             }

15             for (int j = 0; j <= i; j++) {

16                 System.out.print(yh[j] + "\t");

17             }

18             System.out.println();

19         }

20     }

21 

22 }

 

七、特殊的数字【暴力破解：从100开始，循环到999，即循环所有的三位数】

问题描述

　　153是一个非常特殊的数，它等于它的每位数字的立方和，即153=1*1*1+5*5*5+3*3*3。编程求所有满足这种条件的三位十进制数。

输出格式

　　按从小到大的顺序输出满足条件的三位十进制数，每个数占一行。

 1 public class Main {

 2 

 3     public static void main(String[] args) {

 4         for (int i = 100; i < 1000; i++) {

 5             check(i);

 6         }

 7     }

 8 

 9     public static void check(int n) {

10         int a = n % 10;

11         int b = (int) (n / 10) % 10;

12         int c = (int) ((int) (n / 10) / 10);

13         test(n, a, b, c);

14     }

15 

16     public static void test(int a, int m, int n, int t) {

17         if (a == m * m * m + n * n * n + t * t * t) {

18             System.out.println(a);

19         }

20     }

21 }

 

八、回文数【暴力破解】

问题描述

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

输出格式

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

 1 public class Main {

 2 

 3     public static void main(String[] args) {

 4         for (int i = 1; i <= 9; i++) {

 5             for (int j = 0; j <= 9; j++) {

 6                 for (int j2 = 0; j2 <= 9; j2++) {

 7                     for (int k = 1; k <= 9; k++) {

 8                         if (i == k && j == j2) {

 9                             System.out.println(i+""+j+""+j2+""+k);

10                         }

11                     }

12                 }

13             }

14         }

15     }

16 

17 }

 

九、特殊回文数【暴力遍历所有符合条件的5位数，6位数】

问题描述

　　123321是一个非常特殊的数，它从左边读和从右边读是一样的。
　　输入一个正整数n， 编程求所有这样的五位和六位十进制数，满足各位数字之和等于n 。

输入格式

　　输入一行，包含一个正整数n。

输出格式

　　按从小到大的顺序输出满足条件的整数，每个整数占一行。

样例输入

52

样例输出

899998
989989
998899

数据规模和约定

　　1<=n<=54。

 1 import java.util.Scanner;

 2 

 3 public class Main {

 4 

 5     public static void main(String[] args) {

 6         Scanner mScanner = new Scanner(System.in);

 7         int n = mScanner.nextInt();

 8         if (1 <= n && n <= 54) {

 9             test1(n);

10             test2(n);

11         }

12     }

13 

14     public static void test1(int m) {

15         for (int i = 1; i <= 9; i++) {

16             for (int j = 0; j <= 9; j++) {

17                 for (int j2 = 0; j2 <= 9; j2++) {

18                     if ((i + j) * 2 + j2 == m) {

19                         System.out.println(i * 10000 + j * 1000 + j2 * 100 + j

20                                 * 10 + i);

21                     }

22                 }

23             }

24         }

25     }

26 

27     public static void test2(int m) {

28         for (int i = 1; i <= 9; i++) {

29             for (int j = 0; j <= 9; j++) {

30                 for (int j2 = 0; j2 <= 9; j2++) {

31                     if ((i + j + j2) * 2 == m) {

32                         System.out.println(i * 100000 + j * 10000 + j2 * 1000

33                                 + j2 * 100 + j * 10 + i);

34                     }

35                 }

36             }

37         }

38     }

39 

40 }

 

十、十进制转十六进制【个人感觉这个代码需要灵活运用掌握，(char) ((Integer.parseInt(a) - 10) + 'A');】

问题描述

　　十六进制数是在程序设计时经常要使用到的一种整数的表示方式。它有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

 1 import java.util.*;

 2 

 3 public class Main {

 4     public static void main(String[] args) {

 5         Scanner mScanner = new Scanner(System.in);

 6         int m = mScanner.nextInt();

 7         if (0 <= m && m <= 2147483647) {

 8             if (m==0) {

 9                 System.out.print(0);

10             }else{

11                 test(m);

12             }

13         }

14     }

15 

16     public static void test(int m) {

17         Vector<String> arr = new Vector<String>();

18         while (m > 0) {

19             arr.add(m % 16 + "");

20             m = (int) (m / 16);

21         }

22 

23         for (int i = arr.size() - 1; i >= 0; i--) {

24             int mm = Integer.parseInt(arr.get(i));

25             char s;

26             if (mm >= 10) {

27                 s = change(arr.get(i));

28                 System.out.print(s);

29             } else {

30                 System.out.print(mm + "");

31             }

32 

33         }

34 

35     }

36 

37     public static char change(String a) {

38         return (char) ((Integer.parseInt(a) - 10) + 'A');

39     }

40 }

 

十一、十六进制转十进制【此处用到了一个toString方法！】

问题描述

　　从键盘输入一个不超过8位的正的十六进制数字符串，将它转换为正的十进制数后输出。
　　注：十六进制数中的10~15分别用大写的英文字母A、B、C、D、E、F表示。

样例输入

　　FFFF

样例输出

　　65535

 1 import java.math.BigInteger;

 2 import java.util.Scanner;

 3 

 4 public class Main {

 5 

 6     public static void main(String[] args) {

 7         Scanner mScanner = new Scanner(System.in);

 8         String aa  = mScanner.next();

 9         BigInteger mBigInteger = new BigInteger(aa,16);

10         System.out.println(mBigInteger.toString(10));

11     }

12 

13 }

 

十二、十六进制转八进制【此题由于题目给出的测试值太大，未能通过测试，此处不再给出代码……，如果各位有更好的算法，可以私信我哦！】

问题描述

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

输入格式

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

输出格式

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

注意

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

样例输入

　　2
　　39
　　123ABC

样例输出

　　71
　　4435274

提示

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

十三、数列排序【本题主要就是数组的排序，这里用到了java已经封装好的类库中的一个排序方法 Arrays.sort(aa);】

问题描述

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

输入格式

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

输出格式

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

样例输入

　　5
　　8 3 6 4 9

样例输出

　　3 4 6 8 9

 1 import java.util.Arrays;

 2 import java.util.Scanner;

 3 

 4 public class Main {

 5     public static void main(String[] args) {

 6         Scanner mm = new Scanner(System.in);

 7         int n = mm.nextInt();

 8         int []aa = new int[n]; 

 9         for (int i = 0; i < n; i++) {

10             aa[i] = mm.nextInt();

11         }

12         Arrays.sort(aa);

13         for (int i = 0; i < n; i++) {

14             System.out.print(aa[i]+" ");

15         }

16     }

17 

18 }

注：本文系原创，首发于博客园，转载请注明出处。