Java基础题50（已全部更新完成）

目录见左边广告之下，涉及到的常用功能函数

1、兔子繁殖问题

package woniu.java50;

import java.util.Scanner;

/*Java50例题
 * 1、兔子繁殖问题--斐波那契数列
 * 条件：1对兔子出生第3个月后开始繁殖，2月后一月一次1对，不死
 * 分析兔子的对数呈现为：1、1、2、3、5、8、13、21*/
public class T_1_tuzi {	
	
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入兔子繁殖的时间（单位：月,类型整数）：");
		int month = scanner.nextInt();
		while (month <= 0) {
			System.out.println("输入不合法，请重新输入：");
			month = scanner.nextInt();
		}
		int pre = fanzhi(month);
		System.out.println(month+"个月后，兔子的对数为："+pre+"对");
		scanner.close();
	}

	private static int fanzhi(int month) {
		// TODO Auto-generated method stub
		int pre_1=1,pre_2=1;
		int pre_n = 0;
		if (month ==1 || month ==2) {
			pre_n = 1;
		}else {
			for (int i = 3; i <= month; i++) {
				pre_n = pre_1+pre_2;
				pre_1 = pre_2;
				pre_2 = pre_n;
			}
		}
		return pre_n;
	}
}

2、101-200之间的素数

package woniu.java50;

/*判断101-200之间有多少个素数，并输出所有素数
 *素数又叫质数，就是除了1和它本身之外，再也没有整数能被它整除的数
 * */
public class T_2_shusu {
	
	public static void main(String[] args) {
		int s=0;//素数个数
		for (int i = 101; i < 201; i++) {
			int k = 0;
			int data[] = new int[30];//定义一个数组，长度为20
//			判断素数并存入数组
			for (int j = 1; j <= i; j++) {								
				if (i%j == 0) {
					while (true) {
						data[k] = j;
						k++;
//						跳出while循环
						break;
					}
				}
			}
//			查看数组元素
/*
 * System.out.println(i+"的因数数组为："); for (int j = 0; j < k; j++)
 * System.out.print(data[j]+" "); System.out.println();
 */
//			判断素数
			if (k == 2) {
				System.out.println(i+"是素数");
				s++;
//				查看因数数组
				/*
				 * for (int j = 0; j < k; j++) System.out.print(data[j]+" ");
				 * System.out.println();
				 */		
			}
		}
		System.out.println("101--200之间一共有"+s+"个素数");
	}
}

3、水仙花

package woniu.java50;
/**
 * 3、打印水仙花数
 * @author 26307
 *水仙花数：3位数，其每一位数的立方和等于其本身
 *范围：100-999
 */
public class T_3_shuixianhuashu {
	
	public static void main(String[] args) {
		for (int i = 100; i < 1000; i++) {
			panduan(i);
		}
	}
	
	private static void panduan(int num) {
		// TODO Auto-generated method stub
		int bai = num/100; //百位数
		int shi = num/10%10; //十位数
		int ge = num%10; //个位数
		if (num == bai*bai*bai + shi*shi*shi + ge*ge*ge) {
			System.out.println(num+"是水仙花数！");
		}
	}
}

4、正整数分解成质因数

package woniu.java50;

import java.util.Scanner;

/**
 * 将一个正整数分解质因数
 * @author 26307
 *eg：90=2*3*3*5
 *条件：
 *1、可以被整除，除数是素数
 *2、循环除，直到成为一个素数
 *素数：只有1和本身两个因子
 *不是：奇数1、偶数（2除外）
 *
 */
public class T_4_zhishu {
	
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入一个正整数：");
		int num = scanner.nextInt();
		int a = num;
		while (num < 0) {
			System.err.println("您输入的是负数，请重新输入一个正整数：");
			num = scanner.nextInt();
			a = num;
		}
		int[] arr = new int[11];
		int key = 0;
		for (int i = 2; i <= num; i++) {
			if (num%i==0 && sushu(i)) {
				num = num/i;
				arr[key] = i;
				key++;
				i = 1;
			}
		}
//		输入的整数为1或者为素数
		if (a==1 || sushu(a)) {
			System.out.println(a+" = "+ a + " * "+" 1 ");
//			退出程序
			System.exit(0);
		}
//		规范输出
		System.out.print(a+" = ");
		for (int i = 0; i < key; i++) {
//			输出前面的质因数
			if (i< key-1) {
				System.out.print(arr[i]+" * ");
//				结束当前循环进入下次循环
				continue;
			}
//			最后一个质因数
			if (i == key-1) {
				System.out.print(arr[i]);
			}
		}
		scanner.close();
	}
	
//	判断素数
	@SuppressWarnings("unused")
	public static boolean sushu(int num) {
		// TODO Auto-generated method stub	
		if (num==2 ) {
//			System.out.println(num+"是素数！");
			return true;
//			排除偶数和1（素数必须>0)
		}else if (num%2==0 || num < 2) {
//			System.out.println(num+"不是素数！");
			return false;
		}else {
//			定理: 如果n不是素数, 则n有满足1< d<=sqrt(n)的一个因子d.
//          证明: 如果n不是素数, 则由定义n有一个因子d满足1< d< n.	
			for (int i = 3; i*i <= num; i += 2) {
//				i+=2:排除偶数
				if (num%i == 0) {
//					System.out.println(num+"不是素数！");
					return false;
				}
//				System.out.println(num+"是素数！");
				return true;
			}
		}
//		System.out.println(num+"是素数！");
		return true;
	}
}

4、简化版本（原网址：java基础50题_Purnell的博客-CSDN博客）

package woniu.java50;
/**
 * 不用考虑素数，在方法f中已经规避了对素数的判定
 */
import java.util.Scanner;

public class T_4_primeNum {
	
	public static int f(int n) {
		for (int i = 2; i < n; i++) {
			if (n%i==0 && n!=i) {
				System.out.print(i+" * ");
				return f(n/i);
			}
		}
		System.out.print(n);
		return n;
	}
	
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入一个正整数：");
		int n = scanner.nextInt();
		System.out.print(n+" = ");
		f(n);
		scanner.close();
	}
}

5、给成绩分等级

package woniu.java50;

import java.util.Scanner;

/**
 * 给输入的成绩分等级
 * @author 26307
 *A:>=90
 *B:89-60
 *C:<60
 *Java默认整除
 */
public class T_5_score {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入您的分数（0~100）：");
		int score = scanner.nextInt();
		while (score>100 || score<0) {
			System.err.println("输入错误，请重新输入百分制的分数：");
			score = scanner.nextInt();
		}
		switch (score/30) {
		case 1:
		case 0:
			System.out.println("您的等级是C");
			break;
		case 2:
			System.out.println("您的等级是B");
			break;
		case 3:
			System.out.println("您的等级是D");
			break;
		default:
			break;
		}
		scanner.close();
	}
}

6、最大公约数和公倍数

package woniu.java50;

import java.util.Scanner;

/**
 * 输入两个正整数找到他们最大公约数和最小公倍数
 * @author 26307
 *公约数：整除两个整数的最大正整数common divisor
 *公倍数：2个整数的共有倍数（第一个可以整除两个整数的正整数）Common multiple
 */
public class T_6_mathBeiUYue {
	
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入两个整数：");
		int a = scanner.nextInt();
		int b = scanner.nextInt();
		while (a<=0 || b<=0) {
			if (a<=0) {
				System.err.println("第一个数输入错误，请重新输入一个正整数：");
				a = scanner.nextInt();
			}
			if (b<=0) {
				System.err.println("第二个数输入错误，请重新输入一个正整数：");
				b = scanner.nextInt();
			}
		}
		int min = commonMultipleMin(a, b);
		int max = commonDivisorMax(a, b);
		System.out.println(a+"和"+b+"的最小公倍数是："+min+",最大公约数是："+max);
		scanner.close();
	}
	
//最小公倍数Common multiple
	public static int commonMultipleMin(int a,int b) {
		int max = a>b?a:b;
		int min = max;
		for (int i = max; i <= a*b; i++) {
			if (i%a==0 && i%b==0) {
				min = i;
				break;
			}
		}
		return min;
	}
	
//	最大公约数common divisor
	public static int commonDivisorMax(int a,int b) {
		int min = a<b?a:b;
		int max = 1;
		for (int i = 2; i < min; i++) {
			if (a%i==0 && b%i==0) {
				max = max>i?max:i;
			}
		}
		return max;
	}
}

7、字符统计

package woniu.java50;

import java.util.Scanner;

/*统计字符个数
 * 描述：输出一行字符，分别统计其英文字母、空格、数字和其他字符的个数
 * charAt():
 * */
public class T_7_characterStatistical {
//	函数中的void表示return返回的数据类型，其中void表示空
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入一行字符串，回车结束输入：");
		String str = scanner.nextLine();
		tongji(str);
		scanner.close();
	}
	private static void tongji(String str) {
		int china = 0;
		int english = 0;
		int number = 0;
		int blank = 0;
		int other = 0;
		for (int i = 0; i < str.length(); i++) {
//			缓存字符
			char ch = str.charAt(i);
//			Unicode表中：中文基础范围：'\u4E00'--'\u9FA5
			if (ch >= '\u4E00' && ch <= '\u9FA5') {
				china++;
			}
//			统计英文字母
			else if (ch >= 'a' && ch <= 'z'||ch >= 'A' && ch <= 'Z') {
				english++;
//			数字
			}else if (ch >= '0' && ch <= '9') {
				number++;
//			空格,ASCII码为32
			}else if (ch == ' ') {
				blank++;
//			其他
			}else {
				other++;
			}
		}
		System.out.println("中文字符有："+china+"个，英文字母有："+english+"个，数字有："+number+"个，空格有："+blank+"个，其他字符有："+other+"个");
		return;	
	}
}

8、求s=a+aa+aaa+aaaa+aa…a的值，其中a是一个数字

package woniu.java50;

import java.util.Scanner;

/**
 * 求解：s = a + aa + aaa + aaaa + aaaaa + ???
 * 加多少由用户设定
 * @author 26307
 *
 */
public class T_8_sum5 {

	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入一个整数（1-9）：");
		int num = scanner.nextInt();
		while (num <= 0 || num > 9 ) {
			System.err.println("第一个数输入错误，请重新输入1-9内的一个整数：");
			num = scanner.nextInt();
		}
		System.out.println("请输入需要相加的数的最大位数（不超过9）：");
		int n = scanner.nextInt();
		while ( n<= 0 || n>9) {
			System.err.println("第二个数输入错误，请重新输入1-9内的一个整数：");
			n = scanner.nextInt();
		}
		System.out.println(sum(num,n));
		scanner.close();
	}
	
	public static int sum(int a,int b) {
		int s = 0;
		int result = 0;
		System.out.print("s = ");
		for (int i = 0; i < b; i++) {
			s = s * 10 + a;
			result += s;
			if (i<b-1) {
				System.out.print(s+" + ");
				continue;
			}
			System.out.println(s);
			System.out.print("  = ");
		}
		return result;
	}
}

随机版

package woniu.java50;

import MyShortcuts.Random;

/**
 * 求解：s = a + aa + aaa + aaaa + aaaaa + ???
 * 加多少由随机设定
 * @author 26307
 *
 */
public class T_8_randomSum {
	
	public static void main(String[] args) {
		int num = Random.randomNuber(1, 9);
		System.out.println("初始数据是："+num);
		int n = Random.randomNumber(1, 9);
		System.out.println("最大位数是："+n);
		System.out.println(sum(num,n));
	}
	
