博客

Java基础算法题

  • Post author:
  • Post category:java


以创作之名致敬节日

胜固欣然，败亦可喜。 –苏轼


目录


练习1 :


优化代码


扩展 : CRTL + Alt + M 自动抽取方法


练习2:


方法一:


方法二:


方法三:


Math : 顾名思义，Math类就是用来进行数学计算的，它提供了大量的静态方法来便于我们实现数学计算：


练习3 :


练习4:


练习5 :


练习6:


练习7 :


练习8 :


练习9 :


方法一:


方法二:


练习10:

练习1 :

 import java.util.Scanner;
 public class Test1 {
    public static void main(String[] args) {
        //键盘录入数据
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入当前机票的原价");
        int ticket = sc.nextInt();
        System.out.println("请输入当前月份");
        int month = sc.nextInt();
        System.out.println("请输入当前舱位 0头等舱 1经济舱");
        int seat = sc.nextInt();

        //2.先判断旺季 还是 淡季
        if (month >= 5 && month <= 10) {
            //旺季
            if (seat == 0) {
                ticket = (int) (ticket * 0.9);
            } else if (seat == 1) {
                ticket = (int) (ticket * 0.85);
            }else {
                System.out.println("没有这个舱位");
            }
        } else if (month >= 11 && month <= 12 || month <= 1 && month >= 4) {
            //淡季
            if (seat == 0) {
                ticket = (int) (ticket * 0.7);
            } else if (seat == 1) {
                ticket = (int) (ticket * 0.65);
            }else {
                System.out.println("没有这个舱位");
            }
        } else {
            System.out.println("键盘录入不合法");
        }
        System.out.println(ticket);
    } 
}

运行结果:

优化代码

分析:

1. 我要干嘛?  根据舱位和折扣来计算最终的原价

2. 我完成这个需要什么?  原价 舱位 头等舱的折扣 经济舱的折扣

3. 方法的调用处是否需要继续使用该结果? 需要 

import java.util.Scanner;
public class Test1 {
    public static void main(String[] args) {
        //键盘录入数据
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入当前机票的原价");
        int ticket = sc.nextInt();
        System.out.println("请输入当前月份");
        int month = sc.nextInt();
        System.out.println("请输入当前舱位 0头等舱 1经济舱");
        int seat = sc.nextInt();

        //2.先判断旺季 还是 淡季
        if (month >= 5 && month <= 10) {
            //旺季 
            ticket = getArr(ticket,seat,0.9,0.85);
        } else if (month >= 11 && month <= 12 || month <= 1 && month >= 4) {
            //淡季 
            ticket = getArr(ticket,seat,0.7,0.65);
        } else {
            System.out.println("键盘录入的月份不合法");
        }
        System.out.println(ticket);
    }

    //1. 我要干嘛?  根据舱位和折扣来计算最终的原价
    //2. 我完成这个需要什么?  原价 舱位 头等舱的折扣 经济舱的折扣
    //3. 方法的调用处是否需要继续使用该结果? 需要

    public static int getArr(int ticket,int seat ,double d1,double d2){
        if (seat == 0) {
            ticket = (int) (ticket * d1);
        } else if (seat == 1) {
            ticket = (int) (ticket * d2);
        }else {
            System.out.println("没有这个舱位");
        }
        return ticket;
    }
}

扩展 : CRTL + Alt + M 自动抽取方法

选中需要抽取的代码,然后按下快捷键

练习2:

在这道题中,下面罗列了三种方法

方法一:

分析:

思路一 :2~99

定义变量i ,赋值100

判断i是否为质数

第二个for循环的思路分析:

第二个for循环就是取 i 的值，然后依次去除以2,3,4….一直到i-1 求模，如果取模为0，则表示是可以除尽的，那就说明不是质数， flag = false;跳出循环，如果都不为0，则不会改变flag的值，flag是true 就是质数 

