Java基础函数与简单算法练习题

爱被打了一巴掌 2022-12-23 07:25 145阅读 0赞

### 文章目录 ###

*  函数
 *   *  E201\_06\_02\_输出1000的完数
     *  E201\_06\_03\_正弦函数
     *  E201\_06\_04\_计算常量e
     *  E201\_06\_05\_身份证验证
     *  E201\_06\_06\_计算组合
     *  E201\_06\_07\_分糖果
     *  E201\_06\_08\_验证四位卡布列克数
     *  E201\_06\_09\_计算定积分
 *  7 常见算法
 *   *  E201\_07\_01\_计算累加和
     *  E201\_07\_02\_求算数平方根
     *  E201\_07\_03\_计算最小公倍数
     *  E201\_07\_04\_刘徽割圆术计算圆周率
     *  E201\_07\_05\_富二代存钱问题
     *  E201\_07\_06\_奇怪的三位数
     *  E201\_07\_07\_数动物腿
     *  E201\_07\_08\_猴子选大王

# 函数 #

## E201\_06\_02\_输出1000的完数 ##

题目要求：如题。  
解题思路：  
输入所求范围的最大值。  
计算除完数的因子，并将因子相加，判断是否为等于其本身，如果等于本身则输出结果。  
输出结果。

**代码：**

package HomeWork.Part6;
    
    import java.util.Scanner;
    
    public class HomeWork_Part6_02_QiuWanShu { 
        public static void main(String[] args) { 
            System.out.println("请输入所求范围的最大值：");
            Scanner scan = new Scanner(System.in);
            int n = scan.nextInt();
            qiuWanShu(n);
        }
    
       private static void qiuWanShu(int n) { 
            System.out.println("完数为：");
            for(int i=2;i<=n;i++){ 
                int sum =0;
                for(int j=1;j<i;j++){ 
                    if(i%j==0){ 
                        sum += j;
                    }
                }
           if(sum==i){ 
                   System.out.println(i);
                }
            }
        }
    }

运行结果：  
请输入所求范围的最大值：  
999  
完数为：  
6  
28  
496  
心得体会：

## E201\_06\_03\_正弦函数 ##

题目要求：按照三角函数泰勒级数展开式计算正弦函数值：  
sinx=x-x3/3!+x5/5!-x^7/7!+⋯,直到最后一项的绝对值小于10 6  
解题思路：  
输入x。  
找规律将三角函数泰勒级数展开式的项表达出来，前面一项于-x*x/((n+1)*(n+2))恰好等于后面一项，这是解决问题的关键。  
输出结果。  
**代码：**

package HomeWork.Part6;
    
    import java.util.Scanner;
    
    public class HomeWork_Part6_03_ZhengXuanHanShu { 
        public static void main(String[] args) { 
            Scanner scan = new Scanner(System.in);
            System.out.println("请输入x的值：");
            float x = scan.nextFloat();
            qiuZhi(x);
        }
    
        //求值
        private static void qiuZhi(float x) { 
            float temp = x;
            float sum = x;
            float n = 1;
            do{ 
                temp = -temp*x*x/((n+1)*(n+2));
                sum = sum+ temp;
                n+=2;
            }
            while (Math.abs(temp)>=1.0e-6);
            System.out.printf("sin(%f)=%f",x,sum);
        }
    }

运行结果：  
请输入x的值：  
0  
sin(0.000000)=0.000000  
心得体会：  
将问题转化成计算机能解决的问题很关键。

## E201\_06\_04\_计算常量e ##

题目要求：按照如下公式计算常数e的值

解题思路：  
输入n的值。  
将阶乘关系转换成前一项与1/n的乘积得到下一项的值。  
输出结果。  
**代码：**

package HomeWork.Part6;
    
    import java.util.Scanner;
    
    public class HomeWork_Part6_JiSuanChangLiang { 
        public static void main(String[] args) { 
            Scanner scan = new Scanner(System.in);
            System.out.println("请输入n的值：");
            float n = scan.nextFloat();
            qiuZhi(n);
        }
    
        //求值
        private static void qiuZhi(float x) { 
            float temp = 1;
            float sum = 1;
            float n = 1;
            do{ 
                temp = temp*1/n;
                sum = sum+ temp;
                n++;
            }
            while (n<=x);
            System.out.printf("e=%f",sum);
        }
    }