	public static int sum(int a,int b) {
		int s = 0;
		int result = 0;
		System.out.print("s = ");
		for (int i = 0; i < b; i++) {
			s = s * 10 + a;
			result += s;
			if (i<b-1) {
				System.out.print(s+" + ");
				continue;
			}
			System.out.println(s);
			System.out.print("  = ");
		}
		return result;
	}
}

随机函数

package MyShortcuts;
/**
 * 随机生成指定范围的一个随机整数
 * @author 26307
 *
 */
public class Random {
//	随机一个数在指定范围内[a,b]，a<b
//	调用eg : Random.randomNuber(11, 30)
	public static int randomNuber (int a,int b) {
//		向上取整：范围会变小，即[a,b]-->[a+1,b]
//		向下取整
		int num = (int)Math.floor(Math.random()*(b-a+1)+a); 
		return num;
	}
}

9、完数

package woniu.java50;
/**
 *描述：
 *一个数如果恰好等于它的因子之和，这个数就称为”完数”。
 *例如6=1＋2＋3.编程 找出1000以内的所有完数
 * @author 26307
 *求因子：可以整除
 *求和：数组长度未知，相加，求和
 */
public class T_9_wanMeiShu {

	public static void main(String[] args) {
		for (int i = 1; i < 1000; i++) {
			if (i == sum(yinzi(i))) {
				show(i, yinzi(i));
			}
		}
	}
//	求因子
	public static int[] yinzi(int a) {
//		1000以内因子最多的是840，有32个因子（包含840）
		int[] arr = new int[31];
		int k = 0;
		for (int i = 1; i < a; i++) {
//			数组未赋值时存储的数据是0
			if (a%i==0) {
				arr[k] = i;
				k++;
			}
		}
		return arr;
	}
//	求和
	public static int sum(int[] a) {
		int s = 0;
		for (int i = 0; i < a.length; i++) {
			if (a[i]==0) {
				break;
			}
			s += a[i];
		}
		return s;
	}
//	输出因子
	public static void show(int a,int[] b) {
		System.out.print(a+" = ");
		for (int i = 0; i < b.length; i++) {
			if (b[i+1]==0) {
				System.out.print(b[i]);
				break;
			}
//			if (i!=0 && i%6==0) {
//				System.out.println();
//				System.out.print("   ");
//			}
			System.out.print(b[i]+" + ");
		}
		System.out.println();
	}
}

10、球落地反弹

package woniu.java50;

import java.util.Scanner;

/**题目描述：
 * 一球从100米高度自由落下，每次落地后反跳回原高度的一半；
 * 再落下，求它在 第10次落地时，共经过多少米？
 * 第10次反弹多高？
 * @author 26307
 * 解决思路：
 * 1、h = h * 0.5,float
 * 2、函数调用本身
 */
public class T_10_qiuFanTan {
	
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入初始高度（单位：米，>=1）：");
		float h = scanner.nextFloat();
		while (h < 1.0F) {
			System.err.println("输入错误，请重新输入初始高度（单位：米，>1）：");
			h = scanner.nextFloat();
		}
		System.out.println("请输入反弹次数（>=1）：");
		int n = scanner.nextInt();
		while (n < 1) {
			System.err.println("输入错误，请重新输入弹跳次数：");
			n = scanner.nextInt();
		}
		System.out.println("初始高度为"+h+"米时，第"+n+"次反弹高度是："+tanQiu(h, n)+"米");
		scanner.close();
	}
//	弹球
	public static float tanQiu(float h,int n) {
		h = h/2.0F;
		n--;
//		System.out.println("n="+n+", h="+h);
//		省略for循环
		if (n>0) {
			return tanQiu(h, n);
		}else {
			return h;
		}
	}
}

11、1~4组成3位数

package woniu.java50;
/**题目：
 * 有1、2、3、4个数字，能组成多少个互不相同且无重复数字的三位数？
 * 都是多少？
 * 
 * @author 26307
 *解析：
 *4个数字1-4，3位数：3层for循环
 */
public class T_11_numberZuHe {

	public static void main(String[] args) {
		int n = 1;
		for (int i = 1; i < 5; i++) {
			for (int j = 1; j < 5; j++) {
				for (int j2 = 1; j2 < 5; j2++) {
					if (i==j || i==j2 || j==j2) {
						continue;
					}else {
						System.out.println("第"+n+"个三位数是："+i+j+j2);
						n++;
					}
				}
			}
		}
	}
}

12、利润提成

package woniu.java50;

import java.util.Scanner;

/**题目：
 * 企业发放的奖金根据利润提成。利润(I)低于或等于10万元时，奖金可提10%；
 * 利润高于10万元，低于20万元时，低于10万元的部分按10%提成，
 * 高于10万元的部分，可可提成7.5%；20万到40万之间时，高于20万元的部分，
 * 可提成5%；40万到60万之间时高于40万元的部分，可提成3%；
 * 60万到100万之间时，高于60万元的部分，可提成1.5%，
 * 高于100万元时，超过100万元的部分按1%提成，
 * 从键盘输入当月利润I，求应发放奖金总数？
 * 
 * @author 26307
 *解析：
 *1、用户输入利润
 *2、根据利润判断得到奖金
 *利润提成区间
 *1、lr<=10w     0.1     lr*0.1  1
 *2  10w<lr<=20W 0.075  (lr-10)*0.075+1  1+0.75
 *3  20W<lr<=40w 0.05   (lr-20)*0.05+1.75 1.75+1
 *4  40W<lr<=60w 0.03   (lr-40)*0.03+2.75 2.75+0.6
 *5  60W<lr<=100w 0.015   (lr-60)*0.015+3.35 3.35+0.6
 *6  100W<lr  0.01   (lr-100)*0.01+3.95 
 *拓展：
 *利润精确到6位小数
 */
public class T_12_tiChen {

	public static void main(String[] args) {
		Scanner scanner=new Scanner(System.in);
		System.out.println("请输入本月利润（单位：万元）：");
		float lr = scanner.nextFloat();
		while (lr<=0F) {
			System.err.println("利润不能为负数，请重新输入（单位：万元）：");
			lr = scanner.nextFloat();
		}
		System.out.println("本月利润为"+lr+"万元，应发奖金"+tc(lr)+"万元");
		scanner.close();
	}
//	提成
	public static float tc(Float lr) {
		float jiangJin = 0F;
//		100W<lr  0.01   (lr-100)*0.01+3.95 
		if (lr>100F) {
			jiangJin = (lr-100F) * 0.01F + 3.95F;
		}
//		60W<lr<=100w 0.015   (lr-60)*0.015+3.35 3.35+0.6
		if (lr>60F) {
			jiangJin = (lr-60F)*0.015F+3.35F;
		}
//		40W<lr<=60w 0.03   (lr-40)*0.03+2.75 2.75+0.6
		if (lr>40F) {
			jiangJin = (lr-40F)*0.03F+2.75F;
		}
//		20W<lr<=40w 0.05   (lr-20)*0.05+1.75 1.75+1
		if (lr>20F) {
			jiangJin = (lr-20F)*0.05F+1.75F;
		}
//		10w<lr<=20W 0.075  (lr-10)*0.075+1  1+0.75
		if (lr>10F) {
			jiangJin = (lr-10F)*0.075F+1F;
		}
//		lr<=10w     0.1     lr*0.1  1
		if (lr<10F) {
			jiangJin = lr * 0.1F;
		}
		return jiangJin;
	}
}

13、完全平方数

package woniu.java50;
/**题目：
 * 一个整数，它加上100后是一个完全平方数，
 * 再加上168又是一个完全平方数，请问该数是多少？
 * @author 26307
 *解析：
 *使用数学方法：math.sqrt()开平方
 *回答：在int类型范围类只有3个满足该条件的数，即：21 261 1581
 */
public class T_13_sqrt {

	public static void main(String[] args) {
		int number = 1;
//		死循环，结束条件：得到三个满足条件的数
		for (int i = 1;; i++) {
			if (number > 3) {
//				程序停止
				System.exit(0);
			}
			if (isSqrt(i)) {
				System.out.println("第"+number+"个满足条件的数是："+i);
				number++;
			}
		}
	}
	
	public static boolean isSqrt(int n) {
		boolean result = false;
		int n1 = n+100;
		int n2 = n+268;
		int x = (int)Math.sqrt(n1);
		int y = (int)Math.sqrt(n2);
		if (x*x == n1 && y*y == n2) {
			result = true;
		}
		return result;
	}		
}

14、根据日期判断是这年的哪一天

package woniu.java50;

import java.util.Scanner;

/**
 * 题目：输入某年某月某日，判断这一天是这一年的第几天？
 * @author 26307
 * 分析：
 * 闰年：366天  2月29天
 * 平年：365天  2月28天
 * 31天： 1 3 5 7 8 10 12
 * 30天： 4 6 9 11
 * 函数：
 * 1、判断闰年
 *  1）可以被4，但是不能被100整除
 *  2）可以被400整除
 * 2、得到天数
 */
public class T_14_timeYearMonthDay {

	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入年份：");
		int year = scanner.nextInt();
		System.out.println("请输入月份：");
		int mouth = scanner.nextInt();
		System.out.println("请输入号数：");
		int day = scanner.nextInt();
		int dayNumber = dayNumber(year, mouth, day);
		System.out.println(year+"年"+mouth+"月"+day+"日是"+year+"年200的第"+dayNumber+"天");
		scanner.close();
	}
//	判断闰年：
	public static boolean runYear(int year) {
		boolean result = false;
		if ((year%4==0 && year%100!=0) || year%400==0) {
			result = true;
			System.out.println(year+"是闰年");
		}else {
			System.out.println(year+"不是闰年");
		}
		return result;
	}
//	得到天数
	public static int dayNumber(int year, int mouth,int day) {
		int number = 0;
		if (runYear(year) && mouth>2) {
			number++;
		}
		switch (mouth) {
		case 1:
			number += day;
			break;
		case 2:
			number += day+31;
			break;
		case 3:
			number += day+31+28;
			break;
		case 4:
			number += day+31+28+31;
			break;
		case 5:
			number += day+31+28+31+30;
			break;
		case 6:
			number += day+31+28+31+30+31;
			break;
		case 7:
			number += day+31+28+31+30+31+30;
			break;
		case 8:
			number += day+31+28+31+30+31+30+31;
			break;
		case 9:
			number += day+31+28+31+30+31+30+31+31;
			break;
		case 10:
			number += day+31+28+31+30+31+30+31+31+30;
			break;
		case 11:
			number += day+31+28+31+30+31+30+31+31+30+31;
			break;
		case 12:
			number += day+31+28+31+30+31+30+31+31+30+31+30;
			break;
		default:
			break;
		}
		return number;
	}
}

15、3个整数比较大小

package woniu.java50;

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

/**
 * 题目：输入三个整数x,y,z，请把这三个数由小到大输出。
 * @author 26307
 *
 */
public class T_15_shuZiDaXiao {

	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		int[] arr = new int[3];
//		System.out.println("请输入3个整数（空格相隔，回车结束）：");
//		arr[0] = scanner.nextInt();
//		arr[1] = scanner.nextInt();
//		arr[2] = scanner.nextInt();
		for (int i = 0; i < arr.length; i++) {
			System.out.println("请输入第"+(i+1)+"个整数");
			arr[i] = scanner.nextInt();
		}
		int[] arr2 = paiXu(arr);
		System.out.println(Arrays.toString(arr2));
		scanner.close();
	}
//	排序
	public static int[] paiXu(int[] arr) {
//		比较轮数
		for (int i = 0; i < arr.length-1; i++) {
//			比较，升序
			for (int j = 0; j < arr.length-i-1; j++) {
				if (arr[j] > arr[j+1]) {
					int max = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = max;
				}
			}
		}
		return arr;
	}
}