public class Test3 {
    public static void main(String[] args) {
        //思路一 :2~99
        //定义变量i ,赋值100
        //判断i是否为质数

        //定义一个变量用来统计有多少个质数
        int count = 0;
        for (int i = 101; i <= 200; i++) {
            //i 表示循环里面的每一个数字
            //继续判断i是否为一个质数
            boolean flag = true;
            for (int j = 2; j < i; j++) {
                //j 表示2~99之间的每一个数字
                if (i % j == 0) {
                    flag = false;
                    break;
                }
            }
            if (flag) {
                System.out.println("当前数字" + i + "是质数");
                count++;
            }
        }
        System.out.println("一共有多少" + count + "个质数");
    }
}

运行结果:

方法二:

public class Test3 {
    public static void main(String[] args) {
      //定义一个变量用来统计有多少个质数
        int count = 0;
        for (int i = 101; i <= 200; i++) {
            boolean isPrime  = true;
            for (int j = 2; j < i; j++) {
                if (i % j == 0) {
                    isPrime  = false;
                    break;
                }
            }
            if (isPrime ) {
                System.out.println(i);
                count++;
            }
        } System.out.println("101-200之间有" + count + "个质数");
    }
}

方法三:

这里使用的一个方法

Math : 顾名思义，

Math

类就是用来进行数学计算的，它提供了大量的静态方法来便于我们实现数学计算：

计算√x：
Math.sqrt(2); // 1.414...
public class Test10 {
    public static void main(String[] args) {
        int count = 0;
        for (int i = 101; i <= 200; i++) {
            if (isPrime(i)) {
                System.out.println(i + " ");
                count++;
            }
        }
        System.out.println();
        System.out.println("101-200之间共有" + count + "个素数");
    }

    //判断一个数是否为质数
    public static boolean isPrime(int n) {
        if (n <= 1) {
            return false;
        }
        for (int i = 2; i <= Math.sqrt(n); i++) {
            if (n % i == 0) {
                return false;
            }
        }
        return true;
    }
}

练习3 :

练习4:

分析:

定义一个老数组并存储一些元素

再定义一个新数组的长度跟老数组一致

遍历老数组, 得到老数组中的每一个元素,依次存入新数组

,的

i 表示老数组中的索引,新数组中的每一个索引

arr[i]  表示老数组中的元素 

public class Test5 {
    public static void main(String[] args) {
        //分析:
        //1.定义一个老数组并存储一些元素
        int[] arr = {1,2,3,4,5};
        //2.定义一个新数组的长度跟老数组一致
        int[] newArr = new int[arr.length];
        //3.遍历老数组,得到老数组中的每一个元素,依次存入新数组中
        for (int i = 0; i < arr.length; i++) {
            //i 表示老数组中的索引,新数组中的每一个索引
            //arr[i] 表示老数组中的元素
            newArr[i] = arr[i];
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(newArr[i]);
        }
    }
}

运行结果:

练习5 :

代码实现: 

import java.util.Scanner;

public class Test6 {
    public static void main(String[] args) {
        //分析:
        //1.定义一个数组,用来存储6名评委的打分(1-100)
        int[] scoreArr = getScores();
        for (int i = 0; i < scoreArr.length; i++) {
            System.out.println(scoreArr[i]);
        }
        //2.求出数组中的最大值
        int max = getMax(scoreArr);

        //3. 求出数组中的最小值
        int min = getMin(scoreArr);

        //4.求出数组中的6个分数的总和
        int sum = getSum(scoreArr);
        //5, (总和-最大值-最小值)/4;
        int avg = (sum - max - min) / (scoreArr.length - 2);//这里为什么要减2,因为要减去最大值和最小值,为什么不直接写4,因为在代码中,最好不要写死,因为随时可能发生变化
        System.out.println("选手的最终得分为" + avg);
    }

