【原】Java学习笔记009

package cn.temptation;

public class Sample01 {
    public static void main(String[] args) {
        // 1、需求：打印如下图形
        /*
         * *       *
         *  *     *
         *   *   *
         *    * *
         *     *
         *    * *
         *   *   *
         *  *     *
         * *       *
         */
        
        // 打印上部
        for (int i = 0; i < 5; i++) {
            // 打印空格
            for (int j = 0; j < i; j++) {
                System.out.print(" ");
            }
            
            // 打印星号
            System.out.print("*");
            
            // 打印空格
            for (int j = 0; j < 7 - i * 2; j++) {
                System.out.print(" ");
            }
            
            // 打印星号
            if (i != 4) {        // 第5行时不打印后面的星号
                System.out.print("*");
            }
            
            // 换行
            System.out.println();
        }
        
        // 打印下部
        for (int i = 0; i < 4; i++) {
            // 打印空格
            for (int j = 0; j < 3 - i; j++) {
                System.out.print(" ");
            }
            
            // 打印星号
            System.out.print("*");
            
            // 打印空格
            for (int j = 0; j < i * 2 + 1; j++) {
                System.out.print(" ");
            }
            
            // 打印星号
            System.out.print("*");
            
            // 换行
            System.out.println();
        }
    }
}

package cn.temptation;

public class Sample02 {
    public static void main(String[] args) {
        // 2、需求：猴子第一天早上摘下若干个桃子，当即吃了一半，觉得不过瘾，又多吃了一个。第二天早上又将剩下的桃子吃掉一半，又多吃了一个。
        //            以后每天早上都多吃了前一天的一半零一个。到第10天早上再吃时，发现就剩下一个桃子了。求第一天共摘了多少个桃子。
                
        // 思路：正向思维比较复杂时，可以考虑逆向思维，把第10天看成逆向的第1天，第9天看成逆向的第2天，...
        
        int count = 1;
        
        for (int i = 2; i <= 10; i++) {
            count = (count + 1) * 2;
        }
        
        System.out.println("第一天共摘了" + count + "个桃子");
    }
}

package cn.temptation;

public class Sample03 {
    public static void main(String[] args) {
        // 3、需求：商店里篮球原价为78元一个，现在为了促销，推出了买5个送1个的活动，波波维奇需要35个球，问他需要花多少钱？
        
        // 单价
        int price = 78;
        // 购买的篮球数
        int number = 1;
        // 赠送的篮球数
        int extendNumber = 0;
        // 需求的篮球数
        int totalNumber = 35;
        
        for(;;) {
            // 买5个送1个，赠送的数量加在赠送的篮球数的变量上
            if (number % 5 == 0) {
                extendNumber++;
            }
            
            // 购买的篮球数量 + 赠送的篮球数量 达到  需要的篮球数量，就跳出这个死循环
            if (number + extendNumber >= totalNumber) {
                break;
            }
            
            number++;
        }
        
        System.out.println("波波维奇需要35个球，问他需要花" + (number * price) + "元");
    }
}

package cn.temptation;

public class Sample04 {
    public static void main(String[] args) {
        // 4、需求：网红开网店，工作日营业，休息日出去玩。工作日每天随机得到150~200元，休息日每天随机花费100~150元，问需要经过多少天，她才能存到5201314元
        //           （假设她是从某一个周一开始计算）
        //           提示：随机数使用Math.random()方法
                
        // 思路：
        // 最终存下来的钱        =     赚的钱                    -               花的钱
        //                         (工作日)                        (休息日)
        
        // 1、研究随机数的产生
        // Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。
        // 常用的成员方法：
        // static double random() ：返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。 
//        System.out.println(Math.random());
        // 150 ~ 200 -----> 150 + 0 ~ 150 + 50 -----> 150 + Math.random() * 50
        // 100 ~ 150 -----> 100 + 0 ~ 100 + 50 -----> 100 + Math.random() * 50
//        System.out.println((int)(150 + Math.random() * 50));
//        System.out.println((int)(100 + Math.random() * 50));
        
        // 2、根据赚钱  和  花钱 的规则，明显要使用选择结构
        
        // 3、研究工作日 和 休息日的判定
        //    可以类比使用 %10 获取个位数字（因为那是十进制），这里一周七天（理解为七进制），所以可以通过 %7 获取是星期几
        
        // 定义天数
        int day = 1;
        // 定义存的钱数
        int totalMoney = 0;
        
        for(;;) {
            // 随机賺的钱
            int earnMoney = (int)(150 + Math.random() * 50);
            // 随机花的钱
            int payMoney = (int)(100 + Math.random() * 50);
            
            // 工作日 和 休息日 的业务逻辑
            switch (day % 7) {
            case 1:
            case 2:
            case 3:
            case 4:
            case 5:
                // 工作日
                totalMoney += earnMoney;
                break;
            case 6:
            case 0:
                totalMoney -= payMoney;
                break;
            default:
                System.out.println("输入错误");
                break;
            }
            
            // 跳出死循环的条件
            if (totalMoney >= 5201314) {
                break;
            }
            
            // 用时的天数需要自增
            day++;
        }
        
        System.out.println("需要经过" + day + "天，她才能存到5201314元");
    }
}

package cn.temptation;

import java.util.Scanner;

