蓝桥杯程序练习

发表于 | 更新于 | 分类于 | 阅读次数： | 字数： 3,860 | 阅读时长： 19

数列排序

问题描述

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

输入格式

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

输出格式

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

样例输入

5
8 3 6 4 9

样例输出

3 4 6 8 9

源代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import java.util.Arrays;
import java.util.Scanner;

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

Fibonacci数列

问题描述

​ Fibonacci数列的递推公式为：Fn=Fn-1+Fn-2，其中 F1=F2=1。

​ 当n比较大时，Fn也非常大，现在我们想知道，Fn除以10007的余数是多少。

输入格式

​ 输入包含一个整数n。

输出格式

​ n

​ 说明：在本题中，答案是要求Fn除以10007的余数，因此我们只要能算出这个余数即可，而不需要先计算出Fn的准确值，再将计算的结果除以10007取余数，直接计算余数往往比先算出原数再取余简单。

样例输入 10 样例输出 55

样例输入 22 样例输出 7704

数据规模与约定

1 <= n <= 1,000,000。

源代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import java.util.Scanner;


public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int[] a = new int[1000000];
		a[1] = 1;
		a[2] = 1;
		for(int i=3; i<=n; i++)
			a[i] = (a[i-1]+a[i-2])%10007;
		System.out.println(a[n]);
	} 
}

十六进制转八进制

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

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

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

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

样例输入**
　　2
　　39
　　123ABC

样例输出**
　　71
　　4435274

　　【提示**】
　　先将十六进制数转换成某进制数，再由某进制数转换成八进制。

源代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
import java.util.Scanner;

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

	private static String toOctal(String strBinary) {
		int len = strBinary.length();
		int k;
		StringBuffer stb =new StringBuffer();
		if(strBinary.substring(0,3).equals("000")) k=3;
		else k=0;
		for(int i=k;i<len; i+=3){
			String string = strBinary.substring(i,i+3);
			if(string.equals("000")) stb.append("0");
			else if(string.equals("001")) stb.append("1");
			else if(string.equals("010")) stb.append("2");
			else if(string.equals("011")) stb.append("3");
			else if(string.equals("100")) stb.append("4");
			else if(string.equals("101")) stb.append("5");
			else if(string.equals("110")) stb.append("6");
			else if(string.equals("111")) stb.append("7");
		}
		return stb.toString();
	}
    


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

十六进制转十进制

问题描述

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

样例输入

FFFF

样例输出

65535

源代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		String string = scanner.next();
		int a = 0;
		long sum = 0;
		
		for(int i = 0; i < string.length(); i++) {
			
			switch (string.charAt(i)) {
			case '0': a = 0;break;
            case '1': a = 1;break;
            case '2': a = 2;break;
            case '3': a = 3;break;
            case '4': a = 4;break;
            case '5': a = 5;break;
            case '6': a = 6;break;
            case '7': a = 7;break;
            case '8': a = 8;break;
            case '9': a = 9;break;
            case 'A': a = 10;break;
            case 'B': a = 11;break;
            case 'C': a = 12;break;
            case 'D': a = 13;break;
            case 'E': a = 14;break;
            case 'F': a = 15;break;
			default:
				break;
			}
			sum += a* Math.pow(16, string.length()-i-1);
		}
		System.out.println(sum);
	
	}
}

十进制转十六进制

问题描述

　　十六进制数是在程序设计时经常要使用到的一种整数的表示方式。它有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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		int a = scanner.nextInt();
		int[] b = new int[10];
		int len = 0;
		if(a==0) {
			System.out.println(0);
			return ;
		}
		while(a != 0) {
			b[len] = a%16;
			len++;
			a /= 16;
		}
      
		StringBuffer stb = new StringBuffer();
		for( int i = len-1; i >= 0; i--) {
			String s = null;
			switch(b[i]) {
			case 0: s = "0";break;
			case 1: s = "1";break;
			case 2: s = "2";break;
			case 3: s = "3";break;
			case 4: s = "4";break;
			case 5: s = "5";break;
			case 6: s = "6";break;
			case 7: s = "7";break;
			case 8: s = "8";break;
			case 9: s = "9";break;
			case 10: s = "A";break;
			case 11: s = "B";break;
			case 12: s = "C";break;
			case 13: s = "D";break;
			case 14: s = "E";break;
			case 15: s = "F";break;
			default:
				break;
			}			
			stb.append(s);				
		}	
		System.out.println(stb.toString());
	}
}

特殊回文数：

问题描述

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

输入格式

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

输出格式

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

样例输入

52

样例输出

899998
989989
998899

数据规模和约定

　　1<=n<=54。