    //求和
    public static int getSum(int[] scoreArr) {
        int sum = 0;
        for (int i = 0; i < scoreArr.length; i++) {
            sum = sum + scoreArr[i];
        }
        return sum;
    }

    //定义一个方法求最大值(//2.求出数组中的最大值)
    public static int getMax(int[] scoreArr) {
        int max = scoreArr[0];//必须要是数组里面的元素
        for (int i = 1; i < scoreArr.length; i++) {
            if (scoreArr[i] > max) {
                max = scoreArr[i];
            }
        }
        return max;
    }

    //3. 求出数组中的最小值
    public static int getMin(int[] scoreArr) {
        int min = scoreArr[0];//必须要是数组里面的元素
        //shift + F6 .同时更改名字所有相同
        for (int i = 1; i < scoreArr.length; i++) {
            if (scoreArr[i] < min) {
                min = scoreArr[i];
            }
        }
        return min;
    }

    //1. 我要干嘛?定义一个数组, 用来存储6名评委的打分(1-100)
    //2. 我需要什么? 都不需要
    //3. 干完这件事情,是否需要返回? 必须返回

    public static int[] getScores() {
        //定义数组
        int[] scores = new int[6];//动态数组
        //使用键盘录入的形式,输入分数:0~100
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < scores.length; ) {
            System.out.println("请输入评委的打分");
            int score = sc.nextInt();
            //当数据瞒足要求的时候,才会 进入循环,也才会进行i++的操作,否则将是0
            if (score >= 0 && score <= 100) {
                scores[i] = score;
                i++;
            } else {
                System.out.println("成绩超出了范围,继续录入,当前的i为" + i);
            }

        }
        return scores;
    }
}

结果:

练习6:


扩展:


反转:定义两个指针,左边指针有一个从0开始, 右边有一个指针从最大索引开始,

然后将两个指针所指向的数据进行交换,每次交换完左边的指针++ ,右边的指针–,

当左边的指针比右边的指针小的时候,循环就结束
 

