一：基础练习：
（本文只附代码，解析后续修改后添上)
1.a+b问题：
代码如下：
1 1 import java.util.*; 2 2 public class Main { 3 3 public static void main(String args[]) { 4 4 int a,b; 5 5 6 6 Scanner input = new Scanner(System.in); 7 7 a = input.nextInt(); 8 8 b = input.nextInt(); 9 9 10 10 System.out.println(a+b); 11 11 } 12 12 }
2.序列排序问题：
代码如下：
1 1 import java.util.Arrays; 2 2 import java.util.Scanner; 3 3 4 4 public class Main { 5 5 public static void main(String[] args) { 6 6 Scanner scanner = new Scanner(System.in); 7 7 int n = scanner.nextInt(); 8 8 int[] arr = new int[n]; 9 9 //往数组添加元素，接收数据 10 10 for (int i = 0; i < n; i++) { 11 11 arr[i] = scanner.nextInt(); 12 12 } 13 13 14 14 //对数组排序 15 15 Arrays.sort(arr); 16 16 17 17 //打印数组 18 18 for (int i = 0; i < n; i++) { 19 19 System.out.print(arr[i] + " "); 20 20 } 21 21 } 22 22 }
3.十六进制转八进制：
代码如下：
1 import java.util.Scanner; 2 public class Main { 3 public static void main(String[] args) { 4 Question1(); 5 6 } 7 public static void Question1() { 8 Scanner in = new Scanner(System.in); 9 int n = Integer.parseInt(in.nextLine()); 10 int i, j; 11 String[] sz = new String[n]; 12 //读入十六进制数 13 for (i = 0; i < n; i++) { 14 sz[i] = in.next(); 15 } 16 for(i = 0; i < sz.length; i++) { 17 String s = sz[i]; 18 StringBuilder sb = new StringBuilder(); 19 //将一位十六进制数转换为四位二进制数 20 for(j = 0; j < s.length(); j++) { 21 switch(s.charAt(j)) { 22 case '0': 23 sb.append("0000"); 24 break; 25 case '1': 26 sb.append("0001"); 27 break; 28 case '2': 29 sb.append("0010"); 30 break; 31 case '3': 32 sb.append("0011"); 33 break; 34 case '4': 35 sb.append("0100"); 36 break; 37 case '5': 38 sb.append("0101"); 39 break; 40 case '6': 41 sb.append("0110"); 42 break; 43 case '7': 44 sb.append("0111"); 45 break; 46 case '8': 47 sb.append("1000"); 48 break; 49 case '9': 50 sb.append("1001"); 51 break; 52 case 'A': 53 sb.append("1010"); 54 break; 55 case 'B': 56 sb.append("1011"); 57 break; 58 case 'C': 59 sb.append("1100"); 60 break; 61 case 'D': 62 sb.append("1101"); 63 break; 64 case 'E': 65 sb.append("1110"); 66 break; 67 case 'F': 68 sb.append("1111"); 69 break; 70 } 71 } 72 //再将二进制数转换成八进制数 73 transform(sb); 74 } 75 76 } 77 public static void transform(StringBuilder sb) { 78 int num = sb.length() % 3; 79 //判断长度是否为3的倍数 80 switch(num) { 81 case 0: 82 //若转换的八进制数中第一位为0则删去 83 if(sb.substring(0, 3).equals("000")) 84 sb.delete(0, 3); 85 break; 86 case 1: 87 if(sb.substring(0, 1).equals("0")) 88 sb.delete(0, 1); 89 else sb = sb.insert(0, "00"); 90 break; 91 case 2: 92 if(sb.substring(0, 2).equals("00")) 93 sb.delete(0, 2); 94 else sb = sb.insert(0, "0"); 95 break; 96 } 97 StringBuilder res = new StringBuilder(); 98 int len = sb.length(); 99 String[] new_s1 = new String[len/3]; 100 //取三位转换成八进制数 101 for(int i = 0; i < len/3; i++) { 102 int tmp = Integer.parseInt(sb.substring(i * 3, i * 3 + 3), 2); 103 res.append(tmp); 104 } 105 System.out.println(res); 106 } 107 }
4.十六进制转十进制：
代码如下：
1 import java.util.Scanner; 2 public class Main { 3 public static void main(String[] args) { 4 Scanner scanner = new Scanner(System.in); 5 String string = scanner.nextLine(); 6 System.out.print(Long.parseLong(string, 16)); 7 } 8 }
5.十进制转十六进制：
代码如下：
1 import java.util.Scanner; 2 public class Main { 3 public static void main(String[] args) { 4 Scanner input = new Scanner(System.in); 5 one(input.nextInt()); 6 7 } 8 9 public static void one(int a){ 10 int b; 11 if(a<=15) { 12 tohax(a); 13 // System.out.print(a); 14 15 } 16 else{ 17 b=a%16; 18 one(a>>4); 19 tohax(b); 20 // System.out.print(b); 21 } 22 } 23 public static void tohax(int c){ 24 switch (c){ 25 default: 26 System.out.print(c); 27 break; 28 29 case 10: 30 System.out.print("A"); 31 break; 32 case 11: 33 System.out.print("B"); 34 break; 35 case 12: 36 System.out.print("C"); 37 break; 38 case 13: 39 System.out.print("D"); 40 break; 41 case 14: 42 System.out.print("E"); 43 break; 44 case 15: 45 System.out.print("F"); 46 break; 47 48 } 49 } 50 }
6.特殊的回文数：
代码如下：
1 import java.util.Scanner; 2 3 public class Main { 4 final static byte one = 1;//常量1. 5 final static byte two = 2;//常量2. 6 final static byte ten = 10;//常量10； 7 8 //输入：正整数n。 9 10 11 //输出：y行，每行为一个回文数。 12 /* 13 * 格式：回文数每个数的和都为n 14 * 从左读和从右读是一样的，所以是关于y轴对称。 15 * 数据大小：10001-999999。n的大小为2-54. 16 * 5位的是2-45，6位的是2-54. 17 * 要求：10进制，五位到六位的所有正整数。 18 * 从小到大输出结果。 19 * */ 20 21 //程序如下： 22 //1.输入正整数n。 23 //2.判断是否是偶数，不是，则说明一定是5位。 24 //3.判断是否小于45，不是，则说明一定是6位。 25 //4.求5位。输出结果 26 //5. 求6位。输出结果 27 public static void main(String[] args) { 28 29 Scanner input = new Scanner(System.in); 30 byte in = input.nextByte(); //获取到输入到2-54的一个正整数。 31 32 if (in % two != 0) { 33 askfive(in);//不是偶数，就只求5位 34 } else if (in > 45) { 35 asksix(in);//大于45，就只求6位。 36 } else {//都不是，就要求5位和6位。 37 askfive(in); 38 asksix(in); 39 } 40 } 41 42 public static void askfive(byte in) { 43 //求5位数。 44 //先确定第一位最小值存不存在。 45 for (int i = one; i <ten ; i++) {//第一位 46 for (int j = 0; j <ten ; j++) {//第二位 47 final int i0 = in - two * i - two * j; 48 if (i0 < ten&&i0>=0) {//求第一位等于第五位，第二位等于第四位，第三位是否满足小于10的要求的数存在。 49 System.out.println(i+""+j+""+i0+""+j+""+i); 50 51 } 52 } 53 } 54 } 55 56 public static void asksix(byte in) { 57 //求6位数。 58 //先确定第一位最小值存不存在。 59 for (int i = one; i <ten ; i++) {//第一位数 60 for (int j = 0; j <ten ; j++) {//第二位数 61 final int i1 = (in - two * i - two * j) / two; 62 if (i1 < ten&&i1>=0) {//第三位数成立 63 System.out.println(i+""+j+""+ i1 +""+ i1 +""+j+""+i); 64 } 65 66 } 67 68 } 69 } 70 71 }
7.回文数：
代码如下：
1 public class Main { 2 3 /* 4 * 输入：无 5 * 输出：回文数 6 * 格式要求：长度是四位的十进制数。关于y轴对此，第一位等于第四位，第二位等于第三位。 7 * 范围是1001-9999. 8 * 要求：从小到大。 9 * */ 10 11 12 //编程思路： 13 //1.从第一位为1，第二位为0，开始循环。 14 //2、输出所有这样的数。 15 16 17 public static void main(String[] args) { 18 for (int i = 1; i <10 ; i++) {//第一位 19 for (int j = 0; j < 10; j++) {//第二位 20 System.out.println(i+""+j+""+j+""+i); 21 } 22 } 23 } 24 }
8.特殊的数字：
代码如下：
1 public class Main { 2 final static byte ten = 10;//常量10； 3 final static byte three = 3;//常量3； 4 5 6 /* 7 * 输入：无 8 * */ 9 10 /* 11 * 输出：n行，三位的十进制 12 * 格式要求：从小到大。 13 * */ 14 15 16 //程序思路： 17 //1、范围是从100-999.而根据立方根来推断，如果从立方根下手，最小要从105（1+125>100)开始循环，最大到962(8+216+729<999) 18 // 2.对三个数循环，求和，判断是否等于自己的10进制。 19 // 3.输出所有相等的数。 20 21 public static void main(String[] args) { 22 for (int i = 105; i <963 ; i++) { 23 int a = i % ten;//个位。 24 int b = (i / ten)%ten;//十位位。 25 int c = i/100 ;//百位。 26 if (i == (Math.pow(a, three) + Math.pow(b, three) + Math.pow(c, three))) { 27 System.out.println(i); 28 } 29 30 31 } 32 33 } 34 35 }
9.杨辉三角：
代码如下：
1 import java.math.BigInteger; 2 import java.util.Objects; 3 import java.util.Scanner; 4 5 public class Main { 6 7 8 /* 9 * 输入：整数n 10 * 格式要求：n的范围是1-34. 11 * */ 12 13 /* 14 * 输出：n行，每一行是杨辉三角的数。 15 * 格式要求，每一行的每个数要按顺序输出，并且要使用一个空格分隔。 16 * */ 17 18 19 //程序思路： 20 //1、输入一个byte大小的数，n 21 //2、根据Cn，循环和递归的方式来求每一行每一个数 22 23 24 public static void main(String[] args) { 25 26 Scanner input = new Scanner(System.in); 27 byte n = input.nextByte();//获取整形n。 28 29 askYh(n); 30 31 } 32 public static void askYh(byte n) {//求杨辉的某行。 33 int b = n-1;//C的下方。 34 if (b == 0) {//说明是第一行 35 System.out.println("1"); 36 } 37 for (int i = 0; i < n; i++) {//n行。 38 for (int j = 0; j <=i; j++) {//对C的上方从0到i循环,注意不能大于i 39 BigInteger out = askJc(i, j) .divide(askJc02(BigInteger.valueOf(i) ,BigInteger.valueOf(j))) ;//实际就是n！/(k!*(n-k)! 40 if (i == j)//二项式最后一位数 41 System.out.print(out); 42 else 43 System.out.print(out + " ");//二项式中间的数。 44 } 45 System.out.println();//换行。 46 } 47 } 48 49 public static BigInteger askJc(int i,int j) {//求b!/i! 50 //先将int，转换为Biginteger类型。 51 BigInteger up = BigInteger.valueOf(j);//上方。 52 BigInteger down = BigInteger.valueOf(i);//下方。 53 54 //递归调用 55 if (down .equals(up .add(BigInteger.valueOf(1))) ) { 56 return down; 57 } 58 if (down .equals(up) ) {//当c的上方和下方相同的时候，返回1. 59 return new BigInteger("1"); 60 } 61 return down.multiply( askJc(down.intValue()-1,up.intValue())); 62 } 63 64 65 public static BigInteger askJc02(BigInteger i, BigInteger j) {//求（i-j）！ 66 BigInteger one = BigInteger.valueOf(1); 67 if ((Objects.equals(i, j.add(one)))||(Objects.equals(i, j))) { //当i-j = 1 或者i=j的时候。 68 return BigInteger.valueOf(1); 69 70 } 71 return (i.subtract(j)) .multiply( askJc02(i.subtract(one) , j) ) ; 72 } 73 }
10.查找整数：
代码如下：
1 import java.util.Scanner; 2 3 public class Main { 4 5 /* 6 * 输入：三行 7 * 第一行，整数n，表示数组个数 8 * 第二行，非负整数数组，大小为0-10000.short类型 9 * 第三行，整数a，为查找的整数。 10 * */ 11 12 /* 13 * 输出：整数c，表示a在数组当中第一次出现的位置 14 * 格式要求：c从1开始编号，取值为-1：表示无。1-n； 15 * */ 16 17 //程序思路： 18 //1.输入n，创建数组。 19 //2.初始化数组。 20 //3.输入整数a，查找a。算法：依次遍历。 21 //4.返回数组下标+1； 22 23 24 public static void main(String[] args){ 25 //1.输入n，创建数组。 26 Scanner input = new Scanner(System.in); 27 int n = input.nextInt();//长度n 28 short[] arrys = new short[n];//数组arrys。 29 30 31 //2.初始化数组。 32 for (int i = 0; i < n; i++) { 33 arrys[i] = input.nextShort(); 34 35 //测试点：测试数组arrys的初始化情况。 36 // System.out.print("测试点一："+"arrys["+i+"]："+arrys[i]+" "); 37 } 38 39 //3.输入整数a。 40 short a = input.nextShort();//查到的对象a。 41 int c = -1;//返回下标的对象，默认初始化为-1. 42 43 //4.查找a，返回下标。 44 for (int i = 0; i < n; i++) { 45 if(arrys[i] == a)//如果数存在。就要跳出并终止循环。 46 { 47 c = i+1;//说明a存在。 48 49 //测试点：测试数组查找的情况。 50 // System.out.println("测试点二：当前a值为："+a+"当前数组内容为："+arrys[i]+"当前下标为："+i); 51 break; 52 } 53 } 54 55 //5.输出下标： 56 System.out.println(c); 57 } 58 }
11.数列特征：
代码如下：
1 import java.util.Scanner; 2 3 public class Main { 4 5 /* 6 * 输出：两行。 7 * 第一行，整数n，数组的长度。范围：1--10000 short类型。 8 * 第二行，n个数，数组的各个值，范围：-10000--10000 short类型。 9 * */ 10 11 /* 12 * 输出：三行。 13 * 第一行，整数，表示数组的最大值。-10000--10000 short类型 14 * 第二行，整数，数组最小值。-10000--10000 short类型 15 * 第三行，整数，数组的和。范围：-1亿--1亿。int类型。 16 * */ 17 18 //程序思路： 19 //1.输入数组长度n，初始化数组。 20 //2.求数组的最大值并打印输出。 21 //3.求数组的最小值并打印输出。 22 //4.求数组的总和并打印输出。 23 24 public static void main(String[] args) { 25 26 //1.输入数组长度n，初始化数组。并求和。 27 Scanner input = new Scanner(System.in); 28 short n = input.nextShort(); //长度n。 29 short[] arrys = new short[n];//数组arrys。 30 int sum = 0; //数组的和。 31 int min = 0;//数组最小值。 32 int max = 0;//数组最大值。 33 34 for (int i = 0; i < n; i++) {//数组初始化。 35 arrys[i] = input.nextShort(); 36 // //测试点一： 37 // System.out.print(arrys[i]+" "); 38 39 sum = sum + arrys[i];//求和。 40 if (i==0)//初始化 41 min = max = arrys[i];//初始化。 42 if (i>0){//比较大小。 43 if (arrys[i]>max) {//如果下一项大于前一项。 44 //测试点二： 45 // System.out.println("测试点二，检查max指针跳转情况："); 46 // System.out.println("arrys:"+arrys[i]+" max："+max); 47 max = arrys[i];//max指针指向下一项。 48 }else if(arrys[i]<min) { 49 //测试点三： 50 // System.out.println("测试点三，检查min指针跳转情况："); 51 // System.out.println("arrys:"+arrys[i]+" min："+min); 52 min = arrys[i];//否则，min指针则指向下一项。 53 } 54 } 55 } 56 57 System.out.println(max); 58 System.out.println(min); 59 System.out.println(sum); 60 61 } 62 }
12.字母图形：
代码如下：
1 import java.util.Scanner; 2 public class Main { 3 4 /* 5 * 输入：一行整数n，整数m。 6 * 格式要求：n（1，m），m（1到26） 7 * */ 8 9 /* 10 * 输出：n行，每行是m个单词，并且有一定规律。 11 * */ 12 13 //程序思路： 14 //1.一维数组，存储26个字母，排序按下标. 15 //2.输入整数n,m. 16 //3.输出n行，m列的元素。 17 //输出n行，每行首元素为当前行数的下标字母，将该元素的前面所有元素输出完毕，再按序输出元素。 18 //每个元素个数为m。 19 20 21 public static void main(String[] args){ 22 //1.一维数组，存储26个字母，排序按下标. 23 char[] arrys = new char[26];//字符数组arrys 24 for (int i = 0; i <26 ; i++) { 25 arrys[i] = (char)(i+65); 26 // System.out.print(arrys[i]+" ");//测试点一：测试字符数组的初始话情况。 27 } 28 29 //2.输入整数n,m 30 Scanner input = new Scanner(System.in); 31 int n = input.nextInt();//行数n 32 int m = input.nextInt();//列数m 33 int counter =0;//计数器。 34 35 //3.打印字符串。 36 for (int i = 0; i <n ; i++) {//行数n 37 counter = i;//计数器 38 39 for (int j = 0; j <m ; j++) {//列数m 40 //第一行： 41 if (i==0){//如果是从头开始 42 System.out.print(arrys[j]); 43 44 //第n行： 45 }else if (counter!=0){ 46 System.out.print(arrys[counter]); 47 counter--;//自减。 48 49 //第n行，第n列。 50 }else 51 System.out.print(arrys[j-i]);//正常输出。 52 } 53 System.out.println();//换行。 54 } 55 } 56 57 }
13.01字串：
代码如下：
1 import java.text.DecimalFormat; 2 3 public class Main { 4 5 6 /* 7 * 输入：无 8 * */ 9 10 11 /* 12 * 输出：32行，5位01字符串。 13 * 格式要求：从小到大，二进制。 14 * */ 15 16 //程序思路： 17 //1.创建byte数组，初始化0-31. 18 //2.遍历数组，并转换成二进制输出。 19 20 public static void main(String[] args){ 21 //1.创建byte数组，初始化0-31. 22 byte[] arrys = new byte[32];//数组arrys。 23 for (byte i = 0; i < 32; i++) { 24 arrys[i] = i;//数组初始化。 25 // System.out.print(arrys[i]);//测试一：测试数组初始化情况。 26 } 27 for (int i = 0; i < 32; i++) { 28 String out = Integer.toBinaryString(arrys[i]);//整形转换成二进制字符串 29 DecimalFormat ft = new DecimalFormat("00000");//格式化工具类。 30 Integer setout = Integer.valueOf(out); 31 // System.out.println(setout); 32 System.out.println(ft.format(setout) ); 33 } 34 } 35 }
14.闰年判断：
代码如下：
1 import java.util.Scanner; 2 public class Main { 3 4 /* 5 * 输入：一行，一个整数y，表示年份 6 * 格式要求：大小范围：1990-2050.short类型。 7 * */ 8 9 /* 10 * 输出：一行，是闰年就yes，不是就no。 11 * */ 12 13 //程序思路： 14 //1.要比较圈圈，很明显是4包括的更大，然后能400 和 不能除100是互斥的 15 //2.输出一个整形。 16 //3.能否被4整除，不能，则明显不是 17 //不能被100整除是闰年 18 //能被400整除是瑞年。 19 20 public static void main(String[] args){ 21 Scanner input = new Scanner(System.in); 22 short year = input.nextShort(); 23 24 if (year % 4 == 0) { 25 //能被4整除，不能被100整除。 26 if (year%100!=0) { 27 System.out.println("yes"); 28 return; 29 } 30 31 //能被4整除，能被400整除。 32 if (year%400==0){ 33 System.out.println("yes"); 34 return; 35 } 36 System.out.println("no"); 37 38 }else System.out.println("no"); 39 } 40 }
15.Fibonacci数列
代码如下：
1 import java.util.Scanner; 2 public class Main { 3 public static void main(String[] args) { 4 int[] a = new int[10000001]; 5 a[1] = 1; 6 a[2] = 1; 7 int n = new Scanner(System.in).nextInt(); 8 for (int i=3; i<=n; i++){ 9 a[i] = (a[i-1]+a[i-2])%10007; 10 } 11 System.out.println(a[n]); 12 } 13 }
16.园的面积：
代码如下：
1 import java.math.BigDecimal; 2 import java.math.RoundingMode; 3 import java.util.Scanner; 4 5 6 public class Main { 7 8 /* 9 * 输入：整数r，表示园的半径。 10 * 格式要求：r的大小（1--1w） int类型 11 * */ 12 13 /* 14 * 输出：一行，实数s，表示园的面积。 15 * 格式要求：四舍五入，保留小数点7位。 float 类型。 16 * */ 17 18 //程序思路： 19 //1.输入园的半径r 20 //2.定义常量pi = atan（1.0）*4. 21 //3.求园的面积，对小数点后面第八位进行四舍五入。 22 //小于5，则第七位不变，输出小数点后7位。 23 //大于等于5，等第七位+1，本质应该是+0.0000001，输出小数点后7位的浮点数。 24 //.输出园的面积s。 25 26 final static double PI =3.14159265358979323;//pi 27 28 public static void main(String[] args) { 29 //1.半径 30 Scanner input = new Scanner(System.in); 31 32 // while (true) { 33 int r = input.nextInt(); 34 35 //2.常量pi，变量面积s。 36 double s = PI * Math.pow(r, 2); 37 // System.out.println(s); 38 39 //3.四舍五入。 40 BigDecimal a = new BigDecimal(PI * Math.pow(r, 2)); 41 42 double sets = a.setScale(7, RoundingMode.HALF_UP).doubleValue(); 43 44 // System.out.println(sets); 45 System.out.println(a.setScale(7, RoundingMode.HALF_UP)); 46 } 47 }
17.序列求和：
代码如下：
1 import java.util.Scanner; 2 3 public class Main { 4 /* 5 * 输入：一行，整数n 6 * 格式要求：取值范围（1--10亿） int 类型。 7 * */ 8 9 /* 10 * 输出：一行，整数sum，表示递增序列的和 11 * 格式要求：取值预计在百亿级别，long类型。 12 * */ 13 14 // 程序思路： 15 // 1.定义常量d，首相a1=1，总和sum。 16 // 2.输入序列长度n 17 // 3.根据公式，求序列的和。 18 19 public static void main(String[] args){ 20 //1.序列n 21 Scanner input = new Scanner(System.in); 22 int n = input.nextInt(); 23 24 //2.常量d，a1； 25 int d =1; 26 int a1=1; 27 long sum; 28 29 //3.求和。 30 sum = n*a1 + (long) d *n*(n-1)/2; 31 System.out.println(sum); 32 33 } 34 }
//未完，待更。。。
//也欢迎各位提出宝贵意见，有则改之无则加勉。