16、乘法表

package woniu.java50;
/**
 * 输出9*9口诀
 * @author 26307
 *
 */
public class T_16_99chengFa {
	public static void main(String[] args) {
		for (int i = 1; i < 10; i++) {
			for (int j = 1; j < i+1; j++) {
				System.out.print(i+" * "+j+" = "+(i*j));
				System.out.print("  ");
			}
			System.out.println();
		}
	}
}

17、猴子吃桃子

package woniu.java50;
/**题目：
 * 猴子吃桃问题：猴子第一天摘下若干个桃子，当即吃了一半，
 * 还不瘾，又多吃了一个 第二天早上又将剩下的桃子吃掉一半，
 * 又多吃了一个。以后每天早上都吃了前一天剩下的一半零一个。
 * 到第10天早上想再吃时，见只剩下一个桃子了。
 * 求第一天共摘了多少。
 * @author 26307
 * 分析：
 * 10天剩下1个
 * 9：（1+1）*2 = n
 * 。。。：（n+1）*2
 */
public class T_17_houZiChiTao {

	public static void main(String[] args) {
		int n = 1;
		for (int i = 10; i > 0; i--) {
			System.out.println("第"+i+"天桃子数量为："+n);
			n = (n+1)*2;
		}
	}
}

18、比赛名单

package woniu.java50;

/**
 * 题目描述；
 * 两个乒乓球队进行比赛，各出三人。甲队为a,b,c三人，乙队为x,y,z三人。
 * 已抽签决定比赛名单。有人向队员打听比赛的名单。
 * a说他不和x比，c说他不和x,z比，请编程序找出三队赛手的名单。
 * @author 26307
 *分析；
 *使用数组进行分组
 *条件：a不和x比赛，c不和x\z比赛-即c只能和y比赛-a、b不能和y比赛
 *
 *分析结果：a-z c-y b-x
 */
public class T_18_abcPKxyz {

	public static void main(String[] args) {
		String[] A = {"a","b","c"};
		String[] B = {"x","y","z"};
		String[][] pk = new String[3][2];
		for (int i = 0; i < A.length; i++) {
			for (int j = 0; j < B.length; j++) {
				if ((A[i] =="a" && B[j] == "x") || (A[i] =="a" && B[j] == "y")) {
					continue;
				}else if ((A[i] == "c" && B[j]=="x") || (A[i] == "c" && B[j]=="z")) {
					continue;
				}else if ((A[i] =="b" && B[j] == pk[0][1])||(A[i] =="b" && B[j] == "y")) {
					continue;
				}else {
					pk[i][0] = A[i];
					pk[i][1] = B[j];
				}
			}
		}
		System.out.println("比赛名单：");
		for (int i = 0; i < pk.length; i++) {
			System.out.println("第"+(i+1)+"组："+pk[i][0]+" pk "+pk[i][1]);
		}
	}
}

19、菱形

package woniu.java50;

import java.util.Scanner;

/**
 * 题目：打印菱形
 * @author 26307
 *分析：菱形
 *行数h必须为奇数，列数l由行数决定
 *最大列数l=h
 *中间行：zh = h/2 +1(整除）
 *1<= h <= zh，即中间行以上：l = 2*h -1
 *hmax>= h >= zh，即中间行以下：l = 2*(h-2(h-zh))-1=2(2*zh-h)-1
 */
public class T_19_lingxing {

	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		int h = 1;
		System.out.println("请输入菱形的对角线长度：（默认为1）");
		h = scanner.nextInt();
		while (h<1 || h%2 == 0) {
			System.err.println("输入错误！对角线长度必须为大于0的奇数，请重新输入：");
			h = scanner.nextInt();
		}
		System.out.println("---------打印菱形-----------");
		lingXing(h);
		scanner.close();
	}
	
	private static void lingXing(int h) {
		int zh = h/2 +1;
		for (int i = 0; i <= h; i++) {
			if (i <= zh) {
				for (int j = 0; j < zh-i; j++) {
					System.out.print("  ");
				}
				for (int j = 0; j < 2*i-1; j++) {
					System.out.print(" *");
				}
			}else {
				for (int j = 0; j < i-zh; j++) {
					System.out.print("  ");
				}
				for (int j = 0; j < 2*(2*zh-i)-1; j++) {
					System.out.print(" *");
				}
			}
			System.out.println();
		}
	}
}

20、分数相加（后面运行数度很慢，数值很大）

package woniu.java50;

import java.util.Arrays;

/**
 * 题目：
 * 有一分数序列：2/1，3/2，5/3，8/5，13/8，21/13…求出这个数列的前20项之和。
 * @author 26307
 *分析：
 *分子：2 3 5 8 13 *** ：规律：从第三个数开始，一个数等于前两个数之和
 *分母：1 2 3 5 8 **** ：规律：从第三个数开始，一个数等于前两个数之和
 *困难：分数相加   数值越界:int--long--double
 *解决：2个分子相加，在和第三个分子相加
 *
 *后面数字较大，加到第11个分数已经达到10位数
 */
public class T_20_fenShuJiaFa {

	public static void main(String[] args) {
		int[] a = new int[20];
		int[] b = new int[20];
		a = guiLv(2,3);
		b = guiLv(1,2);
		System.out.println("分子："+Arrays.toString(a)+",长度"+a.length);
		System.out.println("分母："+Arrays.toString(b)+",长度"+b.length);
		long[] result = new long[2];
		result = addFenShu((long)a[0], a[1], (long)b[0], b[1]);
		for (int i = 2; i < a.length; i++) {
			result = addFenShu(result[0], a[i], result[1], b[i]);
			System.out.println("前"+(i+1)+"个分数相加结果："+result[0]+"/"+result[1]);
		}
//		System.out.println(result[0]+"/"+result[1]);
	}
	
//	分数相加 分子a，分母b
	private static long[] addFenShu(Long a1,int a2,Long b1,int b2) {
		long[] arr = new long[2];
//		找到公倍数
		long gbs = minGBS(b1, b2);
//		找到各自的倍数
		long c1 = gbs/b1;
		long c2 = gbs/b2;
//		相加的分子
		long a3 = a1*c1+a2*c2;
//		化简
		long gys = maxGYS(a3, gbs);
		arr[0] = a3/gys;
		arr[1] = gbs/gys;
		return arr;
	}
	
//	找最小公倍数
	private static long minGBS(Long a,int b) {
		long c = 0;
		long max = a>b?a:b;
		long min = a<b?a:b;
		for (int i = 1; i <= min ; i++) {
			if ((max*i)%min != 0) {
				continue;
			}else {
				c = max*i;
				break;
			}
		}
		return c;
	}
	
//	找最大公因数
	private static long maxGYS(long a,Long b) {
		long c = 1;
		long min = a<b?a:b;
		for (long i = min; i > 0 ; i--) {
			if (a%i==0 && b%i==0) {
				c = i;
				break;
			}else {
				continue;
			}
		}
		return c;
	}

//	规律数组
	private static int[] guiLv(int a,int b) {
		// TODO Auto-generated method stub
		int[] array1 = new int[20];
		array1[0] = a;
		array1[1] = b;
		for (int i = 2; i < 20; i++) {
			array1[i] = array1[i-1] + array1[i-2]; 
		}
		return array1;
	}
}

21、阶乘求和

package woniu.java50;
/**
 * 题目：阶乘求和
 * 求1+2!+3!+…+20!的和
 * @author 26307
 *分析：
 *利用阶乘函数得到阶乘结果，在求和
 *注意位数，20！的结果有19位数
 */
public class T_21_jieChengSum {

	public static void main(String[] args) {
		long sum = 0;
		for (int i = 1; i <= 20; i++) {
			sum += JieCheng(i);
			System.out.println("前"+i+"个数的阶乘之后："+sum);
		}
	}
//	求阶乘
	private static long JieCheng(int a) {
		long result = 1;
		for (int i = 1; i <= a; i++) {
			result = result*i;
		}
		return result;
	}
}

22、递归求阶乘

package woniu.java50;

import java.util.Scanner;

/**
 * 利用递归方法求5!
 * 增加：自己决定求那个数的阶乘，暂定范围0-20
 * @author 26307
 *分析：
 *递归：函数调用自身
 *long只能求到20！，后边可以使用double类型
 */
public class T_22_diGuiJieCheng {

	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入一个正整数（0-20）：");
		int a = scanner.nextInt();
		while (a<0 || a>30) {
			System.err.println("输入参数不合法，请重新输入（0-20）内的整数：");
			a = scanner.nextInt();
		}
		if (a==0) {
			System.out.println("0!=1");
		}else {
			System.out.println(a+"!="+DGJC(a, 1));
		}
		scanner.close();
	}
//	递归函数
	private static long DGJC(int a,long b) {
		if (a>0) {
			b = b*a;
			 a--;
			 return DGJC(a, b);
		} else {
			return b;
		}
		
	}
}

23、5个人的年龄

package woniu.java50;
/**
 * 题目：
 * 有5个人坐在一起，问第五个人多少岁？他说比第4个人大2岁。
 * 问第4个人岁数，他说比第3个人大2岁。问第三个人，又说比第2人大两岁。
 * 问第2个人，说比第一个人大两岁。最后问第一个人，他说是10岁。
 * 请问第五个人多大？
 * @author 26307
 *分析：
 *5比4大2岁，4比3大2岁，3比2大2岁，2比1大2岁，1号10岁
 *分别输出5个人的年龄
 */
public class T_23_5NingLing {

	public static void main(String[] args) {
		int a = 10;
		for (int i = 1; i < 6; i++) {
			System.out.println("第"+i+"个人的年龄是"+a+"岁。");
			a+=2;
		}
	}
}

24、随机生成一个8位数以内的多位数，输出是几位数，并倒序输出每一位数上的数字

package woniu.java50;

import java.util.Arrays;

/**
 * 题目：随机生成一个8位数以内的多位数，输出是几位数，并倒序输出每一位数上的数字
 * @author 26307
 *
 */
public class T_24_randomDuoWeiShu {

	public static void main(String[] args) {
		int a = randomNuber(1, 99999999);
		System.out.println("随机生成的多位数是："+a+",它的位数是"+JiWeiShu(a));
		int[] arr = new int[JiWeiShu(a)];
		arr = ShuChu(JiWeiShu(a), a);
		System.out.println("倒序输出每一位数上的数字："+Arrays.toString(arr));
	}
	
//	随机生成多位数
	private static int randomNuber (int a,int b) {
//		向上取整：范围会变小，即[a,b]-->[a+1,b]
//		向下取整
		int num = (int)Math.floor(Math.random()*(b-a+1)+a); 
		return num;
	}
	
//	判断是多少位数
	private static int JiWeiShu(int a) {
		int b = 0;
		if (a>9999999) {
			b=8;
		}else if (a>999999) {
			b=7;
		}else if (a>99999) {
			b=6;
		}else if (a>9999) {
			b=5;
		}else if (a>999) {
			b=4;
		}else if (a>99) {
			b=3;
		}else if (a>9) {
			b=2;
		}else {
			b = 1;
		}
		return b;
	}
//	倒序输出每个位上的数值
	private static int[] ShuChu(int a,int b) {
		int[] arr=new int[a];
		switch (a) {
		case 8:
			arr[7] = b/10000000;
		case 7:
			arr[6] = b/1000000%10;
		case 6:
			arr[5] = b/100000%10;
		case 5:
			arr[4] = b/10000%10;
		case 4:
			arr[3] = b/1000%10;
		case 3:
			arr[2] = b/100%10;
		case 2:
			arr[1] = b/10%10;
		case 1:
			arr[0] = b%10;
		default:
			break;
		}
		return arr;
	}
}