运行结果：  
请输入n的值：  
134515  
e=2.718282  
心得体会：阶乘关系的表示很重要。

## E201\_06\_05\_身份证验证 ##

题目要求：输入18位的身份证号码，要求首先验证身份证号码合法性（仅利用校验位验证），如果合法则输出性别和出生日期。  
说明：  
（1）身份证号码的7~12位表示出生年月；第17位表示性别，奇数为男，偶数为女；最后一位为校验位  
（2）校验算法：将前面的身份证号码17位数加权求和（系数分别7、9、10、5、8、4、2、1、6、3、7、9、10、5、8、4、2），然后除以11，根据余数找到对应的校验位（分别为1、0、X 、9、8、7、6、5、4、3、2），如果计算的校验位和输入的校验位一致说明身份证号码合法。比如身份证号码53010219200508011X，前17位加权求和:  
(5*7)+(3*9)+(0*10)+(1*5)+(0*8)+(2*4)+(1*2)+(9*1)+(2*6)+(0*3)+(0*7)+(5*9)+(0*10)+(8*5)+(0*8)+(1*4)+(1\*2=189  
189%11 = 2  
序号为2的校验位就是X，所以身份证号码合法。  
提示：字符串提取  
**解题思路：**  
输入身份证号。  
求校验码和输入的校验码比较（加权求和再取余，输出对应的校验码），正确则输出生日和性别。  
输出结果。  
**代码：**

package HomeWork.Part6;
    
    import java.util.Scanner;
    
    public class HomeWork_Part6_05_ShenFenZhengYanZhen { 
        public static void main(String[] args) { 
            Scanner scan = new Scanner(System.in);
            System.out.println("请输入身份证号(18位):");
            String id = scan.next();
            id = id.trim();
            yanZheng(id);
        }
    
        //判断身份证号是否合法
        private static void yanZheng(String id) { 
            char[] checkDigit = { '1','0','X','9','8','7','6','5','4','3','2'};//校验码
            int [] modulus = { 7,9,10,5,8,4,2,1,6,3,7,9,10,5,8,4,2};//系数
            int sum =0;
            for(int i=0;i<id.length()-1;i++){ 
                sum=sum+(id.charAt(i)-'0')*modulus[i];
            }
            int result = sum%11;//计算的校验码序号
    
    
            String sex ="man";//假设为男性
    
            //如果校验码正确
            if(checkDigit[result]==id.charAt(17)){ 
                if((id.charAt(16)-'0')%2==0){ 
                    sex ="women";
                }
                System.out.printf("性别为：%s\n",sex);
                System.out.println("生日为：");
                for(int i=6;i<12;i++){ 
                    System.out.print(id.charAt(i));
                }
            }
            else{ 
                System.out.println("身份证号码不合法！");
            }
        }
    }

**运行结果：**

请输入身份证号(18位):
      53010219200508011X
    性别为：man
    生日为：
    192005

心得体会：灵活的运用字符串操作对未来的学习很重要。

## E201\_06\_06\_计算组合 ##

题目要求：按照下面的公式计算组合数。

**解题思路：**  
输入组合数n,m  
利用for循环计算每个阶乘的结果，然后再根据计算组合数的结果。  
输出结果。  
代码：

package HomeWork.Part6;
    
    import java.util.Scanner;
    
    public class HomeWork_Part6_06_JiSuanZuHe { 
        public static void main(String[] args) { 
            Scanner scan = new Scanner(System.in);
            System.out.println("请输入组合数的n,m:");
            int n = scan.nextInt();
            int m = scan.nextInt();
            calculationResults(n,m);
        }
    
        //计算结果
        private static void calculationResults(int n, int m) { 
            int result ;
            int molecule = factoricalCalculation(m);//分子
            int denominator1 = factoricalCalculation(n);//分母1
            int denominator2 = factoricalCalculation((m-n));//分母2
    
            result = molecule/(denominator1*denominator2);
            System.out.printf("结果是：%d",result);
        }
    
        //计算阶乘的值
        private static int factoricalCalculation(int x) { 
            int result = 1;
            for(int i=1;i<=x;i++){ 
                result = result*i;
            }
            return result;
        }
    }

**运行结果：**  
请输入组合数的n,m:  
2 3  
结果是：3  
心得体会：  
一个看似复杂的问题，将其分解后变得简单起来，因此我们可以看到函数的重要性。

## E201\_06\_07\_分糖果 ##

题目要求：10个小孩围成一圈分糖果，老师分给第一个孩子10块，第二个小孩2块，后面依次分的糖果数量为8、22、16、4、10、6、14、20。然后所有的小孩同时将手中的糖果分一半给右边的小孩，糖果为奇数的可向老师要一块。问经过几次后，大家手中的糖果的块数将一样多，每个人有多少糖果。  
解题思路：  
用数组存储每个孩子的糖果数。  
判断每个孩子的糖果数是否相同，不同则按题目要求进行分配，知道每个孩子的糖果数相同。  
输出结果。  
代码：

package HomeWork.Part6;
    
    public class HomeWork_Part6_07_FenTangGuo { 
        public static void main(String[] args) { 
            int [] candys1 = { 10,2,8,22,16,4,10,6,14,20};//初始糖果数量
            int count = divideCandys(candys1);
            System.out.printf("需要分%d次！每个孩子的糖果数为%d颗",count,candys1[0]);
        }
    
        /**
         * 分糖果
         * @param candys1
         * @return 分的次数
         */
        private static int divideCandys(int[] candys1) { 
            int count=0;//用于计数
            int [] candys2= new int[10];//用来存储分出去的糖果
            while(ending(candys1)){ 
                for(int i=0;i<candys1.length;i++){ 
                    candys2[i]=candys1[i]/2;//分出去的糖果
                    candys1[i]=candys1[i]/2;//剩余的糖果
                }
    
                for(int i=1;i<candys1.length;i++){ 
                    candys1[i]+=candys2[i-1];
                }
                candys1[0]+=candys2[9];
    
                //判断分完糖果后，孩子手里的糖果数是否为偶数
                for(int i=0;i<candys1.length;i++){ 
                    if(candys1[i]%2!=0){ 
                        candys1[i]+=1;//不为偶数，老师给1颗糖
                    }
                }
                count++;
            }
            return count;
        }
    
        /**
         * 判断每个孩子的糖果数是否相同
         * @param candys1
         * @return ture or false
         */
        private static boolean ending(int[] candys1) { 
            boolean flag = false;
            for(int i=1;i<candys1.length;i++){ 
                if(candys1[i]!=candys1[0]){ 
                    flag = true;//发现存在不相同的数，就继续分糖果
                }
            }
            return flag;
        }
    }

运行结果：  
需要分16次！每个孩子的糖果数为18颗  
心得体会：  
在分糖果时，应先算出分出去的糖果，而不应该先算剩余的糖果，否则会造成数据覆盖，导致结果错误。

## E201\_06\_08\_验证四位卡布列克数 ##

题目要求：如题  
概念： \[验证卡布列克数\] 任意一个四位数X(1000≤X≤9999)、只要它们各个数位上的数字不是完全相同的，它就有这样的规律：若这个四位数不等于6174，则有： ① 将组成这个四位数的四个数字由大到小排列，形成由这四个数字组成的最大四位数X1; ② 将组成这个四位数的四个数字由小到大排列，形成由这四个数字组成的最小四位数（如果四个数字含有0，则允许数的高位存在无效0）X2; ③ 求出X1和X2的差，得到一个新的四位数（若有高位零时要保留）； ④ 若X1和X2的差值不等于6174，则回到第①步继续执行；经过有限步以后，X1和X2的差肯定会得到6174。  
解题思路：  
输入一个四位数。  
判断这个数是否等于6174，不等则计算该数重组的最大和最小值。将最大和最小值相减得到新的四位数，如果不等于6174则重复操作，知道结果为6174.  
输出得到结果的过程。  
代码：

package HomeWork.Part6;
    
    import java.util.Arrays;
    import java.util.Scanner;
    
    public class HomeWork_Part6_08_KaBuLieShu { 
        public static void main(String[] args) { 
            Scanner scan = new Scanner(System.in);
            System.out.println("请输入一个四位数：");
            int n = scan.nextInt();
            computedResult(n);
        }
    
        /**
         * 判断结果是否等于6174,不相等则重组计算
         * @param n 输入的值
         */
        private static void computedResult(int n) { 
            while (n!=6174){ 
                n = computedMaxMin(n);
            }
        }
    
        /**
         *  求出重组后的最大值和最小值，并求出两者之差，输出求解过程
         * @param n 判断是否等于6174后的值
         * @return 最大值与最小值之差
         */
        private static int computedMaxMin(int n) { 
            int result=0;
            int[] num = new int[4];
            num[0] = n%10;//个位
            num[1] = n/10%10;
            num[2] = n/100%10;
            num[3] = n/1000%10;
    
            Arrays.sort(num);//排序
    
            int max = num[3]*1000+num[2]*100+num[1]*10+num[0];
            int min = num[0]*1000+num[1]*100+num[2]*10+num[3];
            result = max-min;
            System.out.printf("%d-%d=%d\n",max,min,result);
            return result;
        }
    
    }

运行结果：  
请输入一个四位数：  
1800  
8100-18=8082  
8820-288=8532  
8532-2358=6174  
心得体会：注意书写规范，灵活运用函数。

## E201\_06\_09\_计算定积分 ##

题目要求：定积分是积分的一种，是函数f(x)在区间\[a,b\]上的积分和的极限，其物理含义就是函数f(x)在区间\[a,b\]中的图像包围的面积。而这样一个不规则图形的面积是没有办法直接计算的，但是可以将该图形划分为若干个梯形（或者矩形），用梯形的面积和去近似代替原图形的面积。如果划分得越细，那么近似程度越高。  
此题以计算∫\_0^π▒sinx为例，其结果是2

解题思路：  
如上图所示，求定积分相当于求f(x)与x轴所围成的面积，我们可以将其分为n份，当n接近于无穷时，分割出来的图形接近于矩形，当n接近于无穷时，矩形面积之和近似等于所求的面积。其矩形面积的宽度为（b-a）/n。  
输入n。  
当x=a时，初始，矩形的高（长）为f(a),宽度为（b-a）/n,面积为f(a)*(b-a)/n,当x=x+i*(b-a)/n时，高为f(x+i\*(b-a)/n),面积为：f(x+i\*(b-a)/n)\*(b-a)/n。初始x为下限a。  
将划分的所有矩形面积求和  
输出结果。  
程序代码：

package HomeWork.Part6;
    
    import java.util.Scanner;
    
    public class HomeWork_Part6_09_QiuDingJiFen { 
        public static void main(String[] args) { 
            Scanner scan  = new Scanner(System.in);
            System.out.println("请输入所求积分的上限：");
            float upperLimit = scan.nextFloat();
            System.out.println("请输入所求积分的下限：");
            float lowerLimit = scan.nextFloat();
            System.out.println("请输入你划分的矩形个数：");
            long n = scan.nextLong();
            float area = quadrature(upperLimit,lowerLimit,n);
            System.out.printf("结果为:%f",area);
        }
    
        /**
         * 求出定积分的值
         * @param upperLimit
         * @param lowerLimit
         * @return area
         */
        private static float quadrature(float upperLimit, float lowerLimit,long n) { 
            float result=0;
            float x = lowerLimit;//x的初始值
            for(int i=1;i<=n;i++){ 
                result += (Math.sin(x+i*(upperLimit-lowerLimit)/n)*(upperLimit-lowerLimit)/n);
            }
            return result;
        }
    
    }

# 7 常见算法 #

## E201\_07\_01\_计算累加和 ##

题目要求：求s=a+aa+aaa+aaaa+aa…a的值，其中a是一个数字。例如2+22+222+2222+22222(此时共有5个数相加)，几个数相加由键盘控制。  
解题思路：  
输入数字，和需要相加的数据个数。  
用函数求出数字对应的每个数据并存储于数组中。  
输出相加和。  
代码：

package HomeWork.Part7;
    
    import java.util.Scanner;
    
    public class HomeWork_Part7_01_JiSunLeiJiaHe { 
        public static void main(String[] args) { 
            Scanner scan = new Scanner(System.in);
            System.out.println("请输入一个数字：");
            int num = scan.nextInt();
            System.out.println("请输入要相加的数字个数：");
            int n = scan.nextInt();
            int sum = sumDights(num,n);
            System.out.printf("结果为：%d",sum);
        }
    
        /**
         * 求出该数字组成的数据之和
         * @param num
         * @param n
         * @return 数据之和
         */
        private static int  sumDights(int num,int n) { 
            int result=0;
            int []arrays = new int[n];
            arrays[0]=num;
            for(int i=1;i<n;i++){ 
                arrays[i]=(int)(num*Math.pow(10,i)+arrays[i-1]);
            }
            for(int i=0;i<n;i++){ 
                result+=arrays[i];
            }
            return result;
        }
    }

**运行结果：**  
请输入一个数字：  
2  
请输入要相加的数字个数：  
5  
结果为：24690  
心得体会：  
将问题巧妙地解决很重要。强化思路，和函数的编写。

## E201\_07\_02\_求算数平方根 ##

题目要求：求a的算数平方根： 重复计算x=(x+a/x)/2,直至相邻的两个解非常接近（比如差小于10-6）。  
解题思路：  
输入a。  
根据x=(x+a/x)/2计算f(x)的值，直到f(x+1)-f(x)小于10-6  
停止计算。  
（3）输出结果。  
代码：

package HomeWork.Part7;
    
    import java.util.Scanner;
    
    
    public class HomeWork_Part7_02_NiuDunDieDai { 
        public static void main(String[] args) { 
            Scanner scan = new Scanner(System.in);
            System.out.println("请输入你要求的值：");
            float a = scan.nextFloat();
            float result = compute(a);
            System.out.println(result);
        }
    
        /**
         * 求出算术平方根
         * @param a
         * @return
         */
        private static float compute(float a) { 
            float x = 1f;
            while(Math.abs(((x+a/x)/2)-x)>1e-6){ //f(n+1)-f(n)小于1e-6
                x=(x+a/x)/2;
            }
            return x;
        }
    }

运行结果：  
请输入你要求的值：  
9  
9.000000的平方根为：3.000000  
心得体会：  
根据题目划分子函数。

## E201\_07\_03\_计算最小公倍数 ##

题目要求：计算两个数的最小公倍数  
解题思路：  
输入两个数据a,b。  
先求最大公约数，再求最小公倍数。  
最大公约数求法（辗转相除法）：相比较a,b的大小，用max除min,若余数1为零，则最大公约数为min。  
若余数1不为0,则再用min除余数1，结果如果是余数2为0，则最大公约数为余数1；如果余数2还不为0，继续让除数处于余数，直到最后为0，除数为最大公约数。  
（4）最小公倍数=两数之积/最大公约数。  
代码：

package HomeWork.Part7;
    
    import java.util.Scanner;
    
    public class HomeWork_Part7_03_ZuiXiaoGongBeiShu { 
        public static void main(String[] args) { 
            System.out.println("请输入两个数据：");
            Scanner scan = new Scanner(System.in);
            int a = scan.nextInt();
            int b = scan.nextInt();
            
           /* int max = Math.max(a,b);
            int min = Math.min(a,b);*/  //无需这步操作也可。
            
            int maxCommonDivisor = computerMaxCommonDivisor(a,b);
            int minCommonMuliple = (a*b)/maxCommonDivisor;
            System.out.printf("最小公倍数数为：%d",minCommonMuliple);
    
        }
    
        /**
         * 求最大公约数
         * @param a
         * @param b
         * @return maxCommonDivisor(最大公约数）
         */
        private static int computerMaxCommonDivisor(int a, int b) { 
            int maxCommonDivisor=b;//如果a%b=0,最大公约数就为b
            int remainder =0;//余数
            while(a%b!=0){ 
                remainder = a%b;
                a = b;
                b = remainder;
                maxCommonDivisor = b;
            }
            return maxCommonDivisor;
        }
    }

运行结果：  
请输入两个数据：  
12  
36  
最小公倍数数为：36  
心得体会：  
了解基本的数据的求法。

## E201\_07\_04\_刘徽割圆术计算圆周率 ##

题目要求：设圆内接多边形的边长为b，则边数加倍后的正多边形的边长为b2=√(2-√(4-〖b1〗^2 ))

解题思路：  
原理：圆内接正多边形细割圆周，从而使正多边形的周长无限接近圆周长，进而来求得较为精确的圆周率。  
输入初始正多边形的边长，也为圆的半径。  
设初始正多边形边长为6。  
不断以2倍的倍数扩大正多变形的边数，细割圆周，直到边长足够小的时候，默认多边形的周长近视等于圆周长，求出多边形周长后，将其除以直径，即为圆周率。  
输出结果。  
代码：

package HomeWork.Part7;
    
    import java.util.Scanner;
    
    public class HomeWork_Part7_04_JiSuanYuanZhouLv { 
        public static final int LENGTH= 1;
        public static void main(String[] args) { 
            Scanner scan = new Scanner(System.in);
            double result = computerPerimeter();
            System.out.printf("圆周率为：%f",result);
        }
    
        /**
         * 求圆周率
         * @return 圆周率
         */
        private static double computerPerimeter() { 
            int count=6;//边长数
            double perimeter = 0;//周长
            double a = LENGTH;
            while(a>1E-6){ 
                count*=2;
                a = Math.sqrt(2-Math.sqrt(4-a*a));
            }
            perimeter = count*a;
            double result = perimeter/(2*LENGTH);
            return result;
        }
    }

运行结果：  
圆周率为：3.141674  
心得体会：  
将问题转换成计算机可以求解的模型很重要。

## E201\_07\_05\_富二代存钱问题 ##

题目要求：一个富二代给他儿子的四年大学生活存一笔钱，富三代每月只能取3k作为下个月的生活费，采用的是整存零取的方式，年利率在1.71%，请问富二代需要一次性存入多少钱。  
解题思路：  
采取递推思想，我们清楚最后一个月的月末，富三代需要将利息和本金一共3000元取走，说明产生利息的月份为47个月。  
第47月末存款为3000+（第48月的存款）/（1+0.0171/12）  
第46月末存款为3000+（第47月的存款）/（1+0.0171/12）  
依次类推，算出第一个月初的存款。  
代码：

package HomeWork.Part7;
    
    import java.util.Scanner;
    
    public class HomeWork_Part7_05_FuErDaiCunQian { 
        public static final float RATE = 0.0171f;
        public static void main(String[] args) { 
            float[] money = new float[48];
            computeMoney(money);
            System.out.printf("需要存储的生活费为：%f",money[0]);
        }
    
        /**
         * 计算在每个月的本金和利息
         * @param money
         */
        private static void computeMoney(float[] money) { 
            money[47] = 3000f;//第48个月
            for(int i=46;i>=0;i--){ 
                money[i]=3000+money[i+1]/(1+RATE/12);
            }
        }
    }

运行结果：  
需要存储的生活费为：139287.953125  
心得体会：反向思维，从后往前推。

## E201\_07\_06\_奇怪的三位数 ##

题目要求：有一个三位数，个位数字比百位数字大，而百位数字又比十位数字大，并且各位数字之和等于各位数字相乘之积，求此三位数。  
解题思路：  
从2到9遍历个位。从1到个位遍历百位，从0到百位遍历十位。  
输出符合条件的数。  
代码：

package HomeWork.Part7;
    
    import java.util.Scanner;
    
    public class HomeWork_Part7_06_QiGuaiDeSanWeiShu { 
        public static void main(String[] args) { 
            int result = computeResult();
            System.out.printf("此数为：%d",result);
    
        }
    
        /**
         * 求符合条件的数
         * @return 结果
         */
        private static int computeResult() { 
            int result = 0;
            for(int i=2;i<=9;i++){ //个位
                for(int j=1;j<i;j++){ //百位
                    for(int k=0;k<j;k++){ //十位
                        if((i+j+k)==(i*j*k)){ 
                            result = i+j*100+k*10;
                        }
                    }
                }
            }
            return result;
        }
    }

运行结果：此数为：213  
心得体会：换种思维，穷举法。

## E201\_07\_07\_数动物腿 ##

题目要求：蜘蛛有8条腿，蜻蜓有6条腿和2对翅，蝉有6条腿和1对翅。三种虫子共18只，共有118条腿和20对翅。问每种虫子各几只？  
解题思路：  
穷举法：从0到18遍历三种昆虫数。符合条件就输出。  
代码：

package HomeWork.Part7;
    
    public class HomeWork_Part7_07_ShuDongWuTui { 
        public static void main(String[] args) { 
            for(int i=0;i<=18;i++){ 
                for (int j = 0; j <= 18; j++) { 
                    for (int k = 0; k <= 18; k++) { 
                        boolean flag1,flag2,flag3;
                        flag1 = (i+j+k==18);
                        flag2 = (8*i+6*j+6*k==118);
                        flag3 = (2*j+k==20);
                        if(flag1&&flag2&&flag3){ 
                            System.out.printf("蜘蛛有%d只，蜻蜓有%d只，蝉有%d只！",i,j,k);
                        }
                    }
                }
            }
        }

\}  
运行结果：  
蜘蛛有5只，蜻蜓有7只，蝉有6只！

心得体会：穷举有时候对计算机是好方法，因为它算的快。

## E201\_07\_08\_猴子选大王 ##

题目要求：n个猴子围成一圈，从某个开始报数1-2-3-1-2-3-……报“3”的猴子就被淘汰，游戏一直进行到圈内只剩一只猴子它就是猴大王了。  
解题思路：  
每杀掉一个猴，下一个猴成为“头”，相当于把数组向前移动M位。若已知N-1个人时，胜利者的下标位置位f(N−1,M)，则N个人的时候，就是往后移动M为，(因为有可能数组越界，超过的部分会被接到头上，所以还要模N，既f(N,M)=(f(N−1,M)+M)%n，递推式的核心在于关注胜利者的下标位置是怎么变的。每杀掉一个人，其实就是把这个数组向前移动了M位。然后逆过来，就可以得到这个递推式。因为求出的结果是数组中的下标，最终的编号还要加1。  
输入总人数n，f(1)=1;根据f(1)的值和递推公式求出f(n)的值。  
输出结果。  
代码：  
运行结果：  
请输入人的总数：  
11  
位置为7  
心得体会：递推很重要。  
E201\_07\_09\_阶梯问题  
题目要求：n个台阶，上楼可以一步上1阶，也可以一步上2阶，一共有多少种上楼的方法  
解题思路：  
递推公式：F(n)=F(n-1)+F(n-2)  
F(0)=0,F(1)=1,F(2)=2;  
输入阶梯数。  
根据,F(1)=1,F(2)=2递推F(n)。  
采用数组存储方法数。  
输出结果。  
代码：

package HomeWork.Part7;
    
    import java.util.Scanner;
    
    public class HomeWork_Part7_JieTiWenTi { 
        public static void main(String[] args) { 
            Scanner scan = new Scanner(System.in);
            System.out.println("请输入阶梯数：");
            int n = scan.nextInt();
            int [] arrays = new int[n+1];
            arrays[0]=0;
            if(n>=3) { 
                arrays[1] = 1;
                arrays[2] = 2;
                for (int i = 3; i <= n; i++) { 
                    arrays[i] = arrays[i - 1] + arrays[i - 2];
                }
            }
            else if(n==1){ 
                arrays[1] = 1;
            }
            else if(n==2){ 
                arrays[2] = 2;
            }
                System.out.printf("一共有%d种上楼的方法！", arrays[n]);
        }
    }

运行结果：  
请输入阶梯数：  
5  
一共有8种上楼的方法！  
心得体会：  
灵活运用递推。