精华内容
下载资源
问答
  • JAVA 简单高效的金额随机分配 算法
    千次阅读
    2019-02-27 18:02:19
    
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.List;
    import java.util.Random;
    
    public class SplitRedPacket {
    
        // 最小红包额度
        private static final int MINMONEY = 100;
        // 最大红包额度
        private static final int MAXMONEY = 900;
    
    
        /**
         * @Description: 随机拆分红包
         * @Author: liumeng
         * @Date: 2019/2/27
         * @Param: [money, count]
         * @Return: java.util.List<java.lang.Integer>
         **/
        public static List<Integer> splitRedPackets(int money, int count) {
    
            if(money < count*MINMONEY || money > count* MAXMONEY){
                System.out.println("不可拆分");
                return null;
            }
            // 先预留出 count 份 minS , 其余的做随机
            int moreMoney = money-count*MINMONEY;
            List<Integer> list = new ArrayList<Integer>();
            for(int i=0; i<count; i++){
                int one = random(moreMoney,count-i, MINMONEY, MAXMONEY);
                list.add(one+MINMONEY);
                moreMoney = moreMoney-one;
            }
            Collections.shuffle(list);
            return list;
        }
    
    
        /**
         * @Description: 随机红包数额(加上minS 为实际金额)
         * @Author: liumeng
         * @Date: 2019/2/27
         * @Param: [money, count]
         * @Return: java.util.List<java.lang.Integer>
         **/
        private static int random(int money,  int count, int minS, int maxS) {
            // 红包数量为1,直接返回金额
            if (count == 1) {
                return money;
            }
            // 每次限定随机数值
            // 首先判断实际最小值
            int realMinS = money-(maxS-minS)*(count-1);
            int realRange ;
            // 如果存在实际最小值,则在实际最小值realMinS 和 maxS-minS 之间 random 数值
            if(realMinS > 0){
                realRange = maxS-minS-realMinS + 1;
            }
            //  如果不存在实际最小值(也就是说数值可以是minS)
            else{
                if(money > maxS-minS){
                    realMinS = 0;
                    realRange = maxS-minS + 1;
                }else{
                    realMinS = 0;
                    realRange = money + 1;
                }
            }
    
            return  new Random().nextInt(realRange) + realMinS;
    
    
        }
    
    
    
        public static void main(String[] args) {
            int money = 2500 ;
            int count = 6;
            for(int i=0; i<7; i++) {
                List list = splitRedPackets(money, count);
                if (list != null) {
                    System.out.println("随机拆分" + money + "拆分" + count + "份:" + list);
                }
            }
        }
    
    }
    
    更多相关内容
  • 红包随机分配算法

    2017-05-12 14:31:38
    红包随机分配算法
  • 按金额平均分配任务量算法实例需求背景思路分析代码实现 需求背景 需要批量分配订单给人员,尽量保证分配到每个人的订单金额相近。 思路分析 比如100个任务,每个任务ID和金额及号为(T100,100)…(t1,1)。第一轮...

    JAVA按金额平均分配任务量,随机分配,指定数量分配算法实例

    需求背景

    需要批量分配订单给人员,尽量保证分配到每个人的订单金额相近。可以按照金额平均分配,随机分配,指定数量分配。

    思路分析

    比如100个任务,每个任务ID和金额及号为(T100,100)…(T1,1)。第一轮分配先取最大的任务金额的分配给User1,即user1拥有T100,user2分配到T99,user3分配到T98。第二轮分配最小值,User1分配T1,User2分配T2,User3分配T3,第三轮分配最大值,即User1分配T97,User2分配T96,以此类推。

    在这里插入图片描述

    代码实现

    • JDK必须是1.8及以上,代码中使用了1.8的特性,不多废话上代码

    .

    import java.io.*;
    import java.math.BigDecimal;
    import java.util.ArrayList;
    import java.util.Comparator;
    import java.util.List;
    import java.util.Map;
    import java.util.concurrent.ConcurrentHashMap;
    import java.util.stream.Collectors;
    
    /**
     * @ClassName Allot
     * @Desc TODO
     * @Author chengp
     * @Date 2019/1/11 9:55
     * @Verion 1.0
     */
    public class Allot {
    
    
        /**
         * 按金额分配
         *
         * @param users 人
         * @param tasks 任务
         * @return
         */
        public static Map<String, List<DemoTask>> allotOfAmount(List<DemoUser> users, List<DemoTask> tasks) {
            //Collections.shuffle(users);//随机排序
            Map<String, List<DemoTask>> allot = new ConcurrentHashMap<>(); //保存分配的信息
            if (users != null && users.size() > 0 && tasks != null && tasks.size() > 0) {
                List<DemoTask> copyTask = depCopy(tasks);//深拷贝,在处理过程中会删除已经分配的任务此处方便记录原始数据使用
                for (int n = 0; n < copyTask.size() + n; n++) {
                    if (n % 2 == 0) {
                        copyTask = sortTask(copyTask, "desc");//正排
                    } else {
                        copyTask = sortTask(copyTask, "asc");//倒排
                    }
                    for (int j = 0; j < users.size(); j++) {
                        if (copyTask.isEmpty()) break;
                        if (allot.containsKey(users.get(j).getUserId().toString())) {
                            List<DemoTask> list = allot.get(users.get(j).getUserId().toString());
                            list.add(copyTask.get(0));//每次取排序后的第一条
                            allot.put(users.get(j).getUserId().toString(), list);
                        } else {
                            List<DemoTask> list = new ArrayList<>();
                            list.add(copyTask.get(0));
                            allot.put(users.get(j).getUserId().toString(), list);
                        }
                        copyTask.remove(copyTask.get(0));//分配后删除
    
                    }
                }
            }
            return allot;
        }
    
        /**
         * 平均分配&指定数量分配,多余的任务不予分配
         *
         * @param users 人
         * @param tasks 任务
         * @param count 每人指定分配数量
         * @return
         */
        public static Map<String, List<DemoTask>> allotOfAverage(List<DemoUser> users,   List<DemoTask> tasks, Integer count) {
            Collections.shuffle(users);//随机排序
            Collections.shuffle(tasks);
            Map<String, List<DemoTask>> allot = new ConcurrentHashMap<>(); //保存分配的信息
            if (users != null && users.size() > 0 && tasks != null && tasks.size() > 0) {
                for (int i = 0; i < tasks.size(); i++) {
    
                    if (count != null && (i >= count * users.size())) {
                        break;
                    }
                    int j = i % users.size();
                    if (allot.containsKey(users.get(j).getUserId().toString())) {
                        List<DemoTask> list = allot.get(users.get(j).getUserId().toString());
                        list.add(tasks.get(i));
                        allot.put(users.get(j).getUserId().toString(), list);
                    } else {
                        List<DemoTask> list = new ArrayList<>();
                        list.add(tasks.get(i));
                        allot.put(users.get(j).getUserId().toString(), list);
                    }
                }
            }
            return allot;
        }
        /**
         * 深拷贝
         *
         * @param srcList
         * @param <T>
         * @return
         */
        public static <T> List<T> depCopy(List<T> srcList) {
            ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
            try {
                ObjectOutputStream out = new ObjectOutputStream(byteOut);
                out.writeObject(srcList);
    
                ByteArrayInputStream byteIn = new ByteArrayInputStream(byteOut.toByteArray());
                ObjectInputStream inStream = new ObjectInputStream(byteIn);
                List<T> destList = (List<T>) inStream.readObject();
                return destList;
            } catch (IOException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
            return null;
        }
    
    
        /**
         * 排序
         *
         * @param taskList
         * @param sort
         * @return
         */
        private static List<DemoTask> sortTask(List<DemoTask> taskList, String sort) {
            List<DemoTask> newList;
            if ("asc".equalsIgnoreCase(sort)) {//正序
                newList = taskList.stream().sorted(Comparator.comparing(DemoTask::getAmount))
                        .collect(Collectors.toList());
            } else if ("desc".equalsIgnoreCase(sort)) {//倒叙 reversed()即可
                newList = taskList.stream().sorted(Comparator.comparing(DemoTask::getAmount).reversed())
                        .collect(Collectors.toList());
            } else {
                newList = taskList;
            }
            return newList;
        }
    
    
        public static class  DemoUser{
            private Integer userId;
            private String userName;
    
            public Integer getUserId() {
                return userId;
            }
    
            public void setUserId(Integer userId) {
                this.userId = userId;
            }
    
            public String getUserName() {
                return userName;
            }
    
            public void setUserName(String userName) {
                this.userName = userName;
            }
    
            @Override
            public String toString() {
                return "DemoUser{" +
                        "userId=" + userId +
                        ", userName='" + userName + '\'' +
                        '}';
            }
        }
    
    
        public static class DemoTask implements Serializable{
    
            private Integer taskId;
    
            private BigDecimal amount;
    
            public Integer getTaskId() {
                return taskId;
            }
    
            public void setTaskId(Integer taskId) {
                this.taskId = taskId;
            }
    
            public BigDecimal getAmount() {
                return amount;
            }
    
            public void setAmount(BigDecimal amount) {
                this.amount = amount;
            }
    
            @Override
            public String toString() {
                return "DemoTask{" +
                        "taskId=" + taskId +
                        ", amount=" + amount +
                        '}'+'\n';
            }
        }
        public static void main(String[] args) {
    
            List<DemoUser> userList = new ArrayList<>();
            DemoUser entity = new DemoUser();
            entity.setUserId(1);
            userList.add(entity);
            DemoUser entity2 = new DemoUser();
            entity2.setUserId(2);
            userList.add(entity2);
            DemoUser entity3 = new DemoUser();
            entity3.setUserId(3);
            userList.add(entity3);
    
            List<DemoTask> taskList = new ArrayList<>();
            DemoTask apply1 = new DemoTask();
            apply1.setTaskId(1);
            apply1.setAmount(new BigDecimal(1000));
            taskList.add(apply1);
            DemoTask apply2 = new DemoTask();
            apply2.setTaskId(2);
            apply2.setAmount(new BigDecimal(1200));
            taskList.add(apply2);
            DemoTask apply3 = new DemoTask();
            apply3.setTaskId(3);
            apply3.setAmount(new BigDecimal(800));
            taskList.add(apply3);
            DemoTask apply4 = new DemoTask();
            apply4.setTaskId(5);
            apply4.setAmount(new BigDecimal(600));
            taskList.add(apply4);
            DemoTask apply5 = new DemoTask();
            apply5.setTaskId(5);
            apply5.setAmount(new BigDecimal(1600));
            taskList.add(apply5);
            DemoTask apply6 = new DemoTask();
            apply6.setTaskId(6);
            apply6.setAmount(new BigDecimal(2100));
            taskList.add(apply6);
            DemoTask apply7 = new DemoTask();
            apply7.setTaskId(7);
            apply7.setAmount(new BigDecimal(1210));
            taskList.add(apply7);
    
            DemoTask apply8 = new DemoTask();
            apply8.setTaskId(8);
            apply8.setAmount(new BigDecimal(1120));
            taskList.add(apply8);
    
            DemoTask apply9 = new DemoTask();
            apply9.setTaskId(9);
            apply9.setAmount(new BigDecimal(1310));
            taskList.add(apply9);
    
            DemoTask apply10 = new DemoTask();
            apply10.setTaskId(10);
            apply10.setAmount(new BigDecimal(1050));
            taskList.add(apply10);
    
            DemoTask apply11 = new DemoTask();
            apply11.setTaskId(11);
            apply11.setAmount(new BigDecimal(1500));
            taskList.add(apply11);
            List<DemoTask> copyTask = depCopy(taskList);
    
            Map<String, List<DemoTask>> map = allotOfAmount(userList,copyTask);
    
            System.out.println(map);
        }
    }
    
    

    执行结果:
    在这里插入图片描述
    结果分析:
    在这里插入图片描述
    根据结果看已经实现了我们要的效果了
    www.aniba.cn

    展开全文
  • 直接上代码,不啰嗦,复制可... //分配承接人 List<String> nameList = new ArrayList<>(); nameList.add("张三"); nameList.add("王五"); nameList.add("赵六"); nameList.add("李四"); //打乱li

    直接上代码,不啰嗦,复制可直接用

    @Test
        public void test111() {
            //分配承接人
            List<String> nameList = new ArrayList<>();
            nameList.add("张三");
            nameList.add("王五");
            nameList.add("赵六");
            nameList.add("李四");
            //打乱list顺序,这样避免余数每次都分配到第一个人上面
            Collections.shuffle(nameList);
            //待分配人员
            List<String> clientList = new ArrayList<>();
            clientList.add("客户1");
            clientList.add("客户2");
            clientList.add("客户3");
            clientList.add("客户4");
            clientList.add("客户5");
            clientList.add("客户6");
            clientList.add("客户7");
            clientList.add("客户8");
            clientList.add("客户9");
    //        clientList.add("客户10");
    //        clientList.add("客户11");
    //        clientList.add("客户12");
    //        clientList.add("客户13");
    //        clientList.add("客户14");
    //        clientList.add("客户15");
    //        clientList.add("客户16");
    
            //总客户数
            Integer clientCount = clientList.size();
            //总分配人数
            Integer userCount = nameList.size();
            //余数
            Integer remainderCount = clientCount % userCount;
            //每个人分配数
            Integer divideCount = clientCount / userCount;
            System.out.println("总客户数:" + clientCount + " 总销售数:" + userCount + " 余数:" + remainderCount + " 除数:" + divideCount);
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < userCount; i++) {
                for (int j = 0; j <= divideCount; j++) {
                    sb.setLength(0);
                    if (userCount * (j) + i <= clientList.size() - 1) {
                        sb.append(nameList.get(i)).append(clientList.get(userCount * (j) + i));
                        System.out.println(sb.toString());
                    }
                }
            }
        }
    

    算法学习,java实现数据平均分配

    文章对https://blog.csdn.net/qq_44729754/article/details/108712747进行修改而得。

    如有疑问还请各位大佬指点,谢谢!

    展开全文
  • 主要介绍了java语言实现权重随机算法完整实例,具有一定借鉴价值,需要的朋友可以参考下。
  • 基于JAVA的快速随机分配优化算法的研究.pdf
  • Java实现红包随机分配算法

    千次阅读 2017-05-24 17:31:55
    闲来无事,突然想起来红包随机分配算法要怎么实现,经过一阵子思考,勉强用CAS操作和锁两种方式实现了该算法,但对于CAS实现的方式心里没底,我没办法证明算法的正确性,只能简单的重复执行该算法10000次这种恶劣的...

    闲来无事,突然想起来红包随机分配算法要怎么实现,经过一阵子思考,勉强用CAS操作和锁两种方式实现了该算法,但对于CAS实现的方式心里没底,我没办法证明算法的正确性,只能简单的重复执行该算法10000次这种恶劣的方式来验证。真心希望有这方面经验的朋友可以交流一下,互相学习。还有个问题是,我把两种算法分别执行10000次的记录耗时,结果发现锁方式比CAS快,这有点出乎意料之外。但事后又想想CAS方式在竞争比较大的情况下,不停尝试然后失败确实挺耗费时间的。

    package test1.Test1;
    
    import java.math.BigDecimal;
    import java.util.Iterator;
    import java.util.concurrent.ConcurrentLinkedQueue;
    import java.util.concurrent.CountDownLatch;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.atomic.AtomicInteger;
    import java.util.concurrent.atomic.AtomicReference;
    
    /**
     * 红包随机分配算法,每一个红包必须大于最小值小于平均值的2倍
     *
     */
    public class HongBaoAlgorithm {
    	//每个红包的最小金额
    	private static final double MIN = 0.01;
    	
    	class HongBao{
    		//红包总金额
    		private AtomicReference<BigDecimal> amount = new AtomicReference<BigDecimal>();
    		//红包个数
    		private AtomicInteger count;
    		//红包总金额
    		private BigDecimal hbAmount;
    		private int hbCount;//红包个数
    		//上面的两对参数分别对应CAS和锁操作
    		public HongBao(double amount,int count){
    			this.amount.set(new BigDecimal(amount));
    			this.count = new AtomicInteger(count);
    			this.hbAmount = new BigDecimal(amount);
    			this.hbCount = count;
    		}
    		
    		/**
    		 * 用CAS操作随机分配一个红包
    		 * @return
    		 */
    		public double assignHongBao(){
    			while(true){
    				//如果红包个数为0,则表示红包也被抢完,返回0
    				if(count.get()<=0){
    					return 0.0;
    				}
    				//如果是最后一个红包则直接将剩余的金额返回
    				if(count.get()==1){
    					BigDecimal c = amount.get();
    					if(amount.compareAndSet(c, new BigDecimal(0))){
    						count.decrementAndGet();
    						return c.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
    					}else{//如果最后一个红包金额修改失败,则表示最后一个红包已被抢走,已没有剩余红包,直接返回0
    						return 0.0;
    					}
    				}
    				BigDecimal balanceAmount = amount.get();
    				int balanceCount = count.get();
    				if(balanceCount==0){
    					return 0.0;
    				}
    				//求出剩余红包金额和个数的平均值
    				double avg = balanceAmount.divide(new BigDecimal(balanceCount),8,BigDecimal.ROUND_HALF_UP).doubleValue();
    				//随机获取一个MIN到2倍平均值之间的值
    				double cur = getRandom(MIN, avg*2);
    				//获取剩余金额和分配金额的差值
    				double b = balanceAmount.add(new BigDecimal(-cur)).doubleValue();
    				//由于每个红包至少是MIN这么大,此处获取剩余红包个数应该有的最小的红包金额,
    				//比如MIN=0.01,那么如果这次分配之后还剩2个红包,则金额至少要剩下2分钱,不然不够分
    				double c = new BigDecimal(balanceCount-1).multiply(new BigDecimal(MIN)).doubleValue();
    				//分配之后剩余金额b  需大于等于   剩余的最小值c,如果不满足则重新分配红包大小,直到满足要求
    				while(b < c){
    					cur = getRandom(MIN, avg*2);
    					b = balanceAmount.add(new BigDecimal(-cur)).doubleValue();
    				}
    				//如果是最后一个红包则直接将剩余的金额返回,
    				//在返回结果之前再一次执行这个判断的目的是为了在多线程情况如果在返回结果之前已经被抢到只剩最后一个的时候
    				//还是返回随机获得金额的话则会导致总金额不会被抢完
    				if(count.get()==1){
    					BigDecimal c1 = amount.get();
    					if(amount.compareAndSet(c1, new BigDecimal(0))){
    						count.decrementAndGet();
    						return c1.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
    					}else{//如果最后一个红包金额修改失败,则表示最后一个红包已被抢走,已没有剩余红包,直接返回0
    						return 0.0;
    					}
    				}
    				//CAS更新金额和个数同时成功,则返回随机分配的红包金额
    				if(amount.compareAndSet(balanceAmount, balanceAmount.add(new BigDecimal(-cur)))){
    					count.decrementAndGet();
    					return cur;
    				}
    				
    			}
    			
    
    		}
    		
    		
    		/**
    		 * 用锁控制
    		 * @return
    		 */
    		public synchronized double assignHongBao2(){
    				//如果红包个数为0,则表示红包也被抢完,返回0
    				if(hbCount==0){
    					return 0.0;
    				}
    				//如果是最后一个红包则直接将剩余的金额返回
    				if(hbCount==1){
    					hbCount--;
    					return hbAmount.doubleValue();
    				}
    				//求出剩余红包金额和个数的平均值
    				double avg = hbAmount.divide(new BigDecimal(hbCount),8,BigDecimal.ROUND_HALF_UP).doubleValue();
    				//随机获取一个MIN到2倍平均值之间的值
    				double cur = getRandom(MIN, avg*2);
    				//获取剩余金额和分配金额的差值
    				double b = hbAmount.add(new BigDecimal(-cur)).doubleValue();
    				//由于每个红包至少是MIN这么大,此处获取剩余红包个数应该有的最小的红包金额,
    				//比如MIN=0.01,那么如果这次分配之后还剩2个红包,则金额至少要剩下2分钱,不然不够分
    				double c = new BigDecimal(hbCount-1).multiply(new BigDecimal(MIN)).doubleValue();
    				//分配之后剩余金额b  需大于等于   剩余的最小值c,如果不满足则重新分配红包大小,直到满足要求
    				while(b < c){
    					cur = getRandom(MIN, avg*2);
    					b = hbAmount.add(new BigDecimal(-cur)).doubleValue();
    				}
    				hbAmount = hbAmount.add(new BigDecimal(-cur));
    				hbCount--;
    				return cur;
    		}
    		
    		/**
    		 * 计算两个数之间的随机值,结果保留两位小数
    		 * @param begin
    		 * @param end
    		 * @return
    		 */
    		private double getRandom(double begin,double end){
    			   double random = Math.random();
    			   double amount =  random*(end - begin)+begin;
    			   BigDecimal bg = new BigDecimal(amount);
    			   return bg.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
    		}
    
    	}
    		
    	
    	private static void test(double hbAmount,int hbCount,int personCount) throws InterruptedException{
    		HongBaoAlgorithm h = new HongBaoAlgorithm();
    		final HongBao hb = h.new HongBao(hbAmount,hbCount);
    		int THREAD_COUNT = personCount;
    		ExecutorService pool = Executors.newFixedThreadPool(THREAD_COUNT);
    		final ConcurrentLinkedQueue<Double> total = new ConcurrentLinkedQueue<Double>();
    		final CountDownLatch latch = new CountDownLatch(THREAD_COUNT);
    		for(int i=0;i<THREAD_COUNT;i++){
    			pool.execute(new Runnable() {
    				public void run() {
    					double m = hb.assignHongBao();
    					total.add(m);
    //					if(m>0){
    //						System.out.println(Thread.currentThread().getName()+"抢到:"+m);
    //					}else{
    //						System.out.println(Thread.currentThread().getName()+"没抢到红包");
    //					}
    					latch.countDown();
    				}
    			});
    		}
    		pool.shutdown();
    		latch.await();
    		double amount = 0.0;
    		Iterator<Double> it = total.iterator();
    		while(it.hasNext()){
    			amount += it.next();
    		}
    		amount = new BigDecimal(amount).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
    		//如果分配到的总金额和传入的总金额不相等
    		if(amount!=hbAmount){
    			System.out.println("amount:"+amount);
    		}
    		//计算抢到的红包总额来判断跟设定的金额是否一致,从而判断算法的正确性,很恶劣的方式
    	}
    	
    	public static void main(String[] args) throws InterruptedException{
    		long start = System.currentTimeMillis();
    		//执行10000次,验证一下正确率
    		for(int i=0;i<10000;i++){
    			//9个红包,10个人抢
    			test(100, 9, 10);
    		}
    		System.out.println("用时:"+(System.currentTimeMillis()-start)+"ms");
    	}
    
    }
    



    展开全文
  • 一、简单的平均算法 /* * 平均分配 */ public Map<String,List> allotOfAverage(List users,List tasks){ Map<String,List> allot=new ConcurrentHashMap<String,List>(); //保存分配的...
  • java 分配算法

    2021-02-26 10:13:19
    /** 随机分配*/public Map allotOfRandom(List users,List tasks){Map allot=new ConcurrentHashMap(); //保存分配的信息if(users!=null&&users.size()>0&&tasks!=null&&tasks.size()>...
  • 红包随机算法实现

    2018-08-15 20:38:54
    1.基于Java实现的红包随机分配算法, 2.先抢后抢拿到红包的大小的期望是大致相等的
  • K-means聚类算法是一种迭代求解的聚类分析算法,其步骤是随机选取K个对象作为初始的聚类中心,然后计算每个对象与各个种子聚类中心之间的距离,把每个对象分配给距离它最近的聚类中心。聚类中心以及分配给它们的对象...
  •   在工作中,遇到一个需求:将 N 个单位随机分配给 n 个人,其中每个单位有对应的工作量,分配时要尽量按工作量平均分给 n 个人,且人员的所属单位不能包括在被分配的单位中(N &amp;amp;gt;= n)。例如:有三...
  • 基于JAVA的快速随机分配优化算法的研究
  • 随机分配算法matlab代码明义的硕士论文代码: 这是论文的原始代码:联合异构边缘和雾系统的资源分配:匹配博弈方法。 有几个文件可以处理这些机制。 DataGenerator.java 在此代码中,它可以生成UE的请求和服务器的...
  • Java实现平均分配算法(附代码)

    万次阅读 2019-09-12 09:26:35
    最近公司有业务需求:要求实现批量分配操作,详情如下: 选择多个客户 ...为了实现上述需求,需要设计一个随机平均分配算法 一开始我的设计思路比较简单,遍历员工集合和客户集合,依次分配单个客户给每...
  • java常见算法

    2019-01-17 15:53:59
    1 去重 //去重复,需要额外定义一个List public static void RemoveRepeat(List<Integer> arrs) { List<Integer> tmp = new ArrayList(); Iterator<Integer> it = arrs.iterator();...2 随机分配
  • 随机分配算法(Intege)

    千次阅读 2016-01-08 13:05:56
    参考资料: [url]... [url]http://www.zuidaima.com/code/file/2214023444104192.htm?dir=/2214023444104192.java[/url] 以下为抢红包的随机分配的Integer实现,主要参考以:抢红包的...
  • 存储管理——动态分区分配算法的模拟 要求设计主界面以灵活选择某算法,以下算法都要实现: a、首次适应算法 b、循环首次适应算法 c、最佳适应算法 d、最坏适应算法 e、快速适应算法 具体要求: 1)首先由...
  • 公司有个红包分发业务模块,需要红包随机生成金额,克提供参数为: 1、红包金额(最小精确到厘:0.001,数据库是用int表示,1元也就是1000厘) 2、红包发放数量 3、红包金额上限 4、红包金额下限 5、金额精度(精度...
  • 一种按权重分配Java算法

    千次阅读 2021-02-12 18:28:03
    )分配算法不难,但是用java写起来还是蛮巧妙的~ 觉得很有意思,遂记之。算法设计:1)总的任务数能被权重和整除,则每个人分配的数量就是:总任务数/权重和*权重2)总的任务数不能被权重和整除,则先按整除的数按1)的...
  • 请运行前阅读说明 这是一个银行家算法Java小程序,从文件中读取Max、Allocation矩阵,你也可以选择读取Max矩阵,而随机生成一个Allocation矩阵,代码里面写了详细的注释,帮助阅读
  • 主要为大家详细介绍了Java实现仿微信红包分配规则,介绍一种随机红包分配策略,感兴趣的小伙伴们可以参考一下
  • Java权重分配的实现算法

    千次阅读 2017-04-10 18:03:29
    分配算法不难,但是用java写起来还是蛮巧妙的。 算法设计:1)总的任务数能被权重和整除,则每个人分配的数量就是:总任务数/权重和*权重2)总的任务数不能被权重和整除,则先按整除的数按1)的方式分,然后余数...
  • 微信红包算法在知乎上面有个专题讨论,其实红包的发放的随机算法,有两种作法:java一、预生产:算法无外乎是在发红包的时候,随机去把金额生成到某个容器当中,而后要用的时候,一个一个的POP;微信二、实时随机dom...
  • 最简单的随机数抽签程序!wwenxue.com已打包成双击可运行的exe程序! 基于java swing编写,功能相当简单!非常完美。!大家可以下载测试
  • 可以通过银行家算法、随机分配算法和按序分配算法实现资源分配
  • Java实现游戏抽奖算法

    千次阅读 2021-02-12 10:18:37
    常用抽奖算法对比基础的游戏抽奖算法通常要求实现在指定奖品的集合中,每个奖品根据对对应概率进行抽取。个人了解的主要有以下几中抽奖算法:随机数一一对应算法思想这种算法思想最为简单。将n个奖品编号0 - n-1,...
  • 一种基于平均思想的任务分配算法

    万次阅读 多人点赞 2017-08-28 19:37:52
    假设现在有20个任务需要分配给员工去做,但是每个员工手头上还有未完成的任务,且未完成任务数不同。
  • java实现红包随机分配金额

    千次阅读 2018-11-29 16:22:17
    import java.util.Random; class Scratch {  public static void main(String[] args) {  int count = 5;/个数  double amount = 200;/金额  double singleMin = 0.01;//单个红包最小金额  doub...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 66,540
精华内容 26,616
关键字:

java随机分配算法

java 订阅