25、随机生成一个多位数（1~5位数），判断是否是回文数

package woniu.java50;
/**题目：
 * 随机生成一个5位数以内的多位数，判断它是否是回文数。
 * @author 26307
 *分析：
 *1、回文数必须两边从中间隔开，两边一致，即11，121等
 *2、需要根据位数判断回文数
 */
public class T_25_huiWenShu {

	public static void main(String[] args) {
		int a = randomNuber(1,99999);
		if (0<=a && a<=9) {
			System.out.println(a+"是回文数！");
		}else {
			int b = JiWeiShu(a);
			int[] arr = new int[b];
			arr = ShuChu(b, a);
			PanDuanHuiWenShu(b,arr ,a);
		}
	}
//	随机生成多位数
	private static int randomNuber (int a,int b) {
//		向上取整：范围会变小，即[a,b]-->[a+1,b]
//		向下取整
		int num = (int)Math.floor(Math.random()*(b-a+1)+a); 
		return num;
	}
	
//	判断是多少位数
	private static int JiWeiShu(int a) {
		int b = 0;
		if (a>9999) {
			b=5;
		}else if (a>999) {
			b=4;
		}else if (a>99) {
			b=3;
		}else {
			b=2;
		}
		return b;
	}
//	倒序输出每个位上的数值,参数a位数，b数值
	private static int[] ShuChu(int a,int b) {
		int[] arr=new int[a];
		switch (a) {
		case 5:
			arr[4] = b/10000%10;
		case 4:
			arr[3] = b/1000%10;
		case 3:
			arr[2] = b/100%10;
		case 2:
			arr[1] = b/10%10;
		case 1:
			arr[0] = b%10;
		default:
			break;
		}
		return arr;
	}
//	判断回文数，参数：位数a，每个位上的数字数组arr，原数字b。
	private static void PanDuanHuiWenShu(int a,int[] arr,int b) {
		switch (a) {
		case 2:
			if (arr[0]==arr[1]) {
				System.out.println(b+"是回文数！");
			}else {
				System.out.println(b+"不是回文数！");
			}
			break;
		case 3:
			if (arr[0]==arr[2]) {
				System.out.println(b+"是回文数！");
			}else {
				System.out.println(b+"不是回文数！");
			}
			break;
		case 4:
			if (arr[0]==arr[3] && arr[1]==arr[2]) {
				System.out.println(b+"是回文数！");
			}else {
				System.out.println(b+"不是回文数！");
			}
			break;
		case 5:
			if (arr[0]==arr[4] && arr[1]==arr[3]) {
				System.out.println(b+"是回文数！");
			}else {
				System.out.println(b+"不是回文数！");
			}
			break;
		default:
			break;
		}
	}
}

26、根据首字母或者前两个字母判断是周几

package woniu.java50;

import java.util.Scanner;

/**
 * 题目：
 * 请输入星期几的第一个字母来判断一下是星期几，如果第一个字母一样，则继续 判断第二个字母。
 * @author 26307
 *分析：
 *周一到周日的英文分别是：Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday
 *注意：	string类型比较是否相等时不能使用“==”，只能使用equals（）进行内容比较，string只是表示地址
 */
public class T_26_zhouJi {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入查询周几的首字母：");
		String a = scanner.next();
		while (!(a.equals("m")||a.equals("M"))&&!(a.equals("t")||a.equals("T"))&&!(a.equals("w")||a.equals("W"))&&
				!(a.equals("f")||a.equals("F"))&&!(a.equals("s")||a.equals("S"))) {
			System.err.println("输入超出范围，请重新输入：(m,t,w,f,s)");
			a= scanner.next();
		}
		if (a.equals("t")||a.equals("T")) {
			System.out.println("请输入第二个字母辅助判断：");
			String b = scanner.next();
			while (!(b.equals("u")||b.equals("U"))&&!(b.equals("h")||b.equals("H"))) {
				System.err.println("输入超出范围，请重新输入：(h,u)");
				b = scanner.next();
			}
			if (b.equals("u")||b.equals("U")) {
				System.out.println(a+b+"表示周2");
			}else {
				System.out.println(a+b+"表示周4");
			}
		}else if (a.equals("s")||a.equals("S")) {
			System.out.println("请输入第二个字母辅助判断：");
			String b = scanner.next();
			while (!(b.equals("u")||b.equals("U"))&&!(b.equals("a")||b.equals("A"))) {
				System.err.println("输入超出范围，请重新输入：(a,u)");
				b = scanner.next();
			}
			if (b.equals("u")||b.equals("U")) {
				System.out.println(a+b+"表示周日");
			}else {
				System.out.println(a+b+"表示周6");
			}
		}else if (a.equals("m")||a.equals("M")) {
			System.out.println(a+"表示周1");
		}else if (a.equals("w")||a.equals("W")) {
			System.out.println(a+"表示周3");
		}else 
			System.out.println(a+"表示周5");
		scanner.close();
	}
}

27、100以内的素数

package woniu.java50;
/**
 * 题目：
 * 求100以内的素数
 * @author 26307
 *分析：
 *素数：范围>1的正整数，除了1和它本身之外没有另外的因数
 *判断依据：只需被 2 ~  根号m之间的每一个整数去除就可以了。如果 m 不能被 2 ~ 根号m 间任一整数整除，m 必定是素数。
 *原因：因为如果 m 能被 2 ~ m-1 之间任一整数整除，其二个因子必定有一个小于或等于根号m ，另一个大于或等于 根号m。
 *例如 16 能被 2、4、8 整除，16=2*8，2 小于 4，8 大于 4，16=4*4，4=√16，因此只需判定在 2~4 之间有无因子即可。
 *使用这种方法不能说明2，3也是素数，因此需要进一步优化
 */
public class T_27_suShu {
	public static void main(String[] args) {
		for (int i = 2; i <= 100; i++) {
			if (PanDuanSuShu(i)) {
				System.out.println(i+"是素数");
			}
		}
	}
	
//	判断素数
	private static boolean PanDuanSuShu(int a) {
		boolean t = false;
//		强制转化，将double转化为int，省略小数部分
		int b =(int) Math.sqrt(a);
		for (int i = 1; i <= b; i++) {
			if (a%i!=0||i==1) {
				t = true;
				continue;
			}else {
				t = false;
				break;
			}
		}
		return t;
	}
}

28、10个整数进行排序

package woniu.java50;

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

/**
 * 题目：
 * 输入10个整数进行排序
 * @author 26307
 *分析：
 *采用数组进行降序和升序排列
 */
public class T_28_paiXu {

	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入10个整数进行排序：");
		int[] a = new int[10];
		for (int i = 0; i < a.length; i++) {
			System.out.print("请输入第"+(i+1)+"个整数：");
			a[i]=scanner.nextInt(); 
		}
		System.out.println("升序："+Arrays.toString(shengXu(a)));
		System.out.println("降序: "+Arrays.toString(jiangXu(a)));
		scanner.close();
	}
	
//	升序
	private static int[] shengXu(int[] arr) {
//		轮数
		for (int i = 0; i < arr.length-1; i++) {
//			排序
			for (int j = 0; j < arr.length-1-i; j++) {
				if (arr[j]>arr[j+1]) {
					int max = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = max;
				}
			}
		}
		return arr;
	}
	
//	降序
	private static int[] jiangXu(int[] arr) {
//		轮数
		for (int i = 0; i < arr.length-1; i++) {
//			排序
			for (int j = 0; j < arr.length-1-i; j++) {
				if (arr[j]<arr[j+1]) {
					int min = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = min;
				}
			}
		}
		return arr;
	}
}

29、求矩阵对角线之和

package woniu.java50;

import java.util.Scanner;
import java.util.concurrent.TimeUnit;

/**
 * 题目：
 * 求一个3*3矩阵对角线元素之和
 * @author 26307
 *分析：
 *采用二维素组存储矩阵
 *对角线有2条：即11、22、33和31、22、13
 *注意：统一循环中不允许出现两次同类型的键盘输入获取指令，即nextint等
 *即后边键盘输入的内容尽量放在主函数之中
 */
public class T_29_juZhenDuiJiaoSum {

	public static void main(String[] args) throws InterruptedException {
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入矩阵的规格（m*m）,范围[2,5]：");
		int m = scanner.nextInt();
		while (m<2||m>6) {
			System.err.println("输入的规格超出范围[2,5]，请重新输入：");
			m = scanner.nextInt();
		}
		int[][] arr = new int[m][m];
		arr = GetJuZhen(m);
		TimeUnit.SECONDS.sleep(1);
		System.out.println("-------------操作选项------------");
		System.out.println("    选择1：求左下对角线的之和；");
		System.out.println("    选择2：求左上对角线的之和；");
		System.out.println("    选择3：求两条对角线的之和；");
		System.out.println("请输入选项（1-3）：");
		String k = scanner.next();
		while (!k.equals("1") && !k.equals("3") && !k.equals("3") ) {
			System.err.println("输入选项不正确，请重新输入（1-3）：");
			k = scanner.next();
		}
		int sum = DuiJiaoXianSum(arr, k);
		System.out.println("您输入的选项是："+k+",它的和是："+sum);
		scanner.close();
	}
	
//	画矩阵
	private static int[][] GetJuZhen(int a) {
		// TODO Auto-generated method stub
		Scanner ascanner = new Scanner(System.in);
		int[][] arr = new int[a][a];
		System.out.println("输入"+a+"*"+a+"矩阵的每一个元素,回车结束：");
		for (int i = 0; i < a; i++) {
			for (int j = 0; j < a; j++) {
				System.out.print("请输入位置为"+(i+1)+(j+1)+"的元素：");
				arr[i][j]= ascanner.nextInt(); 
			}
		}
		System.out.println("--------输出输入的"+a+"*"+a+"矩阵---------");
		System.out.println("矩阵arr = ");
		for (int i = 0; i < arr.length; i++) {
			System.out.print("          | ");
			for (int j = 0; j < arr.length; j++) {
				System.out.print("  "+arr[i][j]+"  ");
			}
			System.out.println(" |");
		}
		System.out.println("------------------------------------------");
//		这里不能提前关闭控制，后面还需从键盘获取内容
//		ascanner.close();
		return arr;
	}
	
//	对角线元素相加
	private static int DuiJiaoXianSum(int[][] a,String k) {
		// TODO Auto-generated method stub
		int sum = 0;
		if (k.equals("1")) {
			for (int i = 0; i < a.length; i++) {
				sum += a[i][i];
			}
		}else if (k.equals("2")) {
			for (int i = 0; i < a.length; i++) {
				sum += a[i][a.length-1-i];
			}
		}else {
			for (int i = 0; i < a.length; i++) {
				sum += a[i][i]+a[i][a.length-1-i];
			}
		}
		return sum;
	}
}

30、插入一个数后按照原数组的顺序进行排序

package woniu.java50;

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

/**
 * 题目：
 * 有一个已经排好序的数组。现输入一个数，要求按原来的规律将它插入数组中。
 * @author 26307
 *分析：
 *建立2个数组，一个是排序好的数组，一个是空白数组
 *优化：
 *自动生成一个指定范围内的随机数组，然后根据指令进行排序
 *扫描排序后的数组得到顺序，然后根据顺序将插入的数放在合适的位置
 */
