笔记06-基础练习

基础练习

1.减肥计划

输入星期数，显示今天的减肥活动 周一：跑步 周二：游泳 周三：慢走 周四：动感单车 周五：拳击 周六：爬山
周日：好好吃一顿

思路：
1:键盘录入一个星期数，用一个变量接收
2:对星期数进行判断，这里用 if 语句实现
3:在对应的语句控制中输出对应的减肥活动

package com.itdemo_01;
/*
减肥计划if版本
输入星期数，显示今天的减肥活动   周一：跑步   周二：游泳   周三：慢走   周四：动感单车   周五：拳击   周六：爬山
  周日：好好吃一顿
 */
import java.util.Scanner;
public class Test01 {
    public static void main(String[] args) {
        //变量初始化
        Scanner sc = new Scanner(System.in);
//      接收数据
        System.out.println("输入星期数");
        int x = sc.nextInt();

        if(x ==1){
            System.out.println("周一:跑步");
        }else if(x == 2){
            System.out.println("周二:游泳");
        }else if (x==3){
            System.out.println("周三:慢走");
        }else if (x==4){
            System.out.println("周四:动感单车");
        }else if (x==5){
            System.out.println("周五:拳击");
        }else if (x==6){
            System.out.println("周六:爬山");
        }else if (x==7){
            System.out.println("周日:好好吃一顿");
        }else{
            System.out.println("输入数字错误");
        }
    }
}

2.减肥计划switch版本

输入星期数，显示今天的减肥活动 周一：跑步 周二：游泳 周三：慢走 周四：动感单车 周五：拳击 周六：爬山
周日：好好吃一顿
思路
1:键盘录入一个星期数，用一个变量接收
2:对星期数进行判断，这里用 switch 语句实现
3:在对应的语句控制中输出对应的减肥活动

package com.itdemo_01;
/*
减肥计划switch版
输入星期数，显示今天的减肥活动   周一：跑步   周二：游泳   周三：慢走   周四：动感单车   周五：拳击   周六：爬山
  周日：好好吃一顿
 */
import java.util.Scanner;
public class Test02 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("输入星期数");
        int x = sc.nextInt();

//        对星期数进行判断
        switch (x){
            case 1:
                System.out.println("周一:跑步");
                break;
            case 2:
                System.out.println("周二:游泳");
                break;
            case 3:
                System.out.println("周三:慢走");
                break;
            case 4:
                System.out.println("周四:动感单车");
                break;
            case 5:
                System.out.println("周五:拳击");
                break;
            case 6:
                System.out.println("周六:爬山");
                break;
            case 7:
                System.out.println("周日:好好吃一顿");
                break;
            default:
                    System.out.println("输入错误");

        }
    }
}

3.逢七跳过

逢七跳过
朋友聚会的时候可能会玩一个游戏：逢七过。规则是：从任意一个数字开始报数，
当你要报的数字包含7或者是7 的倍数时都要说：过。为了帮助大家更好的玩这个游戏，这里我们直接在控制台打印出1-100之间的满足逢七必过 规则的数据.这样，大家将来在玩游戏的时候，就知道哪些数据要说：过。
思路：
1:数据在1-100之间，用for循环实现数据的获取 2:根据规则，用if语句实现数据的判断：要么个位是7，要么十位是7，要么能够被7整除 3:在控制台输出满足规则的数据

package com.itdemo_01;
/*
逢七跳过
朋友聚会的时候可能会玩一个游戏：逢七过。
规则是：从任意一个数字开始报数，
当你要报的数字包含7或者是7 的倍数时都要说：过。
为了帮助大家更好的玩这个游戏，
这里我们直接在控制台打印出1-100之间的满足逢七必过 规则的数据。
  这样，大家将来在玩游戏的时候，就知道哪些数据要说：过。
 */
public class Test03 {
    public static void main(String[] args) {
        //循环1-100之间数据
        for(int x =1 ;x<=100;x++){
            //判断:7的倍数,个位为7,十位为7
            if(x%7==0 || x%10==7 || x/10%10 ==7){
                //输出
                System.out.print(x+"\t");
            }
        }
        System.out.println();
    }
}

4.不死神兔

