【原】Java学习笔记013

package cn.temptation;

import java.util.Scanner;

public class Sample01 {
    public static void main(String[] args) {
        // 需求：编写程序打印如下效果：（杨辉三角变体）
        //                         1
        //                     1    1
        //                 1    2    1
        //             1    3    3    1
        //         1    4    6    4    1
        // 1    5    10    10    5    1
        
        // 思路：使用二维数组存储杨辉三角的数据，再遍历数组打印（每行打印缩进 和 数值）
        
        // 思路：（找规律）
        // 1、第n行有n个数（n从1开始）
        // 2、第1行和第2行均为1，从第3行开始，每行的首尾均为1
        // 3、从第3行的第2列开始到该行的倒数第二个数结束，该位置上的数等于上一行同列的数  + 上一行前一列的数
        //       从第4行的第2列开始到该行的倒数第二个数结束，该位置上的数等于上一行同列的数  + 上一行前一列的数
        //         ......以此类推
        
        System.out.println("键盘录入杨辉三角的行数：");
        Scanner input = new Scanner(System.in);
        int row = input.nextInt();
        input.close();
        
        // 考虑存储杨辉三角中的数进行计算，都是数字（具有相同意义），考虑使用数组；
        // 因为涉及到行列，考虑使用二维数组；
        // 因为行中的列数不同，所以声明及初始化数组时使用只有一级元素长度没有二级元素长度的定义方式
        int[][] arr = new int[row][];
        
        // 根据规律1
//                arr[0] = new int[1];
//                arr[1] = new int[2];
//                arr[2] = new int[3];
//                ...
//                arr[n] = new int[n+1];
        
        for (int i = 0; i < row; i++) {
            // 二维数组中的每个一级元素依据规律1创建相应长度的一维数组
            arr[i] = new int[i + 1];
            
            // 依据规律2：第1行和第2行均为1，从第3行开始，每行的首尾均为1
            arr[i][0] = 1;
            arr[i][i] = 1;
        }
        
        // 依据规律3：从第3行的第2列开始到该行的倒数第二个数结束，该位置上的数等于上一行同列的数  + 上一行前一列的数
        //                从第4行的第2列开始到该行的倒数第二个数结束，该位置上的数等于上一行同列的数  + 上一行前一列的数
        //         ......以此类推
        for (int i = 2; i < arr.length; i++) {            // 外层循环的i表示行
            for (int j = 1; j < arr[i].length - 1; j++) {        // 内层循环的j表示列
                arr[i][j] = arr[i - 1][j] + arr[i - 1][j - 1];
            }
        }
        
        // 调用方法打印数组
        printArray(arr);
    }
    
    /**
     * 打印数组
     * @param arr：二维数组
     */
    public static void printArray(int[][] arr) {
        // 遍历数组
        for (int i = 0; i < arr.length; i++) {
            // 1、打印缩进
            for (int j = 0; j < arr.length - i - 1; j++) {
                System.out.print("	");
            }
            
            // 2、打印杨辉三角数据
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j] + "	");
            }
            
            // 换行
            System.out.println();
        }
    }
}

package cn.temptation;

public class Sample02 {
    public static void main(String[] args) {
        // 需求：一个小球从100米的高度自由落下，每次落地后弹起至原高度的一半后再落下，求它在第10次落地时，共运行了多少米？第10次反弹多高？
        
        // 思路：    100        ----->    50        ----->    50        ----->    25        ----->    25        ----->    12.5    ----->        ....
        // 落下：    1                                2                                3
        // 反弹：                    1                                2                                3
        
        // 初始化高度
        double height = 100;
        // 小球行走的距离
        double distance = 0;
        
        // 思路1：分别计算  反弹 和 落下
        // 1、每次反弹的高度都是前一次的一半，第1次反弹按100米的一半来计算
        // 2、行走距离   =  落下的总距离   +  反弹的总距离
        // 3、每次落下的高度也是前一次的一半
        
//        // 计算反弹
//        for (int i = 1; i <= 10; i++) {
//            // 反弹高度
//            height = height / 2;
//            
//            if (i < 10) {
//                distance += height;
//            }
//            
//            if (i == 10) {
//                System.out.println("第" + i + "次反弹的高度为：" + height + "米");
//            }
//        }
//        
//        // 因为分别计算反弹和落下，所以需要重置初始高度
//        height = 100;
//        
//        // 计算落下
//        for (int i = 1; i <= 10; i++) {
//            distance += height;
//            height = height / 2;
//        }
        
        // 思路2：第n次落下  和  第n-1次反弹的高度是一样的，即第n-1次反弹的高度*2 + 初始高度就是第n次落下共行走的距离
        
        // 初始高度
        double defaultHeight = height;
        distance += defaultHeight;
        
        for (int i = 1; i <= 10; i++) {        // i表示反弹的次数
            // 反弹的高度
            height = height / 2;
            
            if (i < 10) {
                distance += height * 2;
            }
            
            if (i == 10) {
                System.out.println("第" + i + "次反弹的高度为：" + height + "米");
            }
        }
        
        System.out.println("在第10次落地时，共运行了" + distance + "米");
    }
}

package cn.temptation;

public class Sample03 {
    public static void main(String[] args) {
        // 需求：有一对兔子，从出生后第3个月开始每个月都生一对兔子，小兔子出生后第3个月后每个月又生一对兔子，假设兔子都不死，计算第20个月兔子的总数有多少只？
        
        // 规律：
        //    月份            当月出生            原有数量            总和
        // 第1个月        0                1                1
        // 第2个月        0                1                1
        // 第3个月        1                1                2
        // 第4个月        1                2                3
        // 第5个月        2                3                5
        // 第6个月        3                5                8
        // ...
        
        // 其实就是Fibonacci数列，规律：1、1、2、3、5、8、13、... 从第3项开始，值为前两项的和
        
        // 写法1、使用数组
        int month = 20;
        int[] arrNumber = new int[20];
        
        for (int i = 1; i <= arrNumber.length; i++) {
            if (i == 1 || i == 2) {
                arrNumber[i - 1] = 1;
            } else {
                arrNumber[i - 1] = arrNumber[i - 3] + arrNumber[i - 2];
            }
            
            if (i == month) {
                System.out.println("第" + i + "个月兔子的总数为：" + arrNumber[i - 1] * 2 + "只");
            }
        }
        
        // 写法2、使用递归方法（方法内调用方法自身）
        System.out.println("第" + month + "个月兔子的总数为：" + count(month) * 2 + "只");
    }
    
    /**
     * 统计方法
     * @param i
     * @return
     */
    public static int count(int i) {
        if (i == 1 || i == 2) {
            return 1;
        } else {
            return count(i - 2) + count(i - 1);
        }
    }
}

package cn.temptation;

import java.util.Scanner;

