1.闰年判断

资源限制

时间限制：1.0s 内存限制：256.0MB

问题描述

给定一个年份，判断这一年是不是闰年。
当以下情况之一满足时，这一年是闰年：
1.年份是4的倍数而不是100的倍数；
2. 年份是400的倍数。
其他的年份都不是闰年。

输入格式

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

输出格式

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

代码

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

public class Main{
	public static void main(String arg[]){
		Scanner in = new Scanner(System.in);
		int n = in.nextInt();
		if((n%4==0&&n%100!=0)||n%400==0)
			System.out.print("yes");
		else
			System.out.print("no");
	}
}

2.01字串

资源限制

时间限制：1.0s 内存限制：256.0MB

问题描述

对于长度为5位的一个01串，每一位都可能是0或1，一共有32种可能。它们的前几个是：
00000
00001
00010
00011
00100
请按从小到大的顺序输出这32种01串。

输入格式

本试题没有输入。

输出格式

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

代码

1
2
3
4
5
6
7
8
9
public class Main {
	public static void main(String args[]){	
		for(int i=0;i<32;i++){
			String result = Integer.toBinaryString(i);
			int  n = Integer.parseInt(result);
			System.out.printf("%05d\n",n);
		}
	}
}

3.字母图形

资源限制

时间限制：1.0s 内存限制：256.0MB

问题描述

利用字母可以组成一些美丽的图形，下面给出了一个例子：
ABCDEFG
BABCDEF
CBABCDE
DCBABCD
EDCBABC
这是一个5行7列的图形，请找出这个图形的规律，并输出一个n行m列的图形。

输入格式

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

输出格式

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

代码

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

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

4.数列特征

资源限制

时间限制：1.0s 内存限制：256.0MB

问题描述

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

输入格式

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

输出格式

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

代码

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

public class Main{
	public static void main(String arg[]){
		Scanner in = new Scanner(System.in);
		int n = in.nextInt();
		int[] array = new int[n];
        for(int i=0;i<array.length;i++){
            array[i] = in.nextInt();
        }
        int max = array[0];
        int min = array[0];
        int sum = 0;
        for (int i = 0; i < array.length; i++) {
            if(max<array[i]){
            	max = array[i];
            }
            if(min>array[i]){
            	min = array[i];
            }
            sum = sum + array[i];
        }
        System.out.printf("%d%n%d%n%d%n",max,min,sum);
	}
}

5.查找整数

资源限制

时间限制：1.0s 内存限制：256.0MB

问题描述

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

输入格式

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

输出格式

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

代码

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

public class Main{
	public static void main(String args[]){
		Scanner in = new Scanner(System.in);
		int n = in.nextInt();
		int array[] = new int[n];
		for(int i=0;i<array.length;i++){
            int m = in.nextInt();
            array[i]= m ;
        }
		int m = in.nextInt();
		for(int i=0;i<n;i++){
			if(array[i] == m){
				System.out.println(i+1);
				break;
			}
			if(i == n-1){
				System.out.println(-1);
			}
		}
	}
}

6.杨辉三角形

资源限制

时间限制：1.0s 内存限制：256.0MB

问题描述

杨辉三角形又称Pascal三角形，它的第i+1行是(a+b)^i的展开式的系数。
它的一个重要性质是：三角形中的每个数字等于它两肩上的数字相加。
下面给出了杨辉三角形的前4行：　
1
1 1
1 2 1
1 3 3 1
给出n，输出它的前n行。

输入格式

输入包含一个数n。

输出格式

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

代码

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

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

7.特殊的数字

资源限制

时间限制：1.0s 内存限制：512.0MB

问题描述

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

输出格式

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

代码

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(a*a*a + b*b*b + c*c*c == i){
				System.out.println(i);
			}
		}
	}
}

8.回文数

资源限制

时间限制：1.0s 内存限制：512.0MB

问题描述

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

输出格式

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

代码

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

9.特殊回文数

资源限制

时间限制：1.0s 内存限制：512.0MB

问题描述

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

