精华内容
下载资源
问答
  • 平均分配

    千次阅读 2020-03-05 21:23:45
    上游系统给本系统一批订单,数量x条(),本系统订单平均分配给下游系统的员工中 2 方案 先算出每个员工分出的订单总数,放到数组中,然后员工id放入map的key中 相应的订单数放进map的value中 在分配的时候,根据...
    
    1 背景:
        上游系统给本系统一批订单,数量x条(),本系统将订单平均分配给下游系统的员工中
    
    2 方案
        先算出每个员工分出的订单总数,放到数组中,然后将员工id放入map的key中
        相应的订单数放进map的value中
        在分配的时候,根据map中的员工id和相应的总数去做分配
    3 分配方法
        OrderCount : 订单总数
        staffCount : 员工总数
        A: 商 = OrderCount / staffCount , 余数 = OrderCount % staffCount
        B: 商 == 0  订单总数<员工总数 每个员工分配1个
        C: 商 > 0 && 余数 == 0 平均分配
        D: 商 > 0 && 余数 > 0  不平均分配
      这三种情况都要照顾到 

     

    package com.sitech.huxiao.batch.ElectricCanalAgentBatch;
    
    import com.google.common.collect.Lists;
    import com.google.common.collect.Maps;
    import com.sitech.huxiao.domin.DistributionRuleEntity;
    
    import org.springframework.util.CollectionUtils;
    
    import java.util.List;
    import java.util.Map;
    
    /**
     * @oauth: qiangSW
     * @date: 2020/3/5 21:12
     * @description: com.sitech.huxiao.batch.ElectricCanalAgentBatch
     * @doc:
     */
    public class Demo {
    
        /**
         * 平均分配
         *
         * @param orderCount 订单总数
         * @param staffCount 员工总数
         * @return int[] 每个员工分配的总数
         */
        public int[] distribution(List<Object> orderCount, int staffCount) {
            Map<String, Integer> map = Maps.newHashMap();
            List<DistributionRuleEntity> list = Lists.newArrayList();
            if (CollectionUtils.isEmpty(orderCount) || staffCount == 0) {
                return null;
            }
            int agentMean = orderCount.size() / staffCount;
            int agentRemainder = orderCount.size() % staffCount;
            /*计算每个员工应该分配的总数*/
            int[] agentCount = null;
            if (agentMean == 0) {
                agentCount = meanEqual0(staffCount);
            } else if (agentMean > 0 && agentRemainder == 0) {
                agentCount = meanGreater0(staffCount, agentMean);
            } else if (agentMean > 0 && agentRemainder > 0) {
                agentCount = meanAndRemainderGreater0(staffCount, agentMean, agentRemainder);
            }
    
            return agentCount;
        }
    
        /**
         * 平均数 == 0
         *
         * @param number
         * @return
         */
        public int[] meanEqual0(int number) {
            int[] array = new int[number];
            for (int i = 0; i < number; i++) {
                array[i] = 1;
            }
            return array;
        }
    
        /**
         * 平均数 > 0 余数 == 0
         *
         * @param arraySize
         * @param mean
         * @return
         */
        public int[] meanGreater0(int arraySize, int mean) {
            int[] array = new int[arraySize];
            for (int i = 0; i < arraySize; i++) {
                array[i] = mean;
            }
            return array;
        }
    
        /**
         * 平均数 > 0 余数 >0
         *
         * @param arraySize
         * @param mean
         * @param remainder
         * @return
         */
        public int[] meanAndRemainderGreater0(int arraySize, int mean, int remainder) {
            int[] array = new int[arraySize];
            for (int i = 0; i < arraySize; i++) {
                if (remainder != 0 && i == remainder) {
                    array[i] = mean + 1;
                } else {
                    array[i] = mean;
                }
            }
            return array;
        }
    }
    

     

     

     

    展开全文
  • 平均分配算法

    千次阅读 2019-10-29 01:58:46
    最近公司有业务需求:要求实现批量分配操作,详情如下: 选择多个客户 ...为了实现上述需求,需要设计一个随机平均分配算法 一开始我的设计思路比较简单,遍历员工集合和客户集合,依次分配单个客户给每个...
    最近公司有业务需求:要求实现批量分配操作,详情如下:
    
    选择多个客户
    选择多个员工
    给每个员工分配客户
    要求分配的客户数量尽量平均
    选择的员工数大于选择的客户数时,一个员工分配一个客户,不够的就不分配
    选择的员工数等于客户数时,一个员工对应一个客户
    分配的客户最好是随机的。
    为了实现上述需求,需要设计一个随机平均分配算法
    一开始我的设计思路比较简单,遍历员工集合和客户集合,依次分配单个客户给每个员工,直到分完为止,但是这种实现效率很低,也达不到随机的效果。
    转变思路,先分析、设计数据存储结构,入参为两个List<String>集合,返回数据类型为:
    一、 Map<String, List<String>>,每个员工作为key,value为分配的客户列表;
    二、List<Map<String, List<String>>>,员工作为key,value为分配给他的客户,每个员工-客户列表都对应一个Map<String, List<String>>集合,这样所有的员工-客户列表组合成一个List<Map<String, List<String>>>集合
    最终我采用了第二种数据结构,下面是实现代码:
    import com.google.common.collect.Lists;
    import com.google.common.collect.Maps;
    import com.google.common.collect.Sets;
    import org.apache.commons.collections.CollectionUtils;
    import org.apache.commons.lang3.RandomStringUtils;
    import org.apache.commons.lang3.RandomUtils;
    import org.apache.commons.lang3.StringUtils;
    
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.List;
    import java.util.Map;
    import java.util.Set;
    
    /**
    * @author gxl
    * @version 1.0
    * @description 平均分配算法
    * @date 2019-09-11 08:53
    */
    public class AverageDataUtil {
    
       /**
        * 定义存储待分配数据集合
        */
       private static List<String> list = Lists.newArrayList();
    
       /**
        * 定义存储分组数据的结构,Map去除泛型,适配多种数据类型格式,使用时需注意
        */
       private static List<Map> los = Lists.newArrayList();
    
       /**
        * 供外部调用的平均分配方法
        *
        * @param visitorIds 客户列表
        * @param sellerIds  员工列表
        * @return List<Map>
        */
       public static List<Map> averageData(List<String> visitorIds, List<String> sellerIds) {
           initCollections(visitorIds, sellerIds);
           if (visitorIds.size() >= sellerIds.size()) {
               groupByData(los.size());
               return getMaps();
           } else {
               groupByData(list.size());
               return getMaps();
           }
       }
    
       /**
        * 返回数据,清空静态缓存
        *
        * @return List<Map>
        */
       @NotNull
       private static List<Map> getMaps() {
           List<Map> listMap = Lists.newArrayList();
           listMap.addAll(los);
           //清空静态数据
           los = Lists.newArrayList();
           list = Lists.newArrayList();
           return listMap;
       }
    
       /**
        * 分配数据
        *
        * @param size       分组大小
        */
       private static void groupByData(int size) {
           List<String> augmented = list;
    
           List<List<String>> lists = chunk2(augmented, size);
    
           for (int i = 0; i < size; i++) {
               Map map = los.get(i);
               Iterator iterator = map.keySet().iterator();
               if (iterator.hasNext()) {
                   String next = (String) iterator.next();
                   map.put(next, lists.get(i));
               }
           }
       }
    
       /**
        * 初始化集合数据
        *
        * @param visitorIds 待分配数据
        * @param sellerIds  分配目标
        */
       private static void initCollections(List<String> visitorIds, List<String> sellerIds) {
           //每次调用前清空数据
           if (list.size() > 0) {
               list = Lists.newArrayList();
           }
           if (los.size() > 0) {
               los = Lists.newArrayList();
           }
           list.addAll(visitorIds);
           List<Map<String, List<String>>> list1 = new ArrayList<>();
           for (String sellerId : sellerIds) {
               Map<String, List<String>> map = new HashMap<>(16);
               List<String> list = new ArrayList<>();
               map.put(sellerId, list);
               list1.add(map);
           }
           los.addAll(list1);
       }
    
       /**
        * 分组数据-核心算法,勿动
        *
        * @param list  需分配数据
        * @param group 分组大小
        * @param <T>   分组数据泛型
        * @return 分组结果
        */
       private static <T> List<List<T>> chunk2(List<T> list, int group) {
           if (CollectionUtils.isEmpty(list)) {
               return Lists.newArrayList();
           }
           List<List<T>> result = Lists.newArrayList();
           Map<Integer, Set<T>> temp = Maps.newHashMap();
           for (int i = 0; i < list.size(); i++) {
               if (temp.containsKey(i % group)) {
                   Set<T> ts = temp.get(i % group);
                   ts.add(list.get(i));
                   temp.put(i % group, ts);
               } else {
                   Set<T> ts = Sets.newHashSet();
                   ts.add(list.get(i));
                   temp.put(i % group, ts);
               }
           }
           for (Set<T> ts : temp.values()) {
               result.add(Lists.newArrayList(ts));
           }
           return result;
       }
       
       public static void main(String[] args) {
           List<String> visitorIds = new ArrayList<>();
           visitorIds.add("aa");
           visitorIds.add("bb");
           visitorIds.add("cc");
           visitorIds.add("dd");
           visitorIds.add("ee");
           visitorIds.add("ff");
           visitorIds.add("gg");
           visitorIds.add("hh");
           visitorIds.add("ii");
           visitorIds.add("jj");
           visitorIds.add("kk");
           List<String> sellerIds = new ArrayList<>();
           sellerIds.add("11");
           sellerIds.add("22");
           sellerIds.add("33");
           sellerIds.add("44");
           sellerIds.add("55");
           sellerIds.add("66");
           sellerIds.add("77");
           sellerIds.add("88");
           sellerIds.add("99");
           sellerIds.add("1010");
           sellerIds.add("1111");
           List<Map> maps = averageData(visitorIds, sellerIds);
           System.out.println(maps);
       }
    
    }
    
    
    这个代码可能还存在部分问题,可以继续优化改进,有什么建议的话,可以在评论区回复,毕竟我也只是个码农,对算法什么的不是很了解 - -
    

     

    展开全文
  • #平均分配list数据到4个list中 def ave_test(): #list1 = [[1,2]] #list1 = [[1,2],[3,4]] #list1 = [[1,2],[3,4],[5,6]] #list1 = [[1,2],[3,4],[5,6],[7,8]] list1 = [[1,2],[3,4],[5,6],[7,8],[56,1],...

    #平均分配list数据到4个list中
    def ave_test():
        #list1 = [[1,2]]
        #list1 = [[1,2],[3,4]]
        #list1 = [[1,2],[3,4],[5,6]]
        #list1 = [[1,2],[3,4],[5,6],[7,8]]
        list1 = [[1,2],[3,4],[5,6],[7,8],[56,1],[57,1],[36,1]]
        print("len:")
        print(len(list1))
        li1=[]
        li2=[]
        li3=[]
        li4=[]

        len1=len(list1)
        x = 0
        x1=0
        m=0
        y1=0

        if len1==1:
            li1 = list1
        if len1 == 2:
            for i in range(len(list1)):
                if i == 0:
                    li1.append(list1[i])
                else:
                    li2.append(list1[i])
        if len1 == 3:
            for i in range(len(list1)):
                if i == 0:
                    li1.append(list1[i])
                elif i == 1:
                    li2.append(list1[i])
                else:
                    li3.append(list1[i])
        if len1>3:
            l2 = len1//2;
            m = l2
            print("m")
            print(m)
            if m>0:
                x1=m//2
                print("x1:")
                print(x1)
                if (len1-m)>1:
                    t= (len1-m)//2
                    y1=m+t
                    print("y1")
                    print(y1)
            for i in range(len(list1)):
                if i<x1:
                    li1.append(list1[i])
                elif i>=x and i<m:
                    li2.append(list1[i])
                elif i>=m and i<y1:
                    li3.append(list1[i])
                else:
                    li4.append(list1[i])
        if li1:
           print("li1")
           print(li1)
        if li2:
           print("li2")
           print(li2)
        if li3:
           print("li3")
           print(li3)
        if li4:
           print("li4")
           print(li4)
    #end ave
    '''
    运行结果:
    li1
    [[1, 2]]
    li2
    [[3, 4], [5, 6]]
    li3
    [[7, 8], [56, 1]]
    li4
    [[57, 1], [36, 1]]
    '''

    展开全文
  • Java平均分配算法

    千次阅读 2019-08-09 15:07:01
    1万个设备的IMEI固定且尽量平均分配到四个组。 算法 算法来自文章【数据结构与算法】一致性Hash算法及Java实践 public static int FnvHash(String key) { final int p = 16777619; long hash = (int) 2166136261...

    需求

    1万个设备的IMEI固定且尽量平均的分配到四个组。

    算法

    算法来自文章【数据结构与算法】一致性Hash算法及Java实践

    public static int FnvHash(String key) {
            final int p = 16777619;
            long hash = (int) 2166136261L;
            for (int i = 0, n = key.length(); i < n; i++) {
                hash = (hash ^ key.charAt(i)) * p;
            }
            hash += hash << 13;
            hash ^= hash >> 7;
            hash += hash << 3;
            hash ^= hash >> 17;
            hash += hash << 5;
            return ((int) hash & 0x7FFFFFFF) ;
    }
    

    示例

    	@Test
        public void contextLoads() {
        	//imei前缀
            String base = "86582003";
            //a,b,c,d,分别记录四组分到的imei个数
            int a = 0;
            int b = 0;
            int c = 0;
            int d = 0;
            for (int i = 0; i < 10000; i++) {
            	//模拟15位的imei码
                String str = base + (int) (Math.random() * 9) * 10 + "" + (int) ((Math.random() * 9 + 1) * 100000);
                //模4 将FnvHash算法得到的固定结果分成四组
                int hash = FnvHash(str)%4;
                switch (hash){
                    case 0:a++;break;
                    case 1:b++;break;
                    case 2:c++;break;
                    case 3:d++;break;
                }
            }
            System.out.println("a:" + a);
            System.out.println("b:" + b);
            System.out.println("c:" + c);
            System.out.println("d:" + d);
            System.out.println("a+b+c+d:" + (a + b + c + d));
        }
    

    多次实验结果

    还比较满意,每次都比较均匀

    a:2475
    b:2526
    c:2497
    d:2502
    a+b+c+d:10000
    
    a:2494
    b:2514
    c:2485
    d:2507
    a+b+c+d:10000
    
    a:2482
    b:2486
    c:2499
    d:2533
    a+b+c+d:10000
    
    展开全文
  • php平均分配算法

    千次阅读 2014-05-26 18:39:40
    最近碰到一个需求,一个一级分类加一个数值,其下的二级分类要平均
  • 有一批不同金额的数据,需要按金额分配给系统内的用户,比如 数据1:3000,数据2:2000,数据3:4900,那么分配给2个用户的话,肯定是A用户分配数据1跟数据2,B用户分配数据3,这样才能做到近似的金额平均。...
  • Java实现平均分配算法(附代码)

    千次阅读 2019-09-12 09:26:35
    最近公司有业务需求:要求实现批量分配操作,详情如下: 选择多个客户 ...为了实现上述需求,需要设计一个随机平均分配算法 一开始我的设计思路比较简单,遍历员工集合和客户集合,依次分配单个客户给每...
  • 按金额平均分配任务量算法实例需求背景思路分析代码实现 需求背景 需要批量分配订单给人员,尽量保证分配到每个人的订单金额相近。 思路分析 比如100个任务,每个任务ID和金额及号为(T100,100)…(t1,1)。第一轮...
  • java平均分配算法

    千次阅读 2010-05-07 13:26:10
    100个数平均分配到指定数量的人 第一种方法 [code="java"] public class Fenpei { static List listCus = new ArrayList(); static List persons = new ArrayList(); // static Map result...
  • 场景:有N张图片,M种图片类型,每张图片可以同时属于1-M种类型。现要把N张图片按照类型分配,使得每种类型的图片数量差不多。 请高手们给个思路。多谢啦~
  • 菜鸟一枚,目前的需求是: 时间段 订阅量 08:00~08:30 0 08:30~09:00 0 09:00~09:30 0 ...在我update的时候,需要手动输入的订阅量数值,平均分派给每个时间段上, 多余的按顺序+1,不足的为0。求大神指教!
  • MySql如何把表中X个客户随机平均分配给Y个人,保证不重复。现有customer表和userCust关系表。 需在在mysql job ,定时任务中实现。
  • 题目:创建一个6*6的格网,商业圈道路数据随机分配到不同的志愿者进行管理数据
  • 数据挖掘与工资分配

    千次阅读 2020-09-01 15:01:51
    企业的工资总额对一个企业的未来发展至关重要,本文以2018年26个省市分公司年运营的统计数据作为研究对象,在合理假设的基础上,综合考虑国企对各省市分公司工资分配的影响因素,通过建立合理的模型;对公司工资分配...
  • //需要分配的人员集合(list) //人员集合顺序随机打乱 因为第一人分配到的案件总金额是最大的 Collections.shuffle(list); final int size =list.size(); //list转换成数组userList...
  • 在excel中如何一列很长的数据平均分成几列 方法一: 参考网址:https://zhidao.baidu.com/question/522133495.html?qbl=relate_question_0 假设你说的一列是A列 B1单元格输入公式 =OFFSET($A$1,...
  • 假设你说的一列是A列,B1单元格输入公式 =OFFSET($A$1,ROW(A1)-1+COLUMN(A1)*3-3,),其中,row函数返回给定引用的行号。下拉复制公式三行,再右拉复制公式多列,这样的效果就是三行多列的样式,如下图,(如果要四行多...
  • 移动平均法是指上是对变量值进行平均的方法而已,即对原时间序列数据进行修正,从而消除季节变动和个别不规则变动对整体数据的影响。根据时序数据的特性不同移动平均法可分为三类: 简单移动平均 直接上例子  ...
  • 模型并行( **model parallelism** ):分布式系统中的不同机器... - 数据并行( **data parallelism** ):不同的机器有同一个模型的多个副本,每个机器分配到不同的数据,然后所有机器的计算结果按照某种方式合并。
  • 一种基于平均思想的任务分配算法

    万次阅读 多人点赞 2017-08-28 19:37:52
    假设现在有20个任务需要分配给员工去做,但是每个员工手头上还有未完成的任务,且未完成任务数不同。
  • 最近遇到需要从经理批量分配订单到主管,主管批量分配订单到人员,我们只需要设计一种算法经理到主管(主管到人类似),尽量保证经理分配到主管的订单的平均金额与数据库里面的平均金额相等。我为此设计了两种算法如下...
  • 欢迎转载,转载请注明:本文出自Bin的专栏blog....Jeff Dean 在演讲中提到,当前的做法是:解决方案 = 机器学习(算法)+ 数据 + 计算力未来有没有可能变为:解决方案 = 数据 + 100 倍的计算力?由此可见,谷歌似乎...
  • 数据挖掘K-平均值(K-means)程序C实现

    千次阅读 多人点赞 2011-12-01 21:26:22
    劳埃德算法首先把输入点分成k个初始化分组,可以是随机的或者使用一些启发式数据。然后计算每组的中心点,根据中心点的位置把对象分到离它最近的中心,重新确定分组。继续重复不断地计算中心并重新分组,直到收敛,...
  • 数据结构基础概念篇

    万次阅读 多人点赞 2017-11-14 13:44:24
    数据结构一些概念 数据结构就是研究数据的逻辑结构和物理结构以及它们之间相互关系,并对这种结构定义相应的运算,而且确保经过这些运算后所得到的新结构仍然是原来的结构类型。数据:所有能被输入到计算机中,且能...
  •   在工作中,遇到一个需求: N 个单位随机分配给 n 个人,其中每个单位有对应的工作量,分配时要尽量按工作量平均分给 n 个人,且人员的所属单位不能包括在被分配的单位中(N &amp;amp;gt;= n)。例如:有三...
  • 数据挖掘:数据清洗——数据噪声处理

    千次阅读 多人点赞 2020-02-19 14:43:42
    数据挖掘:数据预处理——数据噪声处理 一、什么是数据噪声? 数据噪声(Noise):数据集中的干扰数据(对场景描述不准确的数据),即测量变量中的随机误差或方差。 二、噪声数据与离群点的区别 观测量(Measurement) ...
  • 1.顺序表的插入操作 插入元素的位置是i表示插入后,这个插入的元素是在 i 的位置, 即... //用静态数组存储当前数据 int length; //当前顺序表的长度 } SqList; void InitList(SqList &L) { for(int i = 0; i<Ma

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 200,260
精华内容 80,104
关键字:

怎么将数据平均分配