java 算法题input 用java写算法题

前言

这里将会写几个学习java中遇到的题或在力扣上的经典算法题， 也算是记录java学习的历程了吧

1. 双色球问题

题目要求：

实现思路： 动态定义数组， 篮球和红球分两次添加到球池列表中

以下是对应的代码

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

public class PracticeDemo6 {
    public static void main(String[] args) {
        /*
         * 模拟双色球, 红球6个1-33号码中选择且不能重复, 篮球1个 1-16中选择
         * 用户购买双色球,判断用户的数字与中奖号码有多少相同,做出对应奖项
         * */
        int[] arr = getNumberList();

        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println("===============");
        int[] userInput = userInputNumber();
        int redNumber = 0;
        int blueNumber = 0;
        // 判断用户输入的值和系统号码是否相同
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < userInput.length - 1; j++) {
                if (arr[i] == userInput[j]) {
                    redNumber++;
                    break;
                }
            }
        }

        // 判断蓝球的数值是否相等
        if (arr[arr.length - 1] == userInput[userInput.length - 1]) {
            blueNumber++;
        }

        System.out.println("红球中了 " + redNumber + " 个, 蓝球中了 " + blueNumber + " 个");

        if (redNumber == 6 && blueNumber == 1) {
            System.out.println("恭喜你,中了1000万");
        } else if (redNumber == 6 && blueNumber == 0) {
            System.out.println("恭喜你,中了500万");
        } else if (redNumber == 5 && blueNumber == 1) {
            System.out.println("恭喜你,中了3000元");
        } else if ((redNumber == 4 && blueNumber == 1) || (redNumber == 5 && blueNumber == 0)) {
            System.out.println("恭喜你,中了2000元");
        } else if ((redNumber == 3 && blueNumber == 1) || (redNumber == 2 && blueNumber == 1)) {
            System.out.println("恭喜你, 中奖10元");
        } else if ((redNumber == 1 && blueNumber == 1) || (redNumber == 0 && blueNumber == 1)) {
            System.out.println("恭喜你, 中奖5元");
        } else {
            System.out.println("谢谢惠顾,谢谢光临");
        }
    }

    // 获取双色球的数组列表
    public static int[] getNumberList() {
        // 获取数组
        int[] list = new int[7];
        Random rand = new Random();
        for (int i = 0; i < 6; ) {
            // 生成红色球数组
            int randNumber = rand.nextInt(33) + 1;
            boolean flag = contains(list, randNumber);
            if (!flag) {
                list[i] = randNumber;
                i++;
            }
        }
        int blue = rand.nextInt(16) + 1;
        list[list.length - 1] = blue;
        return list;
    }

    public static boolean contains(int[] arr, int number) {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == number) {
                return true;
            }
        }
        return false;
    }

    // 获取用户球的数组
    public static int[] userInputNumber() {
        // 红球6个, 篮球一个
        // 键盘录入,让用户输入彩票号码
        int[] arr = new int[7];
        Scanner scanner = new Scanner(System.in);
        // 获取红球的数组
        for (int i = 0; i < 6; ) {
            System.out.println("请输入第" + (i + 1) + "个红球的数字");
            int redNumber = scanner.nextInt();
            // 判断红球是否超出范围
            if (redNumber >= 1 && redNumber <= 33) {
                boolean flag = contains(arr, redNumber);
                // 如果数字不存在,写入数组中
                if (!flag) {
                    arr[i] = redNumber;
                    i++;
                } else {
                    System.out.println("数字已存在,请重新输入");
                }
            } else {
                System.out.println("不在红球的范围内,请重新输入");
            }
        }


        while (true) {
            System.out.println("请输入蓝球的数字");
            int blueNumber = scanner.nextInt();
            if (blueNumber >= 1 && blueNumber <= 16) {
                arr[arr.length - 1] = blueNumber;
                break;
            }
        }
        return arr;
    }
}

2. 数组乱序

代码如下：这里用到了 随机索引 + 变量交换 的思想

import java.util.Random;

public class PracticeDemo5 {
    public static void main(String[] args) {
        /*
         * 需求：奖池抽奖
         * 在一个奖池中列表中，打乱顺序并且将元素输出，元素不能重复
         * */
        int[] arr = {2, 588, 888, 1000, 10000};
        Random rand = new Random();
        // 将数组打乱顺序
        for (int i = 0; i < arr.length; i++) {
            // 定义随机索引
            int randIndex = rand.nextInt(arr.length);
            int temp = arr[i];
            arr[i] = arr[randIndex];
            arr[randIndex] = temp;
        }

        // 遍历数据，从0索引开始获取每一个奖项
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

    }
}

3. 斯坦福大学java题目： 求选手平均分