public class Sample05 {
    public static void main(String[] args) {
        // 5、需求：输入两个正整数，求其最大公约数 和 最小公倍数
        
        // 思路：
        // 最大公约数
        // 1、对输入的两个正整数进行大小比较
        // 2、用比较大的数除以比较小的数，如果两个数一样大，那么最大公约数就是其本身；
        //         如果较大的数正好可以整除较小的数，那么最大公约数就是较小的数；
        //        如果较大的数不能整除较小的数，将得到的余数作为新的较小的数，刚才的较小的数作为较大的数再去做除法，直到得到的余数为0为止
        
        // 最小公倍数：两个数的乘积除以最大公约数
        
        Scanner input = new Scanner(System.in);
        System.out.println("输入第一个数：");
        int i = input.nextInt();
        System.out.println("输入第二个数：");
        int j = input.nextInt();
        input.close();
        
        // 声明最大公约数
        int gcd = 0;

        // 获取两个数的乘积（为了后续求最小公倍数时使用，否则后续这两个数字在循环中会发生改变）
        int result = i * j;
        
        // 求最大公约数
        // 1、对输入的两个正整数进行大小比较
        if (i < j) {
            int temp = i;
            i = j;
            j = temp;
        }
        
        // 2、用比较大的数除以比较小的数，如果两个数一样大，那么最大公约数就是其本身；
        //         如果较大的数正好可以整除较小的数，那么最大公约数就是较小的数；
        //            如果较大的数不能整除较小的数，将得到的余数作为新的较小的数，刚才的较小的数作为较大的数再去做除法，直到得到的余数为0为止
        // 注意：数学算式上      被除数     %   除数   =  商......余数
        
        while (j != 0) {
            if (i == j) {
                gcd = i = j;
            } else {
                // 对于当次循环操作，被除数     %   除数
                gcd = i % j;
                // 下面两句实际上是为下次循环的操作来做准备的，即这次循环中的除数移到被除数的位置、余数移到除数的位置
                i = j;
                j = gcd;
            }
        }
        
        // 循环结束时，就是余数为0时，最大公约数不是放在gcd这个变量中的，而是在i这个变量中
        gcd = i;
        System.out.println("最大公约数为：" + gcd);
        
        System.out.println("最小公倍数为：" + result / gcd);
    }
}

package cn.temptation;

import java.util.Scanner;

public class Sample06 {
    public static void main(String[] args) {
        // 6、需求：编写程序，实现Fibonacci数列的求解
        //           提示：Fibonacci数列    1、1、2、3、5、8、13、21、...
        
        // 思路：分析规律
        //      Fibonacci数列：第1项 和 第2项均为1；从第3项开始，值等于前面两项的和
        
        // 写法1、常规写法（使用循环）
        // 第3项 = 第2项 + 第1项
        // 第4项 = 第3项 + 第2项  = (第2项 + 第1项) + 第2项
        // 第5项 = 第4项 + 第3项  = ((第2项 + 第1项) + 第2项) + (第2项 + 第1项)
        
        // 写法2、使用递归
        // 递归：方法调用自身的写法称为递归
        // 从数学角度归纳公式
        // F(1) = 1
        // F(2) = 1
        // F(n) = F(n - 1) + F(n - 2) (n > 2)
        
        // F(n) = F(n - 1) + F(n - 2) -----> F(n - 1) = F(n - 1 - 1) + F(n - 1 - 2), F(n - 2) = F(n - 2 - 1) + F(n - 2 - 2)
        // .......   -----> F(3) = F(2) + F(1) = 1 + 1
        
        // 逆向思考一下
        // 位置            第一个位置        第二个位置
        // F(3)            F(2)       +    F(1)
        // F(4)            F(3)       +    F(2)
        
        Scanner input = new Scanner(System.in);
        System.out.println("输入项数：");
        int n = input.nextInt();
        input.close();
        
        System.out.println("该项的值为：" + Fibonacci(n));
        
//        printFibonacci(n);
        
        System.out.println("该项的值为：" + FibonacciEx(n));
    }
    
    /**
     * 写法1、常规写法（使用循环）
     * 获取Fibonacci数列指定项的值
     * @param n：指定项数
     * @return：Fibonacci数列指定项对应的值
     */
    public static int Fibonacci(int n) {
        // 第1项
        int i = 1;
        // 第2项
        int j = 1;
        // 定义当次结果
        int tempResult = 0;
        // 定义最终结果
        int result = 0;
        
        if (n <= 2 && n > 0) {
            result = i = j = 1;
        } else {
            // 使用循环来实现
            for (int k = 3; k <= n; k++) {
                // 计算出当次结果
                tempResult = i + j;
                // 为了给下一次循环使用，调整一下i位置上 和 j位置上的值
                j = i;
                i = tempResult;
            }
            
            result = tempResult;
        }
        
        return result;
    }
    
    /**
     * 写法1、常规写法（使用循环）
     * 打印Fibonacci数列的指定项之前所有的值
     * @param n
     */
    public static void printFibonacci(int n) {
        // 第1项
        int i = 1;
        // 第2项
        int j = 1;
        // 定义当次结果
        int tempResult = 0;

        // 使用循环来实现
        for (int k = 1; k <= n; k++) {
            if (k <= 2 && k > 0) {
                tempResult = i = j = 1;
                System.out.print(tempResult + "	");
            } else {
                // 计算出当次结果
                tempResult = i + j;
                System.out.print(tempResult + "	");
                // 为了给下一次循环使用，调整一下i位置上 和 j位置上的值
                j = i;
                i = tempResult;
            }
        }
    }
    
    /**
     * 写法2、创建递归方法
     * @param n
     * @return
     */
    public static int FibonacciEx(int n) {
        // 声明最终结果
        int result = 0;
        
        if (n <= 2 && n > 0) {
            result = 1;
        } else {
            result = FibonacciEx(n - 1) + FibonacciEx(n - 2);
        }
        
        return result;
    }
}