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 }