不死神兔
有一对兔子，从出生后第3个月起每个月都生一对兔子，
兔子长到第三个月后每个月又生一对兔子，
假如兔子都 不死，问第二十个月的兔子对数为多少？
思路:
1:为了存储多个月的兔子对数，定义一个数组，用动态初始化完成数组元素的初始化，长度为20
2:因为第1个月，第2个月兔子的对数是已知的，都是1，所以数组的第1个元素，第2个元素值也都是1
3:用循环实现计算每个月的兔子对数
4:输出数组中最后一个元素的值，就是第20个月的兔子对数

package com.itdemo_01;
/*
不死神兔
有一对兔子，从出生后第3个月起每个月都生一对兔子，
兔子长到第三个月后每个月又生一对兔子，
假如兔子都 不死，问第二十个月的兔子对数为多少？
 */
public class Test04 {
    public static void main(String[] args) {
        //定义一个数组,用动态初始化完成数组初始化长度为20'
        int[] arr = new int[20];
        //第一月第二月为1,数组从0开始
        arr[0] =1;
        arr[1] =1;

        //循环,实现兔子每月的对数
        for(int x =2 ; x<arr.length;x++){
            arr[x] = arr[x-2]+arr[x-1];
        }
        System.out.println("第二十个月兔子的对数是"+arr[19]);
    }
}

5.百钱白鸡

我国古代数学家张丘建在《算经》一书中提出的数学问题：鸡翁一值钱五，鸡母一值钱三，鸡雏三值钱一。
百钱买百鸡，问鸡翁、鸡母、鸡雏各几何？

分析:
设公鸡为x只,母鸡y只,雏鸡z只,下面式子成立
x+y+z=100;
5x+3y+z/3 = 100;
如果单独只看一种鸡型，则下面的式子是成立的
0<=x<=20
0<=y<=33
0<=z<=100
使用穷举法就可以罗列出x，y，z的值。

思路:
1.第1层循环，用于表示鸡翁的范围，初始化表达式的变量定义为 x=0，判断条件是x<=20
2.第2层循环，用于表示鸡母的范围，初始化表达式的变量定义为 y=0，判断条件是y<=33
3.这个时候，用于表示鸡雏的变量 z = 100 – x – y
4.判断表达式 z%3==0 和表达式 5x + 3y + z/3 = 100 是否同时成立，如果成立，输出对应的 x，y，z 的值，
就是对应的鸡翁，鸡母，鸡雏的值

package com.itdemo_01;

import java.util.zip.ZipEntry;

/*
百鸡百钱
 */
public class Test05 {
    public static void main(String[] args) {

        //公鸡循环 x个数 范围0到20
        for(int x = 0; x<=20;x++){
//            母鸡循环个数 母鸡范围0到33
            for(int y =0;y<=33;y++ ){
                //鸡雏个数
                int z=100-x-y;

                //判断 雏鸡是3的倍数并且 百钱买百鸡
                if(z%3==0 && 5*x+3*y+z/3 ==100){
                    System.out.println("公鸡"+x+"母鸡"+y+"雏鸡"+z);
                }
            }
        }
    }
}

6.数组元素求和

需求:有这样的一个数组，元素是{68,27,95,88,171,996,51,210}。求出该数组中满足要求的元素和，要求是：求和的元素个位和十位都不能是7，并且只能是偶数
分析:
1.先定义一个数组,进行初始化
2遍历数组
3.判断条件,个位数不是7,十位不是7,并且是偶数
4.求和,
5.输出

package com.itdemo_01;
/*
数组元素求和
需求：有这样的一个数组，
元素是{68,27,95,88,171,996,51,210}。
求出该数组中满足要求的元素和，
要求是：求和的元素个位和十位都不能是7，并且只能是偶数

 */
public class Test06 {
    public static void main(String[] args) {
//        定义一个数组
        int[] arr ={68,27,95,88,171,996,51,210};
        //定义一个求和变量,初始值为0
        int sum =0;
        //遍历数组
        for(int x = 0; x<arr.length;x++){
            //判断元素是否满足条件
            if(arr[x]%10 != 7 && arr[x]/10%10 != 7 && arr[x]%2==0){
                //将遍历的数进行相加求和
                sum += arr[x];
            }
        }
        System.out.println("数组元素的和是:"+sum);

    }
}