题目如下：

思路： 将所有评分添加到列表中， 再求最大值和最小值， 将总分减去最大最小值后求取平均分

代码如下：

import java.util.Random;

public class PracticeDemo4 {
    public static void main(String[] args) {
        /*
         * 评委打分:
         * 需求：有6名评委给选手打分，分值范围是[0-100]之间的整数
         * 选手的最后得分为：去掉最高分、最低分后的平均分，请完成上诉
         * 过程并计算出选手的得分
         * */
        Random rand = new Random();
        int[] scores = new int[6];
        for (int i = 0; i < scores.length; i++) {
            int s = rand.nextInt(101);
            scores[i] = s;
        }

        // 打印数组中的数据, 计算总和
        int sum = 0;
        for (int i = 0; i < scores.length; i++) {
            System.out.print(scores[i] + " ");
            sum += scores[i];
        }

        // 求最大值
        int max = scores[0];
        int min = scores[0];
        for (int i = 0; i < scores.length; i++) {
            if (max < scores[i]) {
                max = scores[i];
            }
        }

        for (int i = 0; i < scores.length; i++) {
            if (min > scores[i]) {
                min = scores[i];
            }
        }
        System.out.println("最小值是:" + max + "最大值是:" + min);
        System.out.println("总数和是: " + sum);
        int avg = (sum - max - min) / (scores.length - 2);
        System.out.println("选手的平均数是：" + avg);
    }
}

4. 生成随机验证码

题目要求:

实现思路： 这里用到了ASCII对应的字母码表，97在码表中对应的字符是 a， 65 代表的 是 A， 不清楚的同学可以去看看哦

代码如下

import java.util.Random;

public class PracticeDemo3 {
    public static void main(String[] args) {
        // 生成随机验证码，要求前四个字符是字母，最后一位是数字
        // 1. 生成字母数组
        char[] chs = new char[52];
        for (int i = 0; i < chs.length; i++) {
            // a 的 字符对应ascii表是97， A是65
            if (i <= 25) {
                chs[i] = (char) (97 + i);
            } else {
                chs[i] = (char) (65 + i - 26);
            }
        }

        // 生成验证码的字符串
        String code = "";
        Random random = new Random();
        for (int i = 0; i < 4; i++) {
            // 生成随机索引
            int randomIndex = random.nextInt(chs.length);
            code += chs[randomIndex];

        }
        // 随机生成一位数字
        int num = random.nextInt(10);
        code += num;
        System.out.println(code);
    }
}

5. 求质数

质数定义： 只能被1 和 本身整除的数字才是质数

题目如下:

实现思路： for循环遍历就完事了

代码如下:

public class ParcticeDemo2 {
    public static void main(String[] args) {
        // 求101 - 200之间的质数, 并打印出来
        int count = 0;
        for (int i = 101; i <= 200; i++) {
            // 求当前数字是不是一个质数
            boolean flag = true;
            for (int j = 2; j < i; j++) {
                if (i % j == 0) {
                    flag = false;
                    // System.out.println(i + "不是一个质数");
                    // break 跳出当前循环
                    break;
                }
            }
            if (flag) {
                System.out.println(i + "是一个质数");
                count++;
            }
        }
        System.out.println("一共有" + count + "个质数");
    }
}

6. 截取数组长度的算法

题目要求:

实现思路： 动态初始话数组, 数组长度由 from 和 to 两个值的差值决定

代码如下：

public class MethodDemo4 {
    public static void main(String[] args) {
        // 定义一个方法 copyOfRange(int[]arr, int from, int to)
        // 功能: 将数组arr中从索引from(包含)开始到
        // 索引to结束, (不包含to)的元素复制到新数组中.将数组返回
        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9};
        int[] result = copyOfRange(arr, 3, 5);
        for (int i = 0; i < result.length; i++) {
            System.out.print(result[i] + ", ");
        }
    }

    public static int[] copyOfRange(int[] arr, int from, int to) {
        int[] array = new int[to - from];
        int arrayIndex = 0;
        for (int i = from; i < to; i++) {
            array[arrayIndex] = arr[i];
            arrayIndex++;
        }
        return array;
    }
}

6. 数组算法

题目如下:

这个需求对应大多数同学应该都比较简单， 这里就不多赘述了

代码如下:

public class MethodDemo3 {
    public static void main(String[] args) {
        // 需求: 编写一个方法进行数组遍历, 打印的结果是 字符串 [11, 22, 33,44, 55]
        int[] array = {11, 22, 33, 44, 55};
        //  forArr(array);

        // 需求二: 设计一个方法求数组的最大值
        /*int result = maxNumber(array);
        System.out.println(result);*/

        // 需求三: 判断数组中的某一个数是否存在,将结果返回给调用处
        boolean result = isNumber(11, array);
        System.out.println(result);
    }

