【原】Java学习笔记009 - 阶段测试

 1 package cn.temptation;
 2 
 3 public class Sample01 {
 4     public static void main(String[] args) {
 5         // 1、需求：打印如下图形
 6         /*
 7          * *       *
 8          *  *     *
 9          *   *   *
10          *    * *
11          *     *
12          *    * *
13          *   *   *
14          *  *     *
15          * *       *
16          */
17         
18         // 打印上部
19         for (int i = 0; i < 5; i++) {
20             // 打印空格
21             for (int j = 0; j < i; j++) {
22                 System.out.print(" ");
23             }
24             
25             // 打印星号
26             System.out.print("*");
27             
28             // 打印空格
29             for (int j = 0; j < 7 - i * 2; j++) {
30                 System.out.print(" ");
31             }
32             
33             // 打印星号
34             if (i != 4) {        // 第5行时不打印后面的星号
35                 System.out.print("*");
36             }
37             
38             // 换行
39             System.out.println();
40         }
41         
42         // 打印下部
43         for (int i = 0; i < 4; i++) {
44             // 打印空格
45             for (int j = 0; j < 3 - i; j++) {
46                 System.out.print(" ");
47             }
48             
49             // 打印星号
50             System.out.print("*");
51             
52             // 打印空格
53             for (int j = 0; j < i * 2 + 1; j++) {
54                 System.out.print(" ");
55             }
56             
57             // 打印星号
58             System.out.print("*");
59             
60             // 换行
61             System.out.println();
62         }
63     }
64 }

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

 1 package cn.temptation;
 2 
 3 public class Sample03 {
 4     public static void main(String[] args) {
 5         // 3、需求：商店里篮球原价为78元一个，现在为了促销，推出了买5个送1个的活动，波波维奇需要35个球，问他需要花多少钱？
 6         
 7         // 单价
 8         int price = 78;
 9         // 购买的篮球数
10         int number = 1;
11         // 赠送的篮球数
12         int extendNumber = 0;
13         // 需求的篮球数
14         int totalNumber = 35;
15         
16         for(;;) {
17             // 买5个送1个，赠送的数量加在赠送的篮球数的变量上
18             if (number % 5 == 0) {
19                 extendNumber++;
20             }
21             
22             // 购买的篮球数量 + 赠送的篮球数量 达到  需要的篮球数量，就跳出这个死循环
23             if (number + extendNumber >= totalNumber) {
24                 break;
25             }
26             
27             number++;
28         }
29         
30         System.out.println("波波维奇需要35个球，问他需要花" + (number * price) + "元");
31     }
32 }

 1 package cn.temptation;
 2 
 3 public class Sample04 {
 4     public static void main(String[] args) {
 5         // 4、需求：网红开网店，工作日营业，休息日出去玩。工作日每天随机得到150~200元，休息日每天随机花费100~150元，问需要经过多少天，她才能存到5201314元
 6         //           （假设她是从某一个周一开始计算）
 7         //           提示：随机数使用Math.random()方法
 8                 
 9         // 思路：
10         // 最终存下来的钱        =     赚的钱                    -               花的钱
11         //                         (工作日)                        (休息日)
12         
13         // 1、研究随机数的产生
14         // Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。
15         // 常用的成员方法：
16         // static double random() ：返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。 
17 //        System.out.println(Math.random());
18         // 150 ~ 200 -----> 150 + 0 ~ 150 + 50 -----> 150 + Math.random() * 50
19         // 100 ~ 150 -----> 100 + 0 ~ 100 + 50 -----> 100 + Math.random() * 50
20 //        System.out.println((int)(150 + Math.random() * 50));
21 //        System.out.println((int)(100 + Math.random() * 50));
22         
23         // 2、根据赚钱  和  花钱 的规则，明显要使用选择结构
24         
25         // 3、研究工作日 和 休息日的判定
26         //    可以类比使用 %10 获取个位数字（因为那是十进制），这里一周七天（理解为七进制），所以可以通过 %7 获取是星期几
27         
28         // 定义天数
29         int day = 1;
30         // 定义存的钱数
31         int totalMoney = 0;
32         
33         for(;;) {
34             // 随机賺的钱
35             int earnMoney = (int)(150 + Math.random() * 50);
36             // 随机花的钱
37             int payMoney = (int)(100 + Math.random() * 50);
38             
39             // 工作日 和 休息日 的业务逻辑
40             switch (day % 7) {
41             case 1:
42             case 2:
43             case 3:
44             case 4:
45             case 5:
46                 // 工作日
47                 totalMoney += earnMoney;
48                 break;
49             case 6:
50             case 0:
51                 totalMoney -= payMoney;
52                 break;
53             default:
54                 System.out.println("输入错误");
55                 break;
56             }
57             
58             // 跳出死循环的条件
59             if (totalMoney >= 5201314) {
60                 break;
61             }
62             
63             // 用时的天数需要自增
64             day++;
65         }
66         
67         System.out.println("需要经过" + day + "天，她才能存到5201314元");
68     }
69 }

 1 package cn.temptation;
 2 
 3 import java.util.Scanner;
 4 
 5 public class Sample05 {
 6     public static void main(String[] args) {
 7         // 5、需求：输入两个正整数，求其最大公约数 和 最小公倍数
 8         
 9         // 思路：
10         // 最大公约数
11         // 1、对输入的两个正整数进行大小比较
12         // 2、用比较大的数除以比较小的数，如果两个数一样大，那么最大公约数就是其本身；
13         //         如果较大的数正好可以整除较小的数，那么最大公约数就是较小的数；
14         //        如果较大的数不能整除较小的数，将得到的余数作为新的较小的数，刚才的较小的数作为较大的数再去做除法，直到得到的余数为0为止
15         
16         // 最小公倍数：两个数的乘积除以最大公约数
17         
18         Scanner input = new Scanner(System.in);
19         System.out.println("输入第一个数：");
20         int i = input.nextInt();
21         System.out.println("输入第二个数：");
22         int j = input.nextInt();
23         input.close();
24         
25         // 声明最大公约数
26         int gcd = 0;
27 
28         // 获取两个数的乘积（为了后续求最小公倍数时使用，否则后续这两个数字在循环中会发生改变）
29         int result = i * j;
30         
31         // 求最大公约数
32         // 1、对输入的两个正整数进行大小比较
33         if (i < j) {
34             int temp = i;
35             i = j;
36             j = temp;
37         }
38         
39         // 2、用比较大的数除以比较小的数，如果两个数一样大，那么最大公约数就是其本身；
40         //         如果较大的数正好可以整除较小的数，那么最大公约数就是较小的数；
41         //            如果较大的数不能整除较小的数，将得到的余数作为新的较小的数，刚才的较小的数作为较大的数再去做除法，直到得到的余数为0为止
42         // 注意：数学算式上      被除数     %   除数   =  商......余数
43         
44         while (j != 0) {
45             if (i == j) {
46                 gcd = i = j;
47             } else {
48                 // 对于当次循环操作，被除数     %   除数
49                 gcd = i % j;
50                 // 下面两句实际上是为下次循环的操作来做准备的，即这次循环中的除数移到被除数的位置、余数移到除数的位置
51                 i = j;
52                 j = gcd;
53             }
54         }
55         
56         // 循环结束时，就是余数为0时，最大公约数不是放在gcd这个变量中的，而是在i这个变量中
57         gcd = i;
58         System.out.println("最大公约数为：" + gcd);
59         
60         System.out.println("最小公倍数为：" + result / gcd);
61     }
62 }

  1 package cn.temptation;
  2 
  3 import java.util.Scanner;
  4 
  5 public class Sample06 {
  6     public static void main(String[] args) {
  7         // 6、需求：编写程序，实现Fibonacci数列的求解
  8         //           提示：Fibonacci数列    1、1、2、3、5、8、13、21、...
  9         
 10         // 思路：分析规律
 11         //      Fibonacci数列：第1项 和 第2项均为1；从第3项开始，值等于前面两项的和
 12         
 13         // 写法1、常规写法（使用循环）
 14         // 第3项 = 第2项 + 第1项
 15         // 第4项 = 第3项 + 第2项  = (第2项 + 第1项) + 第2项
 16         // 第5项 = 第4项 + 第3项  = ((第2项 + 第1项) + 第2项) + (第2项 + 第1项)
 17         
 18         // 写法2、使用递归
 19         // 递归：方法调用自身的写法称为递归
 20         // 从数学角度归纳公式
 21         // F(1) = 1
 22         // F(2) = 1
 23         // F(n) = F(n - 1) + F(n - 2) (n > 2)
 24         
 25         // 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)
 26         // .......   -----> F(3) = F(2) + F(1) = 1 + 1
 27         
 28         // 逆向思考一下
 29         // 位置            第一个位置        第二个位置
 30         // F(3)            F(2)       +    F(1)
 31         // F(4)            F(3)       +    F(2)
 32         
 33         Scanner input = new Scanner(System.in);
 34         System.out.println("输入项数：");
 35         int n = input.nextInt();
 36         input.close();
 37         
 38         System.out.println("该项的值为：" + Fibonacci(n));
 39         
 40 //        printFibonacci(n);
 41         
 42         System.out.println("该项的值为：" + FibonacciEx(n));
 43     }
 44     
 45     /**
 46      * 写法1、常规写法（使用循环）
 47      * 获取Fibonacci数列指定项的值
 48      * @param n：指定项数
 49      * @return：Fibonacci数列指定项对应的值
 50      */
 51     public static int Fibonacci(int n) {
 52         // 第1项
 53         int i = 1;
 54         // 第2项
 55         int j = 1;
 56         // 定义当次结果
 57         int tempResult = 0;
 58         // 定义最终结果
 59         int result = 0;
 60         
 61         if (n <= 2 && n > 0) {
 62             result = i = j = 1;
 63         } else {
 64             // 使用循环来实现
 65             for (int k = 3; k <= n; k++) {
 66                 // 计算出当次结果
 67                 tempResult = i + j;
 68                 // 为了给下一次循环使用，调整一下i位置上 和 j位置上的值
 69                 j = i;
 70                 i = tempResult;
 71             }
 72             
 73             result = tempResult;
 74         }
 75         
 76         return result;
 77     }
 78     
 79     /**
 80      * 写法1、常规写法（使用循环）
 81      * 打印Fibonacci数列的指定项之前所有的值
 82      * @param n
 83      */
 84     public static void printFibonacci(int n) {
 85         // 第1项
 86         int i = 1;
 87         // 第2项
 88         int j = 1;
 89         // 定义当次结果
 90         int tempResult = 0;
 91 
 92         // 使用循环来实现
 93         for (int k = 1; k <= n; k++) {
 94             if (k <= 2 && k > 0) {
 95                 tempResult = i = j = 1;
 96                 System.out.print(tempResult + "\t");
 97             } else {
 98                 // 计算出当次结果
 99                 tempResult = i + j;
100                 System.out.print(tempResult + "\t");
101                 // 为了给下一次循环使用，调整一下i位置上 和 j位置上的值
102                 j = i;
103                 i = tempResult;
104             }
105         }
106     }
107     
108     /**
109      * 写法2、创建递归方法
110      * @param n
111      * @return
112      */
113     public static int FibonacciEx(int n) {
114         // 声明最终结果
115         int result = 0;
116         
117         if (n <= 2 && n > 0) {
118             result = 1;
119         } else {
120             result = FibonacciEx(n - 1) + FibonacciEx(n - 2);
121         }
122         
123         return result;
124     }
125 }

 

转载于:https://www.cnblogs.com/iflytek/p/6443911.html