public class T_30_chaRuArray {
	public static void main(String[] args) {
		Scanner aScanner = new Scanner(System.in);
		System.out.println("-----------------------------创建原数组--------------------------------");
		System.out.println("请输入数组长度(>0,整数)：");
		int l = aScanner.nextInt();
		while (l<1) {
			System.err.println("输入错误，请输入一个正整数：");
			l = aScanner.nextInt();
		}
		System.out.println("请输入数组指定范围，闭区间，前者必须大于后者：");
		int a = aScanner.nextInt();
		int b = aScanner.nextInt();
		while (a>b) {
			System.err.println("您输入的第一个数为"+a+"，后面的数必必须大于"+a+",请重新输入第二个数：");
			b = aScanner.nextInt();
		}
		int[] arr1 = new int[l];
		for (int i = 0; i < l; i++) {
//			自己写的快捷功能
			arr1[i] = MyShortcuts.Random.randomNumber(a, b);
//			原码如下：
/**
 * //	随机一个数在指定范围内[a,b]，a<b
//	调用eg : Random.randomNuber(11, 30)
	public static int randomNumber (int a,int b) {
//		向上取整：范围会变小，即[a,b]-->[a+1,b]
//		向下取整
		int num = (int)Math.floor(Math.random()*(b-a+1)+a); 
		return num;
	}
 */
		}
		System.out.println("原数组为："+Arrays.toString(arr1));
		System.out.println("---------------------------排序----------------------------------");
		System.out.println("请输入排序选项：1升序，2降序");
		int key = aScanner.nextInt();
		while (key!=1&&key!=2) {
			System.err.println("输入选项错误，请重新输入（1/2）：");
			key = aScanner.nextInt();
		}
		int[] arr2 = new int[l];
		if (key==1) {
//			自己写的快捷功能
			arr2 = MyShortcuts.arrayPaiXu.shengXu(arr1);
			System.out.println("升序输出："+Arrays.toString(arr2));
/**源代码如下：
 * //	升序
	public static int[] shengXu(int[] arr) {
//		轮数
		for (int i = 0; i < arr.length-1; i++) {
//			排序
			for (int j = 0; j < arr.length-1-i; j++) {
				if (arr[j]>arr[j+1]) {
					int max = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = max;
				}
			}
		}
		return arr;
	}
 */
		}else {
//			自己写的快捷功能			
			arr2 = MyShortcuts.arrayPaiXu.jiangXu(arr1);
/**源代码如下：
 * //	降序
	public static int[] jiangXu(int[] arr) {
//		轮数
		for (int i = 0; i < arr.length-1; i++) {
//			排序
			for (int j = 0; j < arr.length-1-i; j++) {
				if (arr[j]<arr[j+1]) {
					int min = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = min;
				}
			}
		}
		return arr;
	}
 */
			System.out.println("降序输出："+Arrays.toString(arr2));
		}
		System.out.println("------------------------------插入数字并排序-------------------------------");
		int[] arr3 = new int[l+1];
		System.out.println("请输入你要插入的数字（整数）：");
		arr3[0] = aScanner.nextInt();
		for (int i = 1; i < arr3.length; i++) {
			arr3[i]= arr2[i-1]; 
		}
		int jg = JianCha(arr2);
		if (jg==1) {
			System.out.println("原数组是升序排序的，插入的数字是"+arr3[0]);
			System.out.println("升序输出插入后的新数组："+Arrays.toString(MyShortcuts.arrayPaiXu.shengXu(arr3)));
		}else if (jg==2) {
			System.out.println("原数组是降序排序的，插入的数字是"+arr3[0]);
			System.out.println("降序输出插入后的新数组："+Arrays.toString(MyShortcuts.arrayPaiXu.jiangXu(arr3)));
		}else {
			System.out.println("原数组内所有的元素都相同，插入的数字是"+arr3[0]);
			System.out.println("采用升序输出插入后的新数组："+Arrays.toString(MyShortcuts.arrayPaiXu.shengXu(arr3)));
		}
		aScanner.close();
	}
//	检查数组顺序,降序2，升序1,数组中所有元素相等0
	private static int JianCha(int[] arr) {
		// TODO Auto-generated method stub
		int jg = 0;
		if (arr[0] > arr[arr.length-1]) {
			jg = 2;
		}else if (arr[0] == arr[arr.length-1]) {
			jg = 0;
		}else {
			jg = 1;
		}
		return jg;
	}
}

31、数组排序

package woniu.java50;
import java.util.Arrays;
/**
 * 题目：数组排序
 * 优化：
 * 自动生成一个数组，由用户决定长度、元素取值范围，并且决定排序顺序
 */
import java.util.Scanner;

public class T_31_arrayPaiXu {
	public static void main(String[] args) {
		System.out.println("------------生成随机数组------------");
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入数组长度(>1的整数)：");
		int l = scanner.nextInt();
		while (l<2) {
			System.err.println("输入长度小于1，请重新输入(>1的整数)：");
			l = scanner.nextInt();
		}
		int[] arr1 = new int[l];
		System.out.println("请输入数组元素取值范围（整数，空格相隔开，回车结束）：");
		int a = scanner.nextInt();
		int b = scanner.nextInt();
		while (a>b) {
			System.err.println("您输入的第一个数"+a+"大于第二个数"+b+",请重新输入第二个数：");
			b = scanner.nextInt();
		}
		for (int i = 0; i < arr1.length; i++) {
			arr1[i]= MyShortcuts.Random.randomNumber(a, b); 
		}
		if (a==b) {
			System.out.println("您输入的数组的所有元素都相等，无需排序，其为"+Arrays.toString(arr1));
			System.exit(0);
		}
		System.out.println("原数组为："+Arrays.toString(arr1));
		System.out.println("--------------------数组排序-------------------------");
		System.out.println("排序选项：1、升序；2、降序");
		System.out.println("请输入您的选择：");
		int k = scanner.nextInt();
		while (k!=1&&k!=2) {
			System.err.println("输入选项错误，请重新输入（1/2）：");
			k = scanner.nextInt();
		}
		if (k==1) {
			System.out.println("您选择的是升序，其结果为："+Arrays.toString(ShengXu(arr1)));
		}else {
			System.out.println("您选择的是降序，其结果为："+Arrays.toString(JiangXu(arr1)));
		}
		scanner.close();
	}
	
//	升序排序
	private static int[] ShengXu(int[] arr) {
		// TODO Auto-generated method stub
		for (int i = 0; i < arr.length; i++) {
			for (int j = 0; j < arr.length-1-i; j++) {
				if (arr[j]>arr[j+1]) {
					int a = arr[j];
					arr[j]= arr[j+1];
					arr[j+1] = a;
				}
			}
		}
		return arr;
	}
	
//	降序排序
	private static int[] JiangXu(int[] arr) {
		// TODO Auto-generated method stub
		for (int i = 0; i < arr.length; i++) {
			for (int j = 0; j < arr.length-1-i; j++) {
				if (arr[j]<arr[j+1]) {
					int a = arr[j];
					arr[j]= arr[j+1];
					arr[j+1] = a;
				}
			}
		}
		return arr;
	}
}

32、取一个多位数（7位到9位）其中的任意位上的数值

package woniu.java50;

import java.util.Scanner;

/**
 * 
 * @author 锋
 * @data 2021年9月7日
 * 题目：取一个整数a从右端开始的4～7位。
 * 分析：
 * 1、整数至少要达到7位数
 * 2、从右端开始4~7位即千、万、十万、百万
 * 优化：
 * 1、随机生成一个1000000~999999999即7位数到9位数
 * 2、用户决定所取位数的区间并
 */
public class T_32_quWeiShu {
	public static void main(String[] args) {
//		产生随机数值并判断它是几位数
		int num = MyShortcuts.Random.randomNumber(1000000, 999999999);
		int l = MyShortcuts.math.JiWeiShu(num);
		System.out.println("产生的随机数是："+num+",它是"+l+"位数。");
//		确定取值区间
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入需要取值的位数区间（1-"+l+"，前者小于后者):");
		int a = scanner.nextInt();
		int b = scanner.nextInt();
		
		while (a<1||a>l) {
			System.err.println("输入的第一个数值是"+a+",超出范围1-"+l+",请重新输入：");
			a = scanner.nextInt();
		}
		while (b<1||b>l) {
			System.err.println("输入的第二个数值是"+b+",超出范围1-"+l+",请重新输入：");
			b = scanner.nextInt();
		}
		while (a>b) {
			System.err.println("输入的第一个数大于第二个数，系统自动将大小互换。");
			int c=a;
			a=b;
			b=c;
		}
//		获取每个位数上的数值
		int[] arr1 = new int[l];
		arr1 = MyShortcuts.math.ShuChuWeiShu(l, num);
		System.out.print("选中区间["+a+","+b+"]的数值是：");
		for (int i = b-1; i >= a-1; i--) {
			System.out.print(arr1[i]);
		}
		switch (a) {
		case 1:
			System.out.println("(个)");
			break;
		case 2:
			System.out.println("(十)");
			break;
		case 3:
			System.out.println("(百)");
			break;
		case 4:
			System.out.println("(千)");
			break;
		case 5:
			System.out.println("(万)");
			break;
		case 6:
			System.out.println("(十万)");
			break;
		case 7:
			System.out.println("(百万)");
			break;
		case 8:
			System.out.println("(千万)");
			break;
		case 9:
			System.out.println("(亿)");
			break;
		default:
			break;
		}
		scanner.close();
	}
	
}

33、杨辉三角形

package woniu.java50;

import java.util.Scanner;

/**
 * 
 * @author 锋
 * @data 2021年9月8日
 * 题目：杨辉三角形
 * 分析：
 * 1、每一行上的数字和行数一致
 * 2、前两行都为1
 * 3、除前两行意外，每行首尾数字都为1，中间数字为上行两个邻近数之和
 * 优化：
 * 1、自设定杨辉三角形的层数和形状（直角或者等腰）
 */
public class T_33_yangHuiSanJiaoXing {

	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入杨辉三角形的最大层数（[1,24]的整数）： ");
		int n = scanner.nextInt();
		while (n<1||n>24) {
			System.err.println("您输入的是:"+n+"不在[1,24]内，请重新输入杨辉三角形的最大层数([1,24]的整数)：");
			n = scanner.nextInt();
		}
		System.out.println("请选择杨辉三角形的形状：   1、直角三角形；2、等腰三角形；3、两种都输出");
		int k = scanner.nextInt();
		while (k<1||k>3) {
			System.err.println("你输入的选项是:"+k+",没有这个选项，请重新输入（1-3）：");
			k = scanner.nextInt();
		}
		DaYingYangHuiSJX(n, k);
		scanner.close();
	}
//	生成杨辉三角形,层数n在[1,24]内,直角三角形
	private static void YangHuiRt(int n) {
		for (int i = 0; i < n; i++) {
			int num = 1;
			for (int j = 0; j < i+1; j++) {
				System.out.format("%9d", num);
				num = num * (i -j)/(j+1);
			}
			System.out.println();
		}
	}
	
//	生成杨辉三角形,层数n在[1,24]内,等腰三角形
	private static void YangHuiDy(int n) {
		for (int i = 0; i < n; i++) {
			int num = 1;
//			打印空白
			System.out.format("%"+((n-i)*5)+"s"," ");
			for (int j = 0; j < i+1; j++) {
				System.out.format("%10d", num);
				num = num * (i -j)/(j+1);
			}
			System.out.println();
		}
	}
//	打印杨辉三角形,层数n，选项k：1、直角三角形；2、等腰三角形；3、两种都输出
	private static void DaYingYangHuiSJX(int n,int k) {
		// TODO Auto-generated method stub
		System.out.println("---------------------打印杨辉三角形---------------------------");
		switch (k) {
		case 1:
			System.out.println("您打印的是直角三角形的杨辉三角形：");
			YangHuiRt(n);
			break;
		case 2:
			System.out.println("您打印的是等腰三角形的杨辉三角形：");
			YangHuiDy(n);
			break;
		case 3:
			System.out.println("这是直角三角形的杨辉三角形：");
			YangHuiRt(n);
			System.out.println("----------------------------------------------------------");
			System.out.println("这是等腰三角形的杨辉三角形：");
			YangHuiDy(n);
			break;

		default:
			break;
		}
	}
}

34、输入一串数字比较大小

package woniu.java50;

import java.util.Scanner;

/**
 * 
 * @author 锋
 * @data 2021年9月8日
 * 题目：输入3个整数a,b,c，按大小顺序输出。
 * 分析：将输入的数存储到数组中，进行数组排序
 * 优化：采用数组录入整数，然后利用数组进行排序
 * 用到的快捷功能请参考网址：https://blog.csdn.net/qq_43177828/article/details/120166877
 */
public class T_34_abcBiDaXiao {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入比较大小的整数个数(>=2的整数）：");
		int n = scanner.nextInt();
		while (n<2) {
			System.err.println("您输入的数是"+n+",无法进行大小比较，请重新输入(>=2的整数）：");
			n = scanner.nextInt();
		}
		int[] arr = new int[n];
		System.out.println("请输入需要比较大小的整数：");
		for (int i = 0; i < n; i++) {
			System.out.println("请输入第"+(i+1)+"个整数：");
			arr[i]=scanner.nextInt();
		}
		System.out.println("请选择排序方式： 1、升序；2、降序；3、两种方式");
		int key = scanner.nextInt();
		while (key<1||key>3) {
			System.err.println("您输入的是"+key+",不在规定范围[1,3]内，请重新输入：");
			key = scanner.nextInt();
		}
		MyShortcuts.array.PaiXuWay(arr, key,true);
		scanner.close();
	}
}

35、找到一个数组的最大值和最小值并分别交换到首尾位置

package woniu.java50;

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

/**
 * 
 * @author 锋
 * @data 2021年9月8日
 * 用到的快捷功能请参考网址：https://blog.csdn.net/qq_43177828/article/details/120166877
 * 题目：
 * 输入数组，最大的与第一个元素交换，最小的与最后一个元素交换，输出数组。
 * 分析：
 * 1、找到一个数组中的最大和最小值，然后分别放置在数组的首尾
 * 优化：
 * 1、自定义数组长度
 * 2、随机生成指定范围内的数组元素
 */
public class T_35_JianDanArray {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入数组的长度(>=2的整数):");
		int n = scanner.nextInt();
		while (n<2) {
			System.err.println("您输入的数组长度为:"+n+"，不符合要求，请重新输入(>=2的整数):");
			n = scanner.nextInt();
		}
		System.out.println("请输入数组元素的取值范围（2个整数，以空格隔开，回车结束）：");
		int a = scanner.nextInt();
		int b = scanner.nextInt();
		if (a>b) {
			int c = a;
			a=b;
			b=c;
		}
		int[] arr = new int[n];
		arr = MyShortcuts.Random.ArrayInt(n, a, b);
		if (a==b) {
			System.out.println("其最大最小值皆为"+a+",已经符合要求无需改变。");
			System.out.println("该数组为："+Arrays.toString(arr));
		}else {
			System.out.println("输出生成的随机数组："+Arrays.toString(arr));
			System.out.println("输出交换好的随机数组："+Arrays.toString(PaiXu(arr)));
		}
		scanner.close();
	}

//	将指定数组的最大值交换到首位，最小值交换到末位
	private static int[] PaiXu(int[] a) {
		int max=a[0],min=a[0];
		int maxi=0,mini=0;
		for (int i = 1; i < a.length; i++) {
			if (a[i]>max ) {
				max = a[i];
				maxi=i;
			}
			if (a[i]<min) {
				min = a[i];
				mini=i;
			}
		}
		a[maxi]=a[0];
		a[0]=max;
		a[mini]=a[a.length-1];
		a[a.length-1] = min;
		return a;
	}
}

36、有n个整数，将最后m个数移到最前面，其余数依次后移m个位置

package woniu.java50;

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

/**
 * 
 * @author 锋
 * @data 2021年9月8日
 * 用到的快捷功能请参考网址：https://blog.csdn.net/qq_43177828/article/details/120166877
 * 题目：
 * 有n个整数，使其前面各数顺序向后移m个位置，最后m个数变成最前面的m个数
 * 分析：
 * 1、将n个数存储到数组之中
 * 2、自定义数组长度n以及向后移动的位置m
 * 3、题目应该理解为：将后面m个数迁移成为前m个数，原先前面的数顺序后移m个位置
 * 优化：
 * 1、可以选择自己输入数据元素或自动生成指定范围内的数组元素
 */
public class T_36_arrayJiaoHuan {

	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入数组长度（>=2的整数）：");
		int n = scanner.nextInt();
		while (n<2) {
			System.err.println("您输入的数组长度为"+n+",不符合要求，请重新输入(>=2的整数):");
			n = scanner.nextInt();
		}
		System.out.println("请做出选择：1、自动生成数组元素；2、输入数组元素。");
		int key = scanner.nextInt();
		while (key<1||key>2) {
			System.err.println("您输入的选项是"+key+"，不在规定选项内（1/2）,请重新输入：");
			key = scanner.nextInt();
		}
		int[] arr = new int[n];
		if (key==1) {
			System.out.println("您选择自动生成数组元素，请输入数组元素的取值范围(整数)：");
			int a = scanner.nextInt();
			int b = scanner.nextInt();
			arr = MyShortcuts.Random.ArrayInt(n, a, b);
		}else {
			System.out.println("你选择的是手动输入元素：");
			for (int i = 0; i < arr.length; i++) {
				System.out.print("请输入第"+(i+1)+"个元素：");
				arr[i]=scanner.nextInt();
				System.out.println();
			}
		}
		System.out.println("生成的初始数组是："+Arrays.toString(arr));
		System.out.println("请输入后面需要移动的元素个数(范围：[0,"+n+"]):");
		int m = scanner.nextInt();
		while (m<0||m>n) {
			System.err.println("您输入的是"+m+",已经超出规定范围[0,"+n+"]，请重新输入：");
			m = scanner.nextInt();
		}
		System.out.println("移动之后的数组为："+Arrays.toString(YiDong(arr, m)));
		scanner.close();
	}
	
//	元素移动函数，数组a，后面需要移动的元素个数m，返回移动后的数组b
	private static int[] YiDong(int[] a,int m) {
		int[] b = new int[a.length];
		for (int i = 0; i < b.length; i++) {
			if (i<m) {
				b[i] = a[a.length-m+i];
			}else {
				b[i]=  a[i-2];
			}
		}
		return b;
	}
}

37、报数游戏

package woniu.java50;

import java.util.Scanner;
import java.util.concurrent.TimeUnit;

/**
 * 
 * @author 锋
 * @data 2021年9月8日
 * 用到的快捷功能请参考网址：https://blog.csdn.net/qq_43177828/article/details/120166877
 * 题目：
 * 有n个人围成一圈，顺序排号。从第一个人开始报数（从1到3报数），凡报到3的人退出圈子，
 * 问最后留下的是原来第几号的那位。
 * 分析：
 * 1、自定义人数n以及报的最后一个数m
 * 2、报道m的人退出圈子，直到剩下一个人并输出这个人是原来的第几号
 * 3、退圈条件：号数%m==0，结束条件人数为1
 * 4、使用Boolean数组
 */
public class T_37_paoShu {

	public static void main(String[] args) throws InterruptedException {
		Scanner scanner = new Scanner(System.in);
//		获取参加游戏的人数
		System.out.println("请输入参与这个游戏的人数(>1的整数)：");
		int n = scanner.nextInt();
		while (n<=1) {
			System.err.println("你输入的人数是"+n+",不符合游戏设定范围(>1的整数)，请重新输入：");
			n = scanner.nextInt();
		}
//		生成参与人员数组
		boolean[] aboolean = new boolean[n];
		for (int i = 0; i < aboolean.length; i++) {
			aboolean[i]=true;
		}
//		获取报数指令
		System.out.println("请输入报到哪一个数(从1开始报数，范围[2,10]):");
		int m = scanner.nextInt();
		while (m<2||m>10) {
			System.err.println("您输入的是"+m+",超出设定范围[2,10]，请重新输入：");
			m = scanner.nextInt();
		}
		scanner.close();
		System.out.println("------------报数游戏开始咯--------------");
		int jg = PaoShuYpuXi(aboolean, m);
		TimeUnit.SECONDS.sleep(3);
		System.out.println("获胜者是"+jg+"号！");
	}
	
//	报数游戏
	private static int PaoShuYpuXi(boolean[] b,int m) {
		int jg = 0;
		int n = b.length;
		int ps = 1;
//		游戏开始
		while (n!=1) {
			for (int i = 0; i < b.length; i++) {
				if (b[i]) {
					if (ps!=m) {
						ps++;
					}else {
						ps = 1;
						b[i]= false;
						n--;
					}
				}
			}
		}
//		游戏结束，找到胜利者
		for (int i = 0; i < b.length; i++) {
			if (b[i]) {
				jg = i+1;
			}
		}
		return jg;
	}
}

38、统计不同类型的字符

package woniu.java50;

import java.util.Scanner;

/**
 * 
 * @author 锋
 * @data 2021年9月8日
 * 用到的快捷功能请参考网址：https://blog.csdn.net/qq_43177828/article/details/120166877
 * 题目：
 * 写一个函数，求一个字符串的长度，在main函数中输入字符串，并输出其长度。 
 * 分析+优化：
 * 1、字符类型有：中文、数字、英文、空格、特殊字符
 * 2、中文范围：ch >= '\u4E00' && ch <= '\u9FEF'
 * 3、数字范围：ch<='9' && ch>='0'；英文范围：ch>='a' && ch<='z'||ch>='A' && ch<='Z'
 * 4、空格的ASCII码是32
 */
public class T_38_tongJiZiFu {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入字符串（回车结束输入）:");
		String string = scanner.nextLine();
		boolean key = false;
		System.out.println("是否需要输出各种字符的数量： 1、需要；0：不需要(默认不需要)");
		int k = scanner.nextInt();
		while (k<0||k>1) {
			System.err.println("您输入的是"+k+",不符合规定，请重新输入（1/0");
			k = scanner.nextInt();
		}
		scanner.close();
		if (k==1) {
			key = true;
		}
//		使用功能函数
		MyShortcuts.math.TongJiZiFu(string, key);
	}
}

39、编写一个函数，输入n为偶数时，调用函数求1/2+1/4+…+1/n,当输入n为奇数时，调用函数1/1+1/3+…+1/n

package woniu.java50;

import java.util.Scanner;

/**
 * 
 * @author 锋
 * @data 2021年9月8日
 * 用到的快捷功能请参考网址：https://blog.csdn.net/qq_43177828/article/details/120166877
 * 题目： 
 * 编写一个函数，输入n为偶数时，调用函数求1/2+1/4+…+1/n,当输入n为奇数时，
 * 调用函数1/1+1/3+…+1/n
 * 分析+优化：
 * 1、根据输入的n来决定使用哪种函数求分数和，其中所有的分子都是1
 * 2、当n为偶数时：分母为：2 4 6 8 ... n，测试范围[1,48]int类型
 * 3、当n为奇数时：分母为：1 3 5 7 ... n,测试范围[1,23]int类型
 */
public class T_39_JiOrOuFenShuSum {

	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入一个整数(范围：奇数[1，23]，偶数[2,48])：");
		int n = scanner.nextInt();
		while ((MyShortcuts.math.PanDuanJiShu(n) && n>23||n<1) || (!MyShortcuts.math.PanDuanJiShu(n) && n>48||n<2)) {
			System.err.println("您输入的是"+n+",超出规定范围(奇数[1，23]，偶数[2,48])[1，40]，请重新输入：");
			n = scanner.nextInt();
		}
		GuLuFenShuAdd(n);
		scanner.close();
	}
	