输入格式

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

输出格式

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

代码

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

public class Main {
	public static void main(String[] agrs) {
		Scanner in = new Scanner(System.in);       
        int n = in.nextInt(); 
		for(int i = 10000;i < 1000000;i++){
			if(i < 100000){
				if((i%10 == i/10000) && (i/10%10 == i/1000%10)){
					if(i%10 + i/10%10 + i/100%10 + i/10000 + i/1000%10 == n){
						System.out.println(i);
					}
				}
			}else{
				if((i%10 == i/100000) && (i/10%10 == i/10000%10) && (i/100%10 == i/1000%10)){
					if(i%10 + i/10%10 + i/100%10 + i/1000%10 + i/100000 + i/10000%10 == n){
						System.out.println(i);
					}
				}
			}
		}
	}
}

10.十进制转十六进制

资源限制

时间限制：1.0s 内存限制：512.0MB

问题描述

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

代码

1
2
3
4
5
6
7
8
9
import java.util.Scanner;

public class Main{
	public static void main(String args[]){
		Scanner in = new Scanner(System.in);
		int n = in.nextInt();
		System.out.printf("%X", n);	
	}
}

11.十六进制转十进制

资源限制

时间限制：1.0s 内存限制：512.0MB

问题描述

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

样例输入

FFFF

样例输出

65535

代码

1
2
3
4
5
6
7
8
9
import java.util.Scanner;

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

12.十六进制转八进制

资源限制

时间限制：1.0s 内存限制：512.0MB

问题描述

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

输入格式

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

输出格式

输出n行，每行为输入对应的八进制正整数。
【注意】
输入的十六进制数不会有前导0，比如012A。
输出的八进制数也不能有前导0。

代码

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
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        char[][] str = new char[n][];
        for (int i = 0; i < n; i++) {
            str[i] = new StringBuilder(in.next()).toString().toCharArray();
        }
        in.close();
        for (int i = 0; i < n; i++) {
            //将十六进制转化为二进制
            String strBinary = toBinary(str[i]);
            int len = strBinary.length();
            //二进制转为八进制是以三个二进制数为一位八进制数
            if (len % 3 == 1) strBinary = "00" + strBinary;
            if (len % 3 == 2) strBinary = "0" + strBinary;
            //将二进制转为八进制
            String strOctal = toOctal(strBinary);
            System.out.println(strOctal);
        }
    }

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

    private static String toOctal(String str){
        StringBuffer strOctal = new StringBuffer();
        int k = 0;
        //这一步的目的是消除转换为八进制后，第一位可能的0
        if(str.substring(0, 3).equals("000"))
            k=3;
        for (int i = k; i < str.length()-2; i += 3) {
            switch (str.substring(i, i + 3)) {
                case "000":
                    strOctal.append("0");
                    break;
                case "001":
                    strOctal.append("1");
                    break;
                case "010":
                    strOctal.append("2");
                    break;
                case "011":
                    strOctal.append("3");
                    break;
                case "100":
                    strOctal.append("4");
                    break;
                case "101":
                    strOctal.append("5");
                    break;
                case "110":
                    strOctal.append("6");
                    break;
                case "111":
                    strOctal.append("7");
                    break;
                default:
                    break;
            }
        }
        return strOctal.toString();
    }
}

13.数列排序

资源限制

时间限制：1.0s 内存限制：512.0MB

问题描述

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

输入格式

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

输出格式

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

代码

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

public class Main{
	public static void main(String arg[]){
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int array[] = new int[n];
        for(int i=0;i<n;i++){
        	array[i] = in.nextInt();
        }
        
        Arrays.sort(array);
        
//        for(int j=0;j<array.length-1;j++){
//        	for(int k=0;k<array.length-1-j;k++){
//        		if(array[k]>array[k+1]){
//            		int temp = array[k];
//            		array[k] = array[k+1];
//            		array[k+1] = temp;
//            	}
//        	}
//        }
        
        for(int i:array){
        	System.out.print(i + " ");
        }
	}
}