7.判断两个数组是否相同

需求设计一个方法，用于比较两个数组的内容是否相同.
分析:
1.定义两个数组,静态初始化
2.定义一个方法,用于比较两个数组的内容是否相同
返回值 boolean
参数 int[] arr1 int[] arr2
3.比较两个数组内容,
数组长度,遍历,比较数组元素,只要元素不同就false,两者都相同true
4.调用方法,用变量接收
5.输出

package com.itdemo_01;
/*
数组内容相同\
设计一个方法,用于比较两个数组的内容是否相同
 */
public class Test07 {
    public static void main(String[] args) {
        //定义两个数组,进行静态初始化
        int[] arr1 = {1, 3, 4, 5, 6, 7};
//        int[] arr2 = {2, 3, 4, 5, 6, 7};
        int[] arr2 ={1,3,4,5,6,7};

        //调用方法,y用变量接收
        boolean flag = compare(arr1,arr2);
//      输出
        System.out.println(flag);
    }

    //定义方法,
    /*
        返回值类型 boolean
        参数:int[] arr1; int[] arr2
     */
    public static boolean compare(int[] arr1, int[] arr2) {
        //判断arr1和arr2的长度是否相同
        if (arr1.length != arr2.length) {
            return false;
        }
        //遍历数组1
        for (int x = 0; x < arr1.length; x++) {
            //比较数组1和数组2相同位置上的数是否相同
            if (arr1[x] != arr2[x]) {
                return false;
            }
        }
        //遍历循还结束后
        return true;
    }
}

8.案例查找

需求:
已知一个数组 arr = {19, 28, 37, 46, 50}; 键盘录入一个数据，查找该数据在数组中的索引，并在控制台输出找到的索引值。
分析:
键盘录入一个数据后,让这个数据和数组中的一个元素进行比较,如果数据值相等,返回该数值对应的索引即可
但是如果录入的是一个不存在的数,返回-1
需求:
1.定义一个数组,用静态初始化进行初始化
2.键盘录入
3.定义一个索引变量,初始值为-1
4.遍历数组,获取数组中的每一个元素
5.拿键盘录入的数据和数组中的每一个元素进行比较,相同赋值给索引变量,并结束循环,
6.输出

package com.itdemo_01;
/*
查找
已知一个数组 arr = {19, 28, 37, 46, 50};
键盘录入一个数据，查找该数据在数组中的索引，
并在控制台输出找到的索引值。

 */
import java.util.Scanner;
public class Test08 {
    public static void main(String[] args) {
        //定义一个数组
        int[] arr ={19,28,37,46,50};
        //定义键盘录入变量
        Scanner sc = new Scanner(System.in);
        //键盘录入
        System.out.println("请输入数据");
        int number= sc.nextInt();

        //调用方法
        int index= getIndex(arr,number);
        System.out.println("输出"+index);

    }

    //定义方法
    /*
        明确
            返回类型 int
            参数 int[] arr int number
     */
    public static int getIndex(int[] arr,int number){
        //定义一个索引变量
        int index = -1;
        //遍历数组
        for(int x =0; x<arr.length;x++){
            //将录入数据和数组数据比较
            if(arr[x] == number){
                index = x;
                break;
            }
        }
        //返回索引
        return  index;
    }
}

9 .反转

已知一个数组 arr = {19, 28, 37, 46, 50}; 用程序实现把数组中的元素值交换,交换后的数组 arr = {50, 46, 37, 28, 19}; 并在控制台输出交换后的数组元素。
分析:
1,定义一个数组,静态初始化
2.循环遍历数组,这一次初始化语句定义两个索引变量,判断条件是开始索引小于等于结束索引
3.变量交换
4.遍历数组
在主方法内

package com.itdemo_01;
/*
反转:
已知一个数组 arr = {19, 28, 37, 46, 50};
用程序实现把数组中的元素值交换，
交换后的数组 arr = {50, 46, 37, 28, 19};
并在控制台输出交换后的数组元素。

 */