源代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		ArrayList<Integer> rs = new ArrayList<Integer>();
		
		for(int i=1; i<10; i++) {
			for(int j=0; j<10; j++) {
				for(int k=0; k<10; k++) {
					if(2*i+2*j+k == n)
						rs.add(i*10000 + j*1000 + k*100 + j*10 + i);
					if(2*i+2*j+2*k == n)
						rs.add(i*100000 + j*10000 + k*1000 + k*100 + j*10 + i);
				}
			}
		}
		Collections.sort(rs);
		for(int i=0; i<rs.size(); i++)
			System.out.println(rs.get(i));
	}
}

回文数：

问题描述

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

输出格式

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

源代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Main {
	
	public static void main(String [] arg) {

		for(int i = 1000; i < 10000; i++) {
			int a = i/1000;
			int b = i%1000/100;
			int c = i%100/10;
			int d = i%10;
			if( a == d && b ==c) 
				System.out.println(i);
		}
	}
}

特殊的数字：

问题描述

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

输出格式

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

源代码：

1
2
3
4
5
6
7
8
9
10
11
12
public class Main {

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

杨辉三角

问题描述

​ 杨辉三角形又称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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import java.util.Scanner;

public class Main {

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

}

查找整数：

问题描述

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

输入格式

​ 第一行包含一个整数n。

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

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

输出格式

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

样例输入

6
1 9 4 8 3 9
9

样例输出

2

数据规模与约定

1 <= n <= 1000。

源代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		
		int [] a = new int[n];
		for(int i = 0; i < n; i++) {
			a[i] = sc.nextInt();
		}
		int s = sc.nextInt();
		int b = 0;
		for(int i = 0; i < n; i++) {
			if(a[i] == s) {
				System.out.println(i+1);
				b = 1;
				break;
			}
		}
		if(b == 0)
			System.out.println(-1);
	}

}

数列特征：

问题描述

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

输入格式

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

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

输出格式

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

样例输入

5
1 3 -2 4 5

样例输出

5
-2
11

数据规模与约定

1 <= n <= 10000。

源代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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 [] a = new int[n];
		int b = 0;
		for(int i = 0; i < n; i++) {
			a[i] = sc.nextInt();
			b += a[i];
		}
		Arrays.sort(a);
		System.out.println(a[n-1]);
		System.out.println(a[0]);
		System.out.println(b);
	}	
}

闰年判断：

问题描述

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

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

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

其他的年份都不是闰年。

输入格式

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

输出格式

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

样例输入

2013

样例输出

no

样例输入

2016

样例输出

yes

数据规模与约定

1990 <= y <= 2050。

源代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int y = sc.nextInt();
		if((y%4 == 0 && y%100 != 0) || y%400 == 0) 
			System.out.println("yes");
		else
			System.out.println("no");
	}
}

01字符：

问题描述

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

00000

00001

00010

00011

00100

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

输入格式

本试题没有输入。

输出格式

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

样例输出

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

源代码：

1
2
3
4
5
6
7
8
9
10
11
public class Main{
	public static void main(String[] args) {
		for(int i=0; i<2; i++)
			for(int j=0; j<2; j++)
				for(int k=0; k<2; k++)
					for(int l=0; l<2; l++)
						for(int m=0; m<2; m++) {
							System.out.println(i+""+j+""+k+""+l+""+m);
				    	}						
	}
}

阶乘计算：

问题描述

　　输入一个正整数n，输出n!的值。
　　其中n!=123…n。

算法描述

　　n!可能很大，而计算机能表示的整数范围有限，需要使用高精度计算的方法。使用一个数组A来表示一个大整数a，A[0]表示a的个位，A[1]表示a的十位，依次类推。
　　将a乘以一个整数k变为将数组A的每一个元素都乘以k，请注意处理相应的进位。
　　首先将a设为1，然后乘2，乘3，当乘到n时，即得到了n!的值。

输入格式

　　输入包含一个正整数n，n<=1000。

输出格式

　　输出n!的准确值。

样例输入

10

样例输出

3628800

源代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Scanner;

public class 阶乘计算 {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		System.out.println(f(n));
	}
	
	//初始化数组
	protected static ArrayList<BigInteger> table = new ArrayList<BigInteger>();
	static {
		//BigInterger.valueof(long val);
		//返回其值等于指定 long 的值的 BigInteger。
		table.add(BigInteger.valueOf(1));//给数组添加初始值1
	}
	
	public static BigInteger f(int x) {
		for(int size = table.size(); size <= x; size++) {
			//获取当前数组的最后一个数
			BigInteger lastfact = (BigInteger)table.get(size-1);
			/*
			 *multiply(BigInterger val)
			 *返回其值为（this * val）的BigInterger。
			 */
			//当前数组的最后一个数和size相乘，并存入数组
			BigInteger nextfact = lastfact.multiply(BigInteger.valueOf(size));
			table.add(nextfact);
		}
		return (BigInteger)table.get(x);//返回数组的最后一个数
	}
}
坚持原创技术分享，您的支持将鼓励我继续创作！