【原】Java學習筆記013 - 階段測試。本站提示廣大學習愛好者：（【原】Java學習筆記013 - 階段測試）文章只能為提供參考，不一定能成為您想要的結果。以下是【原】Java學習筆記013 - 階段測試正文
1 package cn.temptation;
2
3 import java.util.Scanner;
4
5 public class Sample01 {
6 public static void main(String[] args) {
7 // 需求：編寫程序打印如下效果：（楊輝三角變體）
8 // 1
9 // 1 1
10 // 1 2 1
11 // 1 3 3 1
12 // 1 4 6 4 1
13 // 1 5 10 10 5 1
14
15 // 思路：使用二維數組存儲楊輝三角的數據，再遍歷數組打印（每行打印縮進 和 數值）
16
17 // 思路：（找規律）
18 // 1、第n行有n個數（n從1開始）
19 // 2、第1行和第2行均為1，從第3行開始，每行的首尾均為1
20 // 3、從第3行的第2列開始到該行的倒數第二個數結束，該位置上的數等於上一行同列的數 + 上一行前一列的數
21 // 從第4行的第2列開始到該行的倒數第二個數結束，該位置上的數等於上一行同列的數 + 上一行前一列的數
22 // ......以此類推
23
24 System.out.println("鍵盤錄入楊輝三角的行數：");
25 Scanner input = new Scanner(System.in);
26 int row = input.nextInt();
27 input.close();
28
29 // 考慮存儲楊輝三角中的數進行計算，都是數字（具有相同意義），考慮使用數組；
30 // 因為涉及到行列，考慮使用二維數組；
31 // 因為行中的列數不同，所以聲明及初始化數組時使用只有一級元素長度沒有二級元素長度的定義方式
32 int[][] arr = new int[row][];
33
34 // 根據規律1
35 // arr[0] = new int[1];
36 // arr[1] = new int[2];
37 // arr[2] = new int[3];
38 // ...
39 // arr[n] = new int[n+1];
40
41 for (int i = 0; i < row; i++) {
42 // 二維數組中的每個一級元素依據規律1創建相應長度的一維數組
43 arr[i] = new int[i + 1];
44
45 // 依據規律2：第1行和第2行均為1，從第3行開始，每行的首尾均為1
46 arr[i][0] = 1;
47 arr[i][i] = 1;
48 }
49
50 // 依據規律3：從第3行的第2列開始到該行的倒數第二個數結束，該位置上的數等於上一行同列的數 + 上一行前一列的數
51 // 從第4行的第2列開始到該行的倒數第二個數結束，該位置上的數等於上一行同列的數 + 上一行前一列的數
52 // ......以此類推
53 for (int i = 2; i < arr.length; i++) { // 外層循環的i表示行
54 for (int j = 1; j < arr[i].length - 1; j++) { // 內層循環的j表示列
55 arr[i][j] = arr[i - 1][j] + arr[i - 1][j - 1];
56 }
57 }
58
59 // 調用方法打印數組
60 printArray(arr);
61 }
62
63 /**
64 * 打印數組
65 * @param arr：二維數組
66 */
67 public static void printArray(int[][] arr) {
68 // 遍歷數組
69 for (int i = 0; i < arr.length; i++) {
70 // 1、打印縮進
71 for (int j = 0; j < arr.length - i - 1; j++) {
72 System.out.print("\t");
73 }
74
75 // 2、打印楊輝三角數據
76 for (int j = 0; j < arr[i].length; j++) {
77 System.out.print(arr[i][j] + "\t");
78 }
79
80 // 換行
81 System.out.println();
82 }
83 }
84 }
1 package cn.temptation;
2
3 public class Sample02 {
4 public static void main(String[] args) {
5 // 需求：一個小球從100米的高度自由落下，每次落地後彈起至原高度的一半後再落下，求它在第10次落地時，共運行了多少米？第10次反彈多高？
6
7 // 思路： 100 -----> 50 -----> 50 -----> 25 -----> 25 -----> 12.5 -----> ....
8 // 落下： 1 2 3
9 // 反彈： 1 2 3
10
11 // 初始化高度
12 double height = 100;
13 // 小球行走的距離
14 double distance = 0;
15
16 // 思路1：分別計算 反彈 和 落下
17 // 1、每次反彈的高度都是前一次的一半，第1次反彈按100米的一半來計算
18 // 2、行走距離 = 落下的總距離 + 反彈的總距離
19 // 3、每次落下的高度也是前一次的一半
20
21 // // 計算反彈
22 // for (int i = 1; i <= 10; i++) {
23 // // 反彈高度
24 // height = height / 2;
25 //
26 // if (i < 10) {
27 // distance += height;
28 // }
29 //
30 // if (i == 10) {
31 // System.out.println("第" + i + "次反彈的高度為：" + height + "米");
32 // }
33 // }
34 //
35 // // 因為分別計算反彈和落下，所以需要重置初始高度
36 // height = 100;
37 //
38 // // 計算落下
39 // for (int i = 1; i <= 10; i++) {
40 // distance += height;
41 // height = height / 2;
42 // }
43
44 // 思路2：第n次落下 和 第n-1次反彈的高度是一樣的，即第n-1次反彈的高度*2 + 初始高度就是第n次落下共行走的距離
45
46 // 初始高度
47 double defaultHeight = height;
48 distance += defaultHeight;
49
50 for (int i = 1; i <= 10; i++) { // i表示反彈的次數
51 // 反彈的高度
52 height = height / 2;
53
54 if (i < 10) {
55 distance += height * 2;
56 }
57
58 if (i == 10) {
59 System.out.println("第" + i + "次反彈的高度為：" + height + "米");
60 }
61 }
62
63 System.out.println("在第10次落地時，共運行了" + distance + "米");
64 }
65 }
1 package cn.temptation;
2
3 public class Sample03 {
4 public static void main(String[] args) {
5 // 需求：有一對兔子，從出生後第3個月開始每個月都生一對兔子，小兔子出生後第3個月後每個月又生一對兔子，假設兔子都不死，計算第20個月兔子的總數有多少只？
6
7 // 規律：
8 // 月份 當月出生 原有數量 總和
9 // 第1個月 0 1 1
10 // 第2個月 0 1 1
11 // 第3個月 1 1 2
12 // 第4個月 1 2 3
13 // 第5個月 2 3 5
14 // 第6個月 3 5 8
15 // ...
16
17 // 其實就是Fibonacci數列，規律：1、1、2、3、5、8、13、... 從第3項開始，值為前兩項的和
18
19 // 寫法1、使用數組
20 int month = 20;
21 int[] arrNumber = new int[20];
22
23 for (int i = 1; i <= arrNumber.length; i++) {
24 if (i == 1 || i == 2) {
25 arrNumber[i - 1] = 1;
26 } else {
27 arrNumber[i - 1] = arrNumber[i - 3] + arrNumber[i - 2];
28 }
29
30 if (i == month) {
31 System.out.println("第" + i + "個月兔子的總數為：" + arrNumber[i - 1] * 2 + "只");
32 }
33 }
34
35 // 寫法2、使用遞歸方法（方法內調用方法自身）
36 System.out.println("第" + month + "個月兔子的總數為：" + count(month) * 2 + "只");
37 }
38
39 /**
40 * 統計方法
41 * @param i
42 * @return
43 */
44 public static int count(int i) {
45 if (i == 1 || i == 2) {
46 return 1;
47 } else {
48 return count(i - 2) + count(i - 1);
49 }
50 }
51 }
1 package cn.temptation;
2
3 import java.util.Scanner;
4
5 public class Sample04 {
6 public static void main(String[] args) {
7 // 需求：一條長廊裡依次裝有n（1 ≤ n ≤ 65535）盞電燈，從頭到尾編號1、2、3、...、n-1、n。每盞電燈由一個拉線開關控制。開始電燈全部關閉。
8 // 有n個學生從長廊穿過。第一個學生把號碼凡是1的倍數的電燈的開關拉一下；接著第二個學生把號碼凡是2的倍數的電燈的開關拉一下；
9 // 接著第三個學生把號碼凡是3的倍數的電燈的開關拉一下；...
10 // 如此繼續下去，最後第n個學生把號碼凡是n的倍數的電燈的開關拉一下。
11 // 計算n個學生按此規定走完後，長廊裡電燈有幾盞亮著。（注意：電燈數 和 學生數一致）
12
13 // 思路：取反操作，切換電燈狀態（開/關）
14
15 System.out.println("長廊裡的電燈數量（也就是學生數量）：");
16 Scanner input = new Scanner(System.in);
17 int number = input.nextInt();
18 input.close();
19
20 // 定義剩余亮著的燈的數量
21 int stillOnNumber = 0;
22
23 if (number < 1 || number > 65535) {
24 System.out.println("輸入的范圍不在1 ≤ n ≤ 65535內");
25 } else {
26 // 因為燈的狀態只有開和關，所以考慮創建一個boolean類型的數組
27 boolean[] arrLight = new boolean[number];
28
29 // 開始電燈全部關閉（這步可以省略，因為boolean類型數組元素的默認值就是false）
30 // for (boolean item : arrLight) {
31 // item = false;
32 // }
33
34 // 所謂的拉一下燈，都是對燈當前的狀態進行取反的操作
35 // 第n個學生把號碼凡是n的倍數的電燈的開關拉一下，感覺需要使用循環
36 for (int i = 1; i <= number; i++) { // i表示學生號
37 // 下句可以進行改進，因為倍數至少是和自身一樣大的數，也就是比自己小的數字不用再去浪費循環比較了
38 // for (int j = 1; j <= number; j++) { // j表示燈號
39 // 優化寫法1、
40 // for (int j = i; j <= number; j++) { // j表示燈號
41 // // 第n個學生尋找n的倍數
42 // if (j % i == 0) {
43 // // 取反操作
44 // arrLight[j - 1] = !arrLight[j - 1];
45 // }
46 // }
47
48 // 優化寫法2、考慮到j從i的值開始算起，統計的是倍數，所以直接在循環時加若干倍
49 for (int j = i; j <= number; j += i) { // j表示燈號
50 // 取反操作
51 arrLight[j - 1] = !arrLight[j - 1];
52 }
53 }
54
55 // 統計一下亮著的燈（狀態為true）的數量
56 for (boolean item : arrLight) {
57 // 寫法1
58 // if (item == true) {
59 // stillOnNumber++;
60 // }
61
62 // 寫法2
63 if (item) {
64 stillOnNumber++;
65 }
66 }
67
68 System.out.println("n個學生按此規定走完後，長廊裡電燈有" + stillOnNumber + "盞亮著");
69 }
70 }
71 }
1 package cn.temptation;
2
3 public class Sample05 {
4 // 成員變量
5 // 注意：因為靜態的成員方法只能訪問靜態的成員變量
6 // 初始的酒的數量
7 static int number = 10 / 2;
8
9 public static void main(String[] args) {
10 // 需求：某啤酒2元一瓶，現在做活動，2個空瓶或4個瓶蓋可以換1瓶啤酒。現有10元，最多可以喝多少瓶啤酒？（注意：不可以賒欠）
11
12 // 思路：兌換的操作終止的條件時，剩下的酒瓶數量沒有2個 或 剩下的瓶蓋數量沒有4個
13
14 // 因為初始的酒的數量會在不同的成員方法中使用，所以就不應該再定義為局部變量了，考慮使用成員變量
15 // 初始的酒的數量
16 // int defaultNumber = 10 / 2;
17
18 // 兌換
19 exchange(number, number);
20 }
21
22 /**
23 * 兌換方法
24 * @param bottle 酒瓶
25 * @param cap 瓶蓋
26 * @return
27 */
28 public static void exchange(int bottle, int cap) {
29 if (bottle >= 2 || cap >= 4) {
30 // 兌換後剩余的酒瓶數量 = 當次酒瓶兌換的酒瓶數量 + 當次酒瓶未能兌換的酒瓶數量 + 當次瓶蓋兌換的酒瓶數量
31 int x = bottle / 2 + bottle % 2 + cap / 4;
32 // 兌換後剩余的瓶蓋數量 = 當次瓶蓋兌換的酒瓶數量（也就是瓶蓋數量） + 當次瓶蓋未能兌換的瓶蓋數量 + 當次酒瓶兌換的酒瓶數量
33 int y = cap / 4 + cap % 4 + bottle / 2;
34
35 // 每次兌換，兌換來的酒的數量應該加在初始數量之上
36 number += (bottle / 2 + cap / 4);
37
38 // 再次調用兌換方法
39 exchange(x, y);
40 } else { // 不再進行兌換的條件
41 System.out.println("剩余的酒瓶數量為：" + bottle);
42 System.out.println("剩余的瓶蓋數量為：" + cap);
43 System.out.println("最多可以喝" + Sample05.number + "瓶啤酒");
44 }
45 }
46 }