public class Test7 {
    public static void main(String[] args) {
        //分析:
        //1.把整数里面的每一位放到数组当中
        int[] arr = {1, 9, 8, 3};

        //2. 加密
        //每位数加上5
        for (int i = 0; i < arr.length; i++) {
            arr[i] = arr[i] + 5;
        }
        //每位数对10 求余
        for (int i = 0; i < arr.length; i++) {
            arr[i] = arr[i] % 10;
        }
        //将所有数字反转
        /*反转:定义两个指针,左边指针有一个从0开始, 右边有一个指针从最大索引开始,
        然后将两个指针所指向的数据进行交换,每次交换完左边的指针++ ,右边的指针--,
         当左边的指针比右边的指针小的时候,循环就结束*/
        for (int i = 0, j = arr.length - 1; i < j; i++, j--) {
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
        //3. 把数组里面的每一个数字进行拼接,变成加密后的结果
        int number = 0;
        for (int i = 0; i < arr.length; i++) {
            number = number * 10 + arr[i];
        }
        System.out.println(number);
    }
}

运行结果:

练习7 :

把整数上每一位都添加到数组中

public class Test8 {
    public static void main(String[] args) {
        //把整数上每一位都添加到数组中
        //大于 0 的整数
        //反向推导

        //分析:
        //1. 计算数组的长度
        int number = 12345;
        //定义一个临时变量记录number的值,就是为了第三步的时候再次使用
        int temp = number;
        //定义一个变量进行统计
        int count = 0;
        while (number != 0) {
            //每一次循环就去掉右边一个数字
            number = number / 10;
            //去掉一位计数器就自增一次
            count++;
        }

        //2. 需要一个数组
        //动态 
        int[] arr = new int[count];

        //3. 把整数里面的每一位放到数组当中
        int index = arr.length - 1;
        while (temp != 0) {
            //获取 temp里面的每一位数组
            int ge = temp % 10;
            //再去掉右边的那位数字
            temp = temp / 10;
            //把当前获取到的个位添加到数组当中
            arr[index] = ge;
            index--;
        }
        //验证结果
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

运行结果:

练习8 :

 某系统的数字密码(大于0) .比如1983 ,采用加密的方式进行传输,
 规则如下:
 每位数加上5
 再对10求余
 最后将所有数字反转
 得到一串新数
 按照以上规则进行解密
 比如:1983 加密之后变成8346 ,解密之后又变成 1983

public class Test11 {
    public static void main(String[] args) {
        //1.定义数组记录解密之后的结果
        int[] arr = {8,3,4,6};
        //2.反转
        for (int i = 0 ,j = arr.length -1;i<j; i++,j--) {
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
        //3.由于加密是通过对10取余的方式进行获取的
        //所以解密的时候就需要判断,0~4之间+10  5~9之间数字不变
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] >= 0 && arr[i] <= 4){
                arr[i] = arr[i] + 10;
            }
        }
        //4.每一位减5
        for (int i = 0; i < arr.length; i++) {
            arr[i] = arr[i] - 5;
        }
        //5. 获取数组里面的每一位数字拼接成最终的结果
        int number = 0;
        for (int i = 0; i < arr.length; i++) {
           number = number * 10 + arr[i];
        }
        System.out.println(number);
    }
}

运行结果:

练习9 :

方法一:

public class Test13 {
    public static void main(String[] args) {
        //1. 定义数组表示奖池
         int[] arr = {2,588,888,1000,10000};
        //2,定义新数组用于存储抽奖的结果
        int[] newArr = new int[arr.length];
        //3,抽奖
        Random r = new Random();
        //因为有5个将项,所以这里要循环5次
        for (int i = 0; i < 5; ) {
            //获取随机索引
            int randomIndex = r.nextInt(arr.length);
            //获取奖项
            int prize = arr[randomIndex];
            //判断当前的奖项是否存在,如果存在则重新抽取,
            // 如果不存在,就表示是有效奖项
            boolean flag = contains(newArr,prize);
            if(!flag){
                //然后把当前抽取到的奖项添加到newArr中
                newArr[i] = prize;
                //添加完毕之后,移动索引
                i++;
            }
        }
        //遍历newArr
        for (int i = 0; i < newArr.length; i++) {
            System.out.println(newArr[i]);
        }
    }
    //判断prize 在数组当中是否存在
    //存在 true
    //不存在false
    public static boolean contains(int[] arr,int prize){//prise抽到的奖项
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == prize){
                return true;
            }
        }
        return false;
    }
}

运行结果:

方法二:

效率高 ,利用 随机索引把奖池里面的所有奖项都打乱顺序 