public class Test09 {
    public static void main(String[] args) {
        //定义数组
        int[] arr = {19,28,37,46,50};

        //循环遍历数组  将数组内数字交换
        for(int start=0 ,end=arr.length-1;start<=end;start++,end--){
            int temp =arr[start];
            arr[start] = arr[end];
            arr[end] =temp;
        }
        //输出
        System.out.print("[");
        for (int x=0;x<arr.length;x++){
            if(x==arr.length-1){
                System.out.print(arr[x]);
            }else{
                System.out.print(arr[x]+",");
            }
        }
        System.out.println("]");
    }
}

使用索引

package com.itdemo_01;

public class Test09_1 {
    public static void main(String[] args) {
        //定义数组
        int[] arr = {19,28,37,46,50};

        //调用反转放啊
        reverse(arr);
        //调用循环方法
        printArray(arr);
    }
    //定义方法 反转方法
    /*
    明确:1.返回值类型 void 2.参数 int[] arr
     */
    public static void reverse(int[] arr){
        //循环遍历数组,初始化语句内定义两个索引变量,
        for(int start=0,end=arr.length-1;start<=end;start++,end--){
            //变量转换
            int temp =arr[start];
            arr[start] =  arr[end];
            arr[end]= temp;
        }
    }
    //定义一个方法,遍历数组
    /*
    明确: 1.返回值类型 void ,参数 int[] arr
     */
    public static void printArray(int[] arr){
        System.out.print("[");

        for (int x =0; x<arr.length;x++){
            if (x == arr.length-1){
                System.out.print(arr[x]);
            }else{
                System.out.print(arr[x]+",");
            }
        }
        System.out.println("]");
    }
}

10.评委打分

需求:
在编程竞赛中，有6个评委为参赛的选手打分，分数为0-100的整数分。选手的最后得分为：去掉一个最高分和一个最低分后 的4个评委平均值 (不考虑小数部分)。
思路:
1.定义一个数组,用动态初始化长度为6
2.键盘录入分数
3.由于是6个评委,所以接收评委分数的操作用循环改进
4.定义方法实现获取数组中最高分调用方法
5.定义方法实现获取数组最低分调用方法
6.定义方法实现获取数组中所有元素的和,调用方法
7.按照计算规则进行计算的到平均分
8.输出平均分

package com.itdemo_01;

import java.util.Scanner;

/*
在编程竞赛中，有6个评委为参赛的选手打分，
分数为0-100的整数分。
选手的最后得分为：去掉一个最高分和一 个最低分后
 的4个评委平均值 (不考虑小数部分)。
 */
public class Test10 {
    public static void main(String[] args) {
        //定义数组,动态初始化
        int[] arr = new int[6];

        //键盘录入
        Scanner sc= new Scanner(System.in);
        //用循环输入六个成绩
        for (int x=0;x<arr.length;x++){
            System.out.println("请输入第"+(x+1)+"个评委的份上");
            arr[x] = sc.nextInt();
        }
        //调用最大值
        int max =getMax(arr);
        //调用最小值
        int min =getMin(arr);
        //调用和
        int sum = getSum(arr);
        //计算平均分
        int avg = (sum - max - min)/(arr.length-2);

        System.out.println("选手的最终得分是:"+avg);

    }

    //定义方法 获取最大值
    /*
    明确:返回值类型 int
        参数:int[] arr
     */
    public static int getMax(int[] arr){
        //初始化
        int max = arr[0];
        for(int x =1 ; x<arr.length;x++){
            if(arr[x]>max){
                max = arr[x];
            }
        }
        return max;
    }
    //定义方法 获取最小值
    /*
    明确:返回值类型 int
        参数:int[] arr
     */
    public static int getMin(int[] arr){
        //初始化
        int min = arr[0];
        for(int x =1 ; x<arr.length;x++){
            if(arr[x]<min){
                min= arr[x];
            }
        }
        return min;
    }

    //定义方法 获取和值
    /*
    明确:返回值类型 int
        参数:int[] arr
     */
    public static int getSum(int[] arr){
        //初始化
        int sum= arr[0];
        for(int x =0 ; x<arr.length;x++){
            sum += arr[x];
        }
        return sum;
    }

}