//	规律加法
	private static int[] GuLuFenShuAdd(int a) {
		int[] arr1 = new int[2];
//		调用判断是否是奇数函数
		if (MyShortcuts.math.PanDuanJiShu(a)) {
//			当n为奇数时
			arr1[0] = 1;
			arr1[1] = 1;
			if (a>1) {
				for (int i = 3; i <= a; i+=2) {
//					调用int型分数加法：前两个值是相加的两个分子，后面依次是相应的分母
					arr1 = MyShortcuts.math.addFenShuInt(arr1[0],1 ,arr1[1], i);
				}
			}	
		}else {
//			当n为偶数时
			arr1[0] = 1;
			arr1[1] = 2;
			if (a>2) {
				for (int i = 4; i <= a; i+=2) {
//					调用int型分数加法：前两个值是相加的两个分子，后面依次是相应的分母
					arr1 = MyShortcuts.math.addFenShuInt(arr1[0],1 ,arr1[1], i);
				}
			}
		}
		System.out.println("当n="+a+"时，其分数和为："+arr1[0]+"/"+arr1[1]);
		return arr1;
	}
}

40、给输入的字符串排序

package woniu.java50;

import java.util.Scanner;

/**
 * 
 * @author 锋
 * @data 2021年9月9日
 * 用到的功能函数请参考网址：https://blog.csdn.net/qq_43177828/article/details/120166877
 * 题目： 字符串排序。
 * 分析+优化：
 * 1、将字符转化为对应的ASCII码，在存入数组中进行排序
 * 2、将顺序拍好的数组转化为字符串，并输出
 */
public class T_40_ziFuPaiXu {

	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入一串字符：");
		String string1 = scanner.nextLine();
//		使用功能函数将字符串转化为int数组
		int[] arr1 = MyShortcuts.zhuangHuan.string2Array(string1);
		System.out.println("请输入排序方式：1、升序；2、降序");
		int zl = scanner.nextInt();
		while (zl<1||zl>2) {
			System.err.println("您输入的是"+zl+",不在指定范围内，请重新输入（1/2）：");
			zl = scanner.nextInt();
		}
		scanner.close();
//		使用功能函数进行排序，不输出排序的数组内容
		arr1 = MyShortcuts.array.PaiXuWay(arr1, zl, false);
//		使用功能函数将数组转化为字符串
		String string2 = MyShortcuts.zhuangHuan.int2String(arr1);
		System.out.println("这是原字符串："+string1);
		if (zl==1) {
			System.out.print("您选择的是升序，");
		}else {
			System.out.print("您选择的是降序，");
		}
		System.out.println("这是排序好了的字符串："+string2);
	}
}

41、5只猴子分桃子

详细描述：海滩上有一堆桃子，五只猴子来分。第一只猴子把这堆桃子凭据分为五份，多了一个，这只猴子把多的一个扔入海中，拿走了一份。第二只猴子把剩下的桃子又平均分成五份，又多了一个，它同样把多的一个扔入海中，拿走了一份，第三、第四、第五只猴子都是这样做的，问海滩上原来最少有多少个桃子？

package woniu.java50;
/**
 * 
 * @author 锋
 * @data 2021年9月9日
 * 用到的功能函数请参考网址：https://blog.csdn.net/qq_43177828/article/details/120166877
 * 题目： 
 * 海滩上有一堆桃子，五只猴子来分。第一只猴子把这堆桃子平均分为五份，多了一个，
 * 这只猴子把多的一个扔入海中，拿走了一份。第二只猴子把剩下的桃子又平均分成五份，又多了一个，
 * 它同样把多的一个扔入海中，拿走了一份，第三、第四、第五只猴子都是这样做的，问海滩上原来最少有多少个桃子？
 * 分析+优化：
 * 1、假设第5只猴子分完桃子并拿走n个桃子，则第五只猴子每一份为n个，总数为s = 5n+1
 * 2、则第四只猴子分的每一份为s/4个，总数为m = s/4 * 5 +1，依次类推
 * 3、条件：并且每一只猴子分完后的数量可以被4整除,且桃子数量必须是正整数
 * 4、2层循环：外层循环找到一个第5只猴子拿的桃子的数量最小且符合前面所有要求，内层检验桃子数量是否符合要求
 */
public class T_41_houZiFenTaoZi {

	public static void main(String[] args) {
		int hz = 5;
		int tz = TaoZiZongShu(hz);
		System.out.println("桃子总数最小为"+tz);
		if (FenTaoZi(tz, hz)) {
			System.out.println("答案符合要求！");
		}else {
			System.out.println("答案不符合要求！！！");
		}
	}
//	分桃子函数，用于验证桃子数量是否正确
	private static boolean FenTaoZi(int tz,int hz) {
		boolean jg = false;
		for (int i = hz; i > 0; i--) {
			tz = (tz-1)/5 * 4;
		}
		if ((tz-1)%5 != 0) {
			jg = true;
		}
		return jg;
	}
	
//	逆向分桃子规律函数,n为猴子拿走1份之后剩下的数量,返回值m为该猴子分的桃子的总数量
	private static int NiXiangFanTaoZi(int n) {
		int m = n/4*5+1;
		return m;
	}
	
//	求桃子总数量
	private static int TaoZiZongShu(int hz) {
		int tz = 0;
		for (int i = 1; ; i++) {
			tz = i*5 + 1;
			while (tz%4==0 && hz>1) {
				tz = NiXiangFanTaoZi(tz);
				if (tz%4==0) {
					hz--;
				}else {
					hz = 5;
					break;
				}
			}
			if (hz == 1) {
				break;
			}
		}
		return tz;
	}
}

42、求809*??=800*??+9*??+1中的？？

描述：其中??代表的两位数,8*??的结果为两位数，9*??的结果为3位数。求??代表的两位数，及809*??后的结果。

package woniu.java50;
/**
 * 
 * @author 锋
 * @data 2021年9月9日
 * 用到的功能函数请参考网址：https://blog.csdn.net/qq_43177828/article/details/120166877
 * 题目： 809*??=800*??+9*??+1
 * 其中??代表的两位数,8*??的结果为两位数，9*??的结果为3位数。求??代表的两位数，及809*??后的结果。
 * 分析+优化：
 * 1、可以根据“8*??的结果为两位数，9*??的结果为3位数”得到??的取值范围为[12,13]
 * 2、题目有2个要求即求??的值以及809*??的值
 */
public class T_42_qiuLiangWeiShu {

	public static void main(String[] args) {
		boolean tj = false;
		int jg = 0;
		for (int i = 12; i < 14; i++) {
			if (809*i == 800 * i + 9*i+1) {
				jg = i;
				tj = true;
			}
		}
		if (tj) {
			System.out.println("所求的？？="+jg+",809*??="+(jg*809));
		}else {
			System.out.println("没有符合要求的数！");
		}
	}
}

43、数组求解0~7的奇数个数

package woniu.java50;

/**
 * 
 * @author 锋
 * @data 2021年9月9日
 * 用到的功能函数请参考网址：https://blog.csdn.net/qq_43177828/article/details/120166877
 * 题目： 求0—7所能组成的奇数个数。
 * 分析+优化：
 * 1、取值区间[0,76543210],但是不允许重复数字，也没有限定位数
 * 2、奇数看个位上的数字是否为奇数，就可以判断是否为奇数
 * 3、0-7有4个奇数和四个偶数,使用数学的排列组合公式
 * 4、注意，在排列组合时最高位不能为0，最低位不能为偶数
 * 不足：
 * 必须满足的条件：元素数组中偶数的个数等于奇数个数或者偶数个数比奇数多一个
 * 结果：
 * 0~7：奇数46972个，偶数48929个
 * 1~8: 奇数54800个，偶数54800个
 */
public class T_43_8ZuChengJiShu {

	public static void main(String[] args) {
		int[] a = {1,2,3,4,5,6,7,8};
//		for (int i = 1; i <= a.length; i++) {
//			int jga1 = MyShortcuts.math.PaiLieZuHeJiShuGeShu(a, i,i);
//			int jga2 = MyShortcuts.math.PaiLieZuHeOuShuGeShu(a, i,i);
//			System.out.println("数字"+Arrays.toString(a)+"可以组成的"+i+"位数有"+jga1+"个奇数，"+jga2+"个偶数");
//		调用功能函数
		int jgaj = MyShortcuts.math.PaiLieZuHeJiShuGeShu(a, 1,a.length);
		int jgao = MyShortcuts.math.PaiLieZuHeOuShuGeShu(a, 1,a.length);
		System.out.println("数字"+Arrays.toString(a)+"可以组成的数有"+jgaj+"个奇数，"+jgao+"个偶数");
		int[] b = {1,2,3,4,5,6,7,0};
//		for (int i = 1; i <= a.length; i++) {
//			int jgb1 = MyShortcuts.math.PaiLieZuHeJiShuGeShu(b, i,i);
//			int jgb2 = MyShortcuts.math.PaiLieZuHeOuShuGeShu(b, i,i);
//			System.out.println("数字"+Arrays.toString(b)+"可以组成的"+i+"位数有"+jgb1+"个奇数，"+jgb2+"个偶数");
		int jgbj = MyShortcuts.math.PaiLieZuHeJiShuGeShu(b, 1,b.length);
		int jgbo = MyShortcuts.math.PaiLieZuHeOuShuGeShu(b, 1,b.length);
		System.out.println("数字"+Arrays.toString(b)+"可以组成的数有"+jgbj+"个奇数，"+jgbo+"个偶数");
//		}
	}
}

44、证明：一个偶数等于两个素数之和。

package woniu.java50;

import java.util.Scanner;

/**
 * 
 * @author 锋
 * @data 2021年9月15日
 * 用到的功能函数请参考网址：https://blog.csdn.net/qq_43177828/article/details/120166877
 * 题目： 一个偶数总能表示为两个素数之和。
 * 分析+优化：
 * 1、偶数/2，判断其是否为素数，如果是则输出，不是则分别+-1，在进行判断，直到得到相应的结果
 */
public class T_44_OuShuDY2SuShuSum {

	public static void main(String[] args) {
		for (int i = 2; i < 101; i+=2) {
			ZhengMingOuShuHeSuShu(i);
		}
	}
//	证明函数：一个偶数总能表示2个素数之和
	private static void ZhengMingOuShuHeSuShu(int n) {
		int a = n/2;
//		调用功能函数：判断素数
		if (MyShortcuts.math.PanDuanSuShu(a)) {
			System.out.println(n+"是偶数，且"+n+"="+a+"+"+a+",其中"+a+"是素数！");
		}else {
			int b = a;
			for (int i = a; i >= 0; i--,b++) {
				if (MyShortcuts.math.PanDuanSuShu(i) && MyShortcuts.math.PanDuanSuShu(b)) {
					System.out.println(n+"是偶数，且"+n+"="+i+"+"+b+",其中"+i+"、"+b+"都是素数！");
					break;
				}
				if (i==0) {
					System.err.println("该命题是错误的！");
				}
			}
		}
	}
}

45、判断一个素数能被几个9整除

package woniu.java50;
/**
 * 
 * @author 锋
 * @data 2021年9月15日
 * 用到的功能函数请参考网址：https://blog.csdn.net/qq_43177828/article/details/120166877
 * 题目： 判断一个素数能被几个9整除
 * 分析+优化：
 * 1、此题无解，素数只有2个因数1和它本身
 */