public class Sample04 {
    public static void main(String[] args) {
        // 需求：一条长廊里依次装有n（1 ≤ n ≤ 65535）盏电灯，从头到尾编号1、2、3、...、n-1、n。每盏电灯由一个拉线开关控制。开始电灯全部关闭。
        //        有n个学生从长廊穿过。第一个学生把号码凡是1的倍数的电灯的开关拉一下；接着第二个学生把号码凡是2的倍数的电灯的开关拉一下；
        //        接着第三个学生把号码凡是3的倍数的电灯的开关拉一下；...
        //        如此继续下去，最后第n个学生把号码凡是n的倍数的电灯的开关拉一下。
        //        计算n个学生按此规定走完后，长廊里电灯有几盏亮着。（注意：电灯数 和 学生数一致）
                
        // 思路：取反操作，切换电灯状态（开/关）
        
        System.out.println("长廊里的电灯数量（也就是学生数量）：");
        Scanner input = new Scanner(System.in);
        int number = input.nextInt();
        input.close();
        
        // 定义剩余亮着的灯的数量
        int stillOnNumber = 0;
        
        if (number < 1 || number > 65535) {
            System.out.println("输入的范围不在1 ≤ n ≤ 65535内");
        } else {
            // 因为灯的状态只有开和关，所以考虑创建一个boolean类型的数组
            boolean[] arrLight = new boolean[number];
            
            // 开始电灯全部关闭（这步可以省略，因为boolean类型数组元素的默认值就是false）
//            for (boolean item : arrLight) {
//                item = false;
//            }
            
            // 所谓的拉一下灯，都是对灯当前的状态进行取反的操作
            // 第n个学生把号码凡是n的倍数的电灯的开关拉一下，感觉需要使用循环
            for (int i = 1; i <= number; i++) {        // i表示学生号
                // 下句可以进行改进，因为倍数至少是和自身一样大的数，也就是比自己小的数字不用再去浪费循环比较了
//                for (int j = 1; j <= number; j++) {        // j表示灯号
                // 优化写法1、
//                for (int j = i; j <= number; j++) {        // j表示灯号
//                    // 第n个学生寻找n的倍数
//                    if (j % i == 0) {
//                        // 取反操作
//                        arrLight[j - 1] = !arrLight[j - 1];
//                    }
//                }
                
                // 优化写法2、考虑到j从i的值开始算起，统计的是倍数，所以直接在循环时加若干倍
                for (int j = i; j <= number; j += i) {        // j表示灯号
                    // 取反操作
                    arrLight[j - 1] = !arrLight[j - 1];
                }
            }
            
            // 统计一下亮着的灯（状态为true）的数量
            for (boolean item : arrLight) {
                // 写法1
//                if (item == true) {
//                    stillOnNumber++;
//                }
                
                // 写法2
                if (item) {
                    stillOnNumber++;
                }
            }
            
            System.out.println("n个学生按此规定走完后，长廊里电灯有" + stillOnNumber + "盏亮着");
        }
    }
}

package cn.temptation;

public class Sample05 {
    // 成员变量
    // 注意：因为静态的成员方法只能访问静态的成员变量
    // 初始的酒的数量
    static int number = 10 / 2;
    
    public static void main(String[] args) {
        // 需求：某啤酒2元一瓶，现在做活动，2个空瓶或4个瓶盖可以换1瓶啤酒。现有10元，最多可以喝多少瓶啤酒？（注意：不可以赊欠）
        
        // 思路：兑换的操作终止的条件时，剩下的酒瓶数量没有2个 或 剩下的瓶盖数量没有4个
        
        // 因为初始的酒的数量会在不同的成员方法中使用，所以就不应该再定义为局部变量了，考虑使用成员变量
        // 初始的酒的数量
//        int defaultNumber = 10 / 2;
        
        // 兑换
        exchange(number, number);
    }
    
    /**
     * 兑换方法
     * @param bottle    酒瓶
     * @param cap        瓶盖
     * @return
     */
    public static void exchange(int bottle, int cap) {
        if (bottle >= 2 || cap >= 4) {
            // 兑换后剩余的酒瓶数量    =  当次酒瓶兑换的酒瓶数量 + 当次酒瓶未能兑换的酒瓶数量   + 当次瓶盖兑换的酒瓶数量
            int x = bottle / 2 + bottle % 2 + cap / 4;
            // 兑换后剩余的瓶盖数量    =  当次瓶盖兑换的酒瓶数量（也就是瓶盖数量） + 当次瓶盖未能兑换的瓶盖数量 + 当次酒瓶兑换的酒瓶数量
            int y = cap / 4 + cap % 4 + bottle / 2;
            
            // 每次兑换，兑换来的酒的数量应该加在初始数量之上
            number += (bottle / 2 + cap / 4);
            
            // 再次调用兑换方法
            exchange(x, y);
        } else {        // 不再进行兑换的条件
            System.out.println("剩余的酒瓶数量为：" + bottle);
            System.out.println("剩余的瓶盖数量为：" + cap);
            System.out.println("最多可以喝" + Sample05.number + "瓶啤酒");
        }
    }
}