public class Test13 {
    public static void main(String[] args) {
        //把奖池里面的所有奖项都打乱顺序
        int[] arr = {2, 588, 888, 1000, 10000};
        Random r = new Random();
        for (int i = 0; i < arr.length; i++) {
            //获取随机索引
            int randomIndex = r.nextInt(arr.length);
            //拿着i跟随机索引randomIndex上的值进行交换
            int temp = arr[randomIndex];
            arr[i] = arr[randomIndex]; //每次打印都将随机的结果
            //arr[randomIndex] = arr[i];  每次打印都是相同的结果,并非随机
            arr[randomIndex] = temp;
        }
        //遍历奖池,从0 索引开始获得每一个奖项
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

运行结果:


练习10:

代码实现: 

import java.util.Random;
import java.util.Scanner;

public class Test14 {
    public static void main(String[] args) {
        //1.生成中奖号码
        int[] arr = createNumber();

        System.out.println("=======================");


        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println("======================");


        //2.用户输入彩票号码(红球+蓝球)
        int[] userInputArr = userInputNumber();
        //3.判断用户的中奖情况
        //红球  蓝球
        int redCount = 0;
        int blueCount = 0;

        //判断红球
        for (int i = 0; i < userInputArr.length - 1; i++) {
            int redNumber = userInputArr[i];
            for (int j = 0; j < arr.length - 1; j++) {
                if (redNumber == arr[j]) {
                    redCount++;
                    //如果找到了,那么后面是数字就没有必要比较了
                    //跳出内循环,继续判断下一个红球号码是否中奖
                    break;
                }
            }
        }
        //判断蓝球中奖
        int blueNumber = userInputArr[userInputArr.length - 1];
        if (blueNumber == arr[arr.length - 1]) {
            blueCount++;
        }

        //判断红球的个数以及蓝球的个数来判断中间情况
        if (redCount == 6 && blueCount == 1) {
            System.out.println("恭喜你,中奖1000万");
        } else if (redCount == 6 && blueCount == 0) {
            System.out.println("恭喜你,中奖500万");
        } else if (redCount == 5 && blueCount == 1) {
            System.out.println("恭喜你,中奖3000");
        } else if (redCount == 5 && blueCount == 0 || redCount == 4 && blueCount == 1) {
            System.out.println("恭喜你,中奖200");
        } else if (redCount == 4 && blueCount == 0 || redCount == 3 && blueCount == 1) {
            System.out.println("恭喜你,中奖10");
        } else if (redCount == 2 && blueCount == 1 || redCount == 1 && blueCount == 1 || redCount == 0 && blueCount == 1) {
            System.out.println("恭喜你,中奖5");
        } else {
            System.out.println("谢谢惠顾");
        }
    }

    public static int[] userInputNumber() {
        //1.创建数组用于添加用户购买的彩票号码
        // 6个红球 1个蓝球 数组长度:7
        int[] arr = new int[7];

        //2. 利用键盘录入让用户输入
        Scanner sc = new Scanner(System.in);
        //让用户输入红球号码
        for (int i = 0; i < 6; ) {
            System.out.println("请输入第一个" + (i + 1) + "个红球号码");
            int redNumber = sc.nextInt();
            //redNumber 在1~33唯一不重复
            if (redNumber >= 1 && redNumber <= 33) {
                boolean flag = contains(arr, redNumber);
                if (!flag) {
                    //不存在
                    //有效的,可以添加到数组中
                    arr[i] = redNumber;
                    i++;
                } else {
                    //存在
                    System.out.println("当前红球号码已经存在,请重新输入");
                }
            } else {
                System.out.println("当前红球号码超出范围");
            }
        }

        //让用户输入蓝球号码
        System.out.println("请输入蓝球号码");
        //1~16
        while (true) {
            int blueNumber = sc.nextInt();
            if (blueNumber >= 1 && blueNumber <= 16) {
                arr[arr.length - 1] = blueNumber;
                break;
            } else {
                System.out.println("当前蓝球号码超出范围");
            }
        }
        return arr;
    }

    public static int[] createNumber() {
        //1.创建数组用于添加中奖号码
        //一等奖  6个红球 1个蓝球 数组长度:7
        int[] arr = new int[7];

        //2. 随机生成号码并添加到数组当中
        //红球:不能重复  1 2 3 4 5 6
        //蓝球:可以跟红球重复 5

        //生成红球号码并添加到数组当中
        Random r = new Random();
        for (int i = 0; i < 6; ) {
            //获取红球号码
            int redNumber = r.nextInt(33) + 1;
            boolean flag = contains(arr, redNumber);
            if (!flag) {
                //把红球号码添加到数组当中
                arr[i] = redNumber;
                i++;
            }
        }
        //生成的蓝球号码并添加到数组当中
        int blueNumber = r.nextInt(16) + 1;
        arr[arr.length - 1] = blueNumber;
        return arr;
    }

    //用于判断数字在数组中是否存在
    public static boolean contains(int[] arr, int number) {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == number) {
                return true;
            }
        }
        return false;
    }
}

运行结果:



版权声明：本文为m0_57448314原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
Tags: