Java 双色球抽号算法的两种实现思路对比

题目:实现双色球彩票随机出号,六个红球,一个蓝球。并顺序输出

双色球规则:

“双色球”彩票投注区分为红色球号码区和蓝色球号码区。

“双色球”每注投注号码由6个红色球号码和1个蓝色球号码组成。

红色球号码从1--33中选择;蓝色球号码从1--16中选择。

两种思路:

  • 随机6个不同的1-33范围内的数字(需要考虑重复问题)
  • 模拟现实生活抽号场景
普通思路(随机数)

6个数需要随机且不能重复,所以需要实现思路,主要是针对红球

  • 创建长度为 6 的数组
  • 循环随机出1-33范围内数字,放入数组
    • 放入时需要先判断是否已经在数组中存在,如果存在,则重新随机。
  • 对数组排序
  • 打印输出

具体代码如下:

    public static void caipiao(){
        Random random = new Random();
        int[] red = new int[6];
        for (int i = 0; i < red.length; ) {
            int rand = random.nextInt(33);//产生一个随机数 
            //放入之前 要把rand和数组中的元素 逐一比较 看是否存在,存在则重新随机

            boolean isExist = false;
            //给定rand数  判断rand是否在数组red中存在
            for (int j = 0; j < i+1; j++) {
                if(rand==red[j]){//判断是否数组中存在此数
                    isExist = true;//表示 数是存在于数组中的
                    break;
                }
            }
            //放入
            if(isExist==false){
                red[i] = rand;
                i++; //注意:只有放入成功后,才能修改下次放入的下标位置
            }
        }
      //生成一个篮球
        int blue = random.nextInt(16);
        Arrays.sort(red);//排序
        System.out.println(Arrays.toString(red)+"+"+blue);
    }

上面的算法,存在的主要问题就是每次随机数都是一个独立的事件,所以每次的随机数是不可控,可能出现重复,所以就需要在放入前先判断重复问题。

但是在现实场景的抽号中是不存在判断重复问题的,因为,从箱子里取出的号码是不会再放入箱子的。下次抽取的号码是在之前抽出的剩余的号码中抽取的。

模拟抽奖思路

模拟真实场景下的抽号过程:

  • 在一个箱子中放入编号为 1-33 的红球
  • 在一个箱子中放入编号为 1-16 的蓝球
  • 把两个箱子摇一摇,尽量打乱
  • 分别从两个箱子中取出 6个红色球和 1个蓝色球

具体代码如下:

import java.util.*;

/**
 * 模拟真实场景下的抽号过程
 */
public class Test1 {
    public static void main(String[] args) {
        caipiao();
    }
    public static void caipiao(){

        //用来存放1-33红色球的箱子
        List<Integer> redBox = new ArrayList<>(33);
        //用来存放1-16蓝色球的箱子
        List<Integer> blueBox = new ArrayList<>(16);

        //依次放入33个红球和16个蓝球
        for (int i = 1; i <= 33 ; i++) {
            redBox.add(i);
            if(i>16){
                continue;
            }
            blueBox.add(i);
        }

        //随机打乱(摇箱子,打乱箱内球为无序)
        Collections.shuffle(redBox);
        Collections.shuffle(blueBox);

        //从红球箱子中取出6个球
        List<Integer> redList = redBox.subList(0,6);
        Integer blueBall = blueBox.get(0);


        Collections.sort(redList);//排序
        System.out.println(redList+"+"+blueBall);
    }
}

哪一个思路更好呢?你有没有其他思路?评论区留言讨论 

  • 10
    点赞
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
磁盘调度算法是操作系统中用于管理磁盘的一种算法,它的主要目的是优化磁盘的读写效率,提高磁盘的利用率。常见的磁盘调度算法有:FCFS(先来先服务)、SSTF(最短寻道时间优先)、SCAN(扫描算法)、C-SCAN(循环扫描算法)等。下面是 Java 实现磁盘调度算法的模拟实现及对比。 1. FCFS(先来先服务) FCFS 算法是最简单的磁盘调度算法,它按照请求的先后顺序进行磁盘访问,即先请求的先被服务。Java 代码如下: ```java public class FCFS { public static void main(String[] args) { int[] requests = {40, 10, 35, 80, 25}; int head = 50; int total = 0; for (int i = 0; i < requests.length; i++) { int distance = Math.abs(requests[i] - head); total += distance; head = requests[i]; } System.out.println("Total Seek Time: " + total); } } ``` 2. SSTF(最短寻道时间优先) SSTF 算法是按照当前磁头位置与请求队列中下一个请求的磁道距离最近,优先服务距离最短的请求。Java 代码如下: ```java public class SSTF { public static void main(String[] args) { int[] requests = {40, 10, 35, 80, 25}; int head = 50; int total = 0; while (requests.length > 0) { int minDistance = Integer.MAX_VALUE; int minIndex = -1; for (int i = 0; i < requests.length; i++) { int distance = Math.abs(requests[i] - head); if (distance < minDistance) { minDistance = distance; minIndex = i; } } total += minDistance; head = requests[minIndex]; int[] newRequests = new int[requests.length - 1]; int j = 0; for (int i = 0; i < requests.length; i++) { if (i != minIndex) { newRequests[j++] = requests[i]; } } requests = newRequests; } System.out.println("Total Seek Time: " + total); } } ``` 3. SCAN(扫描算法) SCAN 算法是按照磁头当前位置对请求进行扫描,服务请求队列中当前磁头位置下方的请求,直到最底端,然后改变磁头移动方向,服务上方的请求,直到最顶端,循环执行。Java 代码如下: ```java public class SCAN { public static void main(String[] args) { int[] requests = {40, 10, 35, 80, 25}; int head = 50; int total = 0; int direction = 1; // 1: move to right, -1: move to left Arrays.sort(requests); int index = Arrays.binarySearch(requests, head); if (index < 0) { index = -(index + 1); } while (index < requests.length && index >= 0) { int distance = Math.abs(requests[index] - head); total += distance; head = requests[index]; if (index == requests.length - 1) { direction = -1; } index += direction; } total += head; head = 0; while (index < requests.length && index >= 0) { int distance = Math.abs(requests[index] - head); total += distance; head = requests[index]; index += direction; } System.out.println("Total Seek Time: " + total); } } ``` 4. C-SCAN(循环扫描算法) C-SCAN 算法是类似 SCAN 算法,不同之处在于磁头到达磁盘底端时,不返回磁盘顶端,而是直接返回磁盘底端,形成一个循环执行的过程。Java 代码如下: ```java public class CSCAN { public static void main(String[] args) { int[] requests = {40, 10, 35, 80, 25}; int head = 50; int total = 0; int direction = 1; // 1: move to right, -1: move to left Arrays.sort(requests); int index = Arrays.binarySearch(requests, head); if (index < 0) { index = -(index + 1); } while (index < requests.length && index >= 0) { int distance = Math.abs(requests[index] - head); total += distance; head = requests[index]; if (index == requests.length - 1) { direction = -1; total += (requests[requests.length - 1] - requests[0]); head = 0; index = Arrays.binarySearch(requests, head); if (index < 0) { index = -(index + 1); } } else { index += direction; } } System.out.println("Total Seek Time: " + total); } } ``` 以上就是 Java 实现磁盘调度算法的模拟实现及对比。根据不同的磁盘访问情况,选择不同的磁盘调度算法,可以有效提高磁盘的读写效率,提高系统的性能。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

zp8126

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值