【原】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 + "\t");
             } else {
                 // 计算出当次结果
                 tempResult = i + j;
                 System.out.print(tempResult + "\t");
                 // 为了给下一次循环使用，调整一下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;
     }
 }