public class T_45_suShuZhengChu9N {

	public static void main(String[] args) {
		for (int i = 1; i < 101; i++) {
			if (MyShortcuts.math.PanDuanSuShu(i)) {
				zhengMing(i);
				System.out.println();
			}
		}
	}
//	证明没有素数可以被(n个)9整除
	private static void zhengMing(int n) {
		for (int i = 1; i < 12; i++) {
			int b = i*9;
			if (n%b!=0) {
				System.out.println("素数"+n+"不能被"+i+"个9整除！");
			}else {
				System.out.println("素数"+n+"能被"+i+"个9整除！");
			}
		}
	}
}

46、拼接2个字符串

package woniu.java50;

import java.util.Scanner;

/**
 * 
 * @author 锋
 * @data 2021年9月15日
 * 用到的功能函数请参考网址：https://blog.csdn.net/qq_43177828/article/details/120166877
 * 题目： 两个字符串连接程序
 * 分析+优化：
 * 1、获取2个字符串的长度，然后新创一个字符数组，再将2个字符串放到新字符串数组中
 */
public class T_46_pinJieZiFuChuang {

	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入第一个字符串：(回车结束)");
		String aString = scanner.next();
		System.out.println("请输入第二个字符串：(回车结束)");
		String bString = scanner.next();
//		调用功能函数：字符拼接
		String cString = MyShortcuts.string.pingJie2String(aString, bString);
		System.out.println("这是拼接好的新字符串："+cString);
		scanner.close();
	}
	
}

47、随机从[1,50]生成7个数，并且打印对应个数的*号

package woniu.java50;
/**
 * 
 * @author 锋
 * @data 2021年9月16日
 * 用到的功能函数请参考网址：https://blog.csdn.net/qq_43177828/article/details/120166877
 * 题目： 读取7个数（1—50）的整数值，每读取一个值，程序打印出该值个数的＊
 * 分析+优化：
 * 随机在1-50内生成7个数，并且答应出对应个数的*
 */
public class T_47_daYingSuiJiXing {
	public static void main(String[] args) {
		for (int i = 0; i < 7; i++) {
//			调用功能函数：在指定范围内取值
			int  n = MyShortcuts.Random.randomNumber(1, 50);
			System.out.print("第"+(i+1)+"个");
			daYingXingXing(n);
		}
	}
//	打印
	private static void daYingXingXing(int n) {
		System.out.println("随机数为："+n+",开始打印 “*” ：");
		for (int i = 0; i < n; i++) {
			System.out.print("*");
		}
		System.out.println();
	}
}

48、4位数的加密问题

package woniu.java50;

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

/**
 * 
 * @author 锋
 * @data 2021年9月16日
 * 用到的功能函数请参考网址：https://blog.csdn.net/qq_43177828/article/details/120166877
 * 题目： 
 * 某个公司采用公用电话传递数据，数据是四位的整数，在传递过程中是加密的，加密规则如下：
 * 每位数字都加上5,然后用和除以10的余数代替该数字，再将第一位和第四位交换，第二位和第三位交换。
 * 分析+优化：
 * 1、数组存储数据信息
 * 2、加密：数据本身是4位数，获取之和存放于数组中，每个位上的数值+5，在除以10取余数作为新数据，在将1和4、2和3进行交换，生成密文，即再次生成一个四位数
 * 3、解密：先将一个密文即四位数，存放于数组中，然后交换1和4、2和3，因为每个数据都是0~9（千位上没有0），则原先0~4的数变成了5~9，而5~9则变成了0~4，根据上述信息这个完成解密
 */
public class T_48_wenJianJiaMiAndJieMi {

	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入需要加密的数据(4位数):");
		int n = scanner.nextInt();
//		调用功能函数判断数据是几位数
		while (MyShortcuts.math.JiWeiShu(n)!=4) {
			System.err.println("输入数据不是4位数，请重新输入：");
			n = scanner.nextInt();
		}
		int jm = jiaMi(n);
		int jg = jieMi(jm);
		System.out.println("需要加密的数据是："+n+",加密的结果是："+jm+",解密的结果是："+jg);
		scanner.close();
	}
//	加密
	private static int jiaMi(int n) {
		int jg = 0;
//		调用功能函数将数据存如数组（数据存贮方式从低位到高位）
		int[] arr = MyShortcuts.math.ShuChuWeiShu(4, n);
		System.out.println("加密数组是："+Arrays.toString(arr));
//		赋新值
		for (int i = 0; i < arr.length; i++) {
			arr[i] = (arr[i]+5)%10; 
		}
//		位数交换：即1和4、2和3交换
		int a = arr[0];
		arr[0] = arr[3];
		arr[3] = a;
		int b = arr[1];
		arr[1] = arr[2];
		arr[2] = b;
//		调用功能函数：将数组内的元素组成一个多位数
		jg = MyShortcuts.math.array2Int(arr);
		return jg;
	}
	
//	解密
	private static int jieMi(int n) {
//		调用功能函数将数据存如数组（数据存贮方式从低位到高位）
		int[] arr = MyShortcuts.math.ShuChuWeiShu(4, n);
		System.out.println("解密数组是："+Arrays.toString(arr));
//		位数还原：即1和4、2和3交换
		int a = arr[0];
		arr[0] = arr[3];
		arr[3] = a;
		int b = arr[1];
		arr[1] = arr[2];
		arr[2] = b;
//		还原数值大小
		for (int i = 0; i < arr.length; i++) {
			if (arr[i]>= 5 ) {
				arr[i] = arr[i]-5;
			}else {
				arr[i] = arr[i]+5;
			}
		}
//		调用功能函数：将数组内的元素组成一个多位数
		int jg = MyShortcuts.math.array2Int(arr);
		return jg;
	}
}

49、统计字符串子串在父串中出现的次数

package woniu.java50;import java.util.Scanner;


/**
 * 
 * @author 锋
 * @data 2021年9月16日
 * 用到的功能函数请参考网址：https://blog.csdn.net/qq_43177828/article/details/120166877
 * 题目： 计算字符串中子串出现的次数
 * 分析+优化：
 * 1、2个字符串，即字串和父串，统计字串在父串中出现的次数
 * 2、先将字符串转化为数组，然后比较子串和父串
 */
public class T_49_jiSuanZiChuang {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入字符串父串：");
		String fString = scanner.next();
		System.out.println("请输入字符串子串：");
		String zString = scanner.next();
		scanner.close();
		int n = tongJi(fString, zString);
		System.out.println("您输入的子串在父串中出现的次数是："+n+"次！");
	}
//	统计字串在父串中出现的次数
	private static int tongJi(String f,String z) {
		int jg = 0;
//		调用功能函数：将字符串转化位int数组
		int[] farr = MyShortcuts.string.String2Array(f);
		int[] zarr = MyShortcuts.string.String2Array(z);
		int j =0;
		for (int i = 0; i < farr.length; i++) {
			if (j==zarr.length) {
				j=0;
				jg++;
			}
			if (farr[i] == zarr[j]) {
				j++;
			}else {
				j=0;
			}
		}
		return jg;
	}
}

50、有五个学生，每个学生有3门课的成绩，从键盘输入以上数据（包括学生号，姓名，三门课成绩），计算出平均成绩，况原有的数据和计算出的平均分数存放在磁盘文件”stud”中。

成绩类函数：

package woniu.java50;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 * 录入成绩类
 * @author 锋
 * @data 2021年9月16日
 * 用到的功能函数请参考网址：https://blog.csdn.net/qq_43177828/article/details/120166877
 * 题目： 有五个学生，每个学生有3门课的成绩，从键盘输入以上数据（包括学生号，姓名，三门课成绩），
 * 计算出平均成绩，将原有的数据和计算出的平均分数存放在磁盘文件”stud”中
 * 分析+优化：
 * 1、输入到文件的内容有：学号、姓名、各科成绩，计算总分、平均分
 * 2、用户控制学生数量、科目数目
 * 3、用户给生成的txt文件命名
 */
public class T_50_chengJiClass {

//	属性
//	考试名称
	String kaoShi = "2021年下半年期中测试";
//	人数
	int n = 5;
//	学科数目：
	int xueKe = 3;
//	成绩类别
	int m = xueKe+2;
//	学号：
	String[] xueHao = new String[n];
//	姓名
	String[] xingMing = new String[n];
//	学科名
	String[] xueKeStrings = new String[xueKe];
//	学科成绩及并计算学生个人总分和平均分
	int[][] chengJi = new int[n][m];
//	学科单科平均分
	int[] pingJunFen = new int[xueKe];
	
//	方法
	
//	学生信息录入：学生人数a，学科数目b
	public void input() throws IOException {
		BufferedReader bReader = new BufferedReader(new InputStreamReader(System.in));
		boolean tj = true;
		while (tj) {
			try {
				System.out.println("请输入考试科目名称：");
				for (int i = 0; i < xueKe; i++) {
					System.out.println("请输入第"+(i+1)+"个科目的名称：");
					xueKeStrings[i] = bReader.readLine(); 
				}
				for (int i = 0; i < n; i++) {
					System.out.println("请输入第"+(i+1)+"个学生的学号：");
					xueHao[i] = bReader.readLine();
					System.out.println("请输入第"+(i+1)+"个学生的姓名：");
					xingMing[i] = bReader.readLine();
					int sum = 0;
					for (int j = 0; j < xueKe; j++) {
						System.out.println("请输入第"+(i+1)+"个学生的"+xueKeStrings[j]+"成绩：");
//						这种只能读取一个数据就跳出循环
//						chengJi[i][j]= bReader.read(); 
//						Integer.parseInt可以将任何类型转化为int类型
						chengJi[i][j] = Integer.parseInt(bReader.readLine());
						sum += chengJi[i][j];
					}		
					chengJi[i][m-2] = sum;
					chengJi[i][m-1] = (int) sum/xueKe;
				}
				tj = false;
			} catch (Exception e) {
				// TODO: handle exception
				System.out.println("错误！");
			}
		}
//		IOException只能存在一个close
//		bReader.close();
	}
	
	
//	输出学生信息成text文件
	public void output() throws IOException {
		FileWriter fWriter = new FileWriter("D://学习//java//交互文件//java50//"+kaoShi+".txt");
		BufferedWriter bWriter = new BufferedWriter(fWriter);
		bWriter.write("学号	  "+"姓名   ");
		for (int i = 0; i < xueKe; i++) {
			bWriter.write(xueKeStrings[i]+"  ");
		}
		bWriter.write("总分   "+"平均分");
		bWriter.newLine();
		for (int i = 0; i < n; i++) {
			bWriter.write(xueHao[i]+"   "+xingMing[i]);
			for (int j = 0; j < m ; j++) {
				bWriter.write("  "+chengJi[i][j]);
			}
			bWriter.newLine();
		}
		System.out.println("完成！");
//		IOException只能存在一个close并且前者不能显示输出内容
//		fWriter.close();
		bWriter.close();
	}
	
}

调用：

package woniu.java50;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


/**
 * 成绩
 * @author 锋
 * @data 2021年9月22日
 * 用到的功能函数请参考网址：https://blog.csdn.net/qq_43177828/article/details/120166877
 */
public class T_50_chengJiTest {
	public static void main(String[] args) throws IOException {
		T_50_chengJiClass cj = new T_50_chengJiClass();
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		System.out.println("请输如考试名称：");
		cj.kaoShi = br.readLine();
		System.out.println("请输入参考人数：");
		cj.n = Integer.parseInt(br.readLine());
		System.out.println("请输入考试科目数目：");
		cj.xueKe = Integer.parseInt(br.readLine());
		cj.input();
		cj.output();
	}
}

结果截图：