    public static void forArr(int[] arr) {
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1) {
                System.out.print(arr[i]);
            } else {
                System.out.print(arr[i] + ", ");
            }
        }
        System.out.print("]");
    }

    public static int maxNumber(int[] arr) {
        int max = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (max < arr[i]) {
                max = arr[i];
            }
        }
        return max;
    }

    public static boolean isNumber(int num, int[] arr) {
        boolean result = false;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == num) {
                result = true;
                break;
            }
        }
        return result;
    }
}

7. 数组练习

这里直接上代码吧。里面的需求比较多, 包括 索引调换， 数组乱序， 求最大值等

import java.util.Random;

public class ArrayDemo3 {
    public static void main(String[] args) {
        /*
         * 动态函数初始化：
         * 初始化时只指定数组长度，由系统为数组分配初始值
         * 格式： 数据类型[] 数组名 = new 数据类型[数组长度]
         * 例子  int[] arr = new int[3]  => 指定数组长度为3的数组
         * 如果数组中的值没有达到指定长度，那么它会被系统中的一些数据代替
         * Strint[] => null
         * int[] => 0
         * double[] => 0.0
         * char[] => '\0000'
         * */
        // 数组练习
        /*
         * 1. 已知数组元素为[33, 5, 22, 44, 55]
         * 请找出最大值并打印到控制台
         * */

        /*
        int[] arr = {33, 5, 22, 44, 55, 16};
        int max = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (max < arr[i]) {
                max = arr[i];
            }
        }

        System.out.println(max);*/

        /*
         *遍历数组求和
         * 需求： 生成10个 1 - 100 之间的随机数存入数组
         * 1. 求所有数组的和
         * 2. 求所有数组的平均数
         * 3. 统计有多少个数据比平均数小
         * */
        /*
        Random random = new Random();
        int[] array = new int[100];
        // 统计总和
        int sum = 0;
        // 生成数组
        for (int i = 0; i < 100; i++) {
            // 随机数
            int number = random.nextInt(100) + 1;
            // 将随机数添加到arr中
            array[i] = number;
            sum += number;
        }
        // 数组中所有数据的和
        int avg = sum / array.length;
        // 数组中多少个小于平均数
        int count = 0;
        System.out.println("总和是:" + sum);
        for (int i = 0; i < array.length; i++) {
            if (array[i] < avg) {
                count++;
            }
        }
        System.out.println("总和是:" + sum);
        System.out.println("平均数是:" + avg);
        System.out.println("小于平均数的有:" + count + "个");*/
        /*
         * 交换数组中的数据 索引调换
         * 需求: 定义一个数组,存入1.2.3,4,5
         * 交换前: 1, 2, 3, 4,5
         * 交换后 5, 4, 3,2,1
         * */

        /*
        int[] arr = {1, 2, 3, 4, 5};
        for (int i = 0, j = arr.length - 1; i < j; i++, j--) {
            //   交换变量
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }

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

        /*
         * 需求:定义一个数组,存入1-5,要求打乱数组中所有数据的排序
         * */

        int[] arr = {1, 2, 3, 4, 5};
        Random random = new Random();
        int randomIndex = random.nextInt(arr.length);

        for (int i = 0; i < arr.length; i++) {
            int temp = arr[i];
            arr[i] = arr[randomIndex];
            arr[randomIndex] = temp;
        }

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

8. 力扣算法题：判断数字是不是回文数

题目：

实现思路： 定义临时变量存储x的值， 再将x进行while循环，将x分解

代码如下:

// 假如x的123
int x  = 123;
int temp = x;
// 待比较的回文数
int num = 0;
while (x != 0) {
    int ge = x % 10; // 第一次循环 个位数为 3， 第二次循环 个位数为2， 三次循环 个位数为1
    x = x / 10;  // 第一次 x = 12 第二次 x = 1 第三次 x = 0
    num = num * 10 + ge;  // 第一次 3， 第二次 32， 第三次 321
}
System.out.println(num == temp);

9. 算法： 求商和余数

题目要求：

实现思路：

利用减法进行循环运算

主体代码如下:

int num1 = 100;  // 被除数
int num2 = 8;   // 除数
int sum = 0;    // 商
int yu = 0;     // 余数
while (num1 >= num2) {
    num1 -= num2;
    sum += 1;

    if (num1 < num2) {
        yu = num1;
    }
}
System.out.println("商为:" + sum);
System.out.println("余数:" + yu);

最后

以上就是一些java的基础算法题目啦， 试试能不能自己做出来呢， 最后， 点个赞吧