#将列表进行平均分组，如果不能整除，则将后面的元素全部放入最后一组


'''

n 指定列表元素个数

group  指定将列表分成的组数

per  每一组包括的元素个数

'''

def put(n,group):


    l2 = []

    num=0

    l = range(n)

    per = len(l) / group


    for i in l[::per]:  #改变i的索引值

        l2.extend(l[i:i+per])


        num+=1 #指定当前添加的组数

        print l2


        #如果只剩下一组，则将剩余元素全部追加至列表

        if num==group-1:

            l2.extend(l[i+per:])


            print '*'*40

            print '最后一组的内容是：',l[i+per:]

            print '*'*40


            break

    print l2





put(40,4)

put(10,7)

一、平均分组问题(Java实现)
题目
按分数对选手进行平均分组，可分多组。
注意：
输入的选手名单players为集合形式，player表示选手名称，score表示选手的分数
选手的分数体现选手的实力，分数有可能是负数
最终解不是唯一，但要求分组后，每组的实力尽量接近，每组的人数也尽量接近
例如：
将所有选手，总共7人
[
{
"player": "a",
"score": 22
},
{
"player": "b",
"score": -9
},
{
"player": "c",
"score": 13
},
{
"player": "d",
"score": 17
},
{
"player": "e",
"score": 0
},
{
"player": "f",
"score": -11
},
{
"player": "g",
"score": -2
}
]
复制代码
1、如果分成两组，应该是4 VS 3 的队形
[
[
{
"player": "a",
"score": 22
},
{
"player": "e",
"score": 0
},
{
"player": "g",
"score": -2
},
{
"player": "f",
"score": -11
}
],
[
{
"player": "d",
"score": 17
},
{
"player": "c",
"score": 13
},
{
"player": "b",
"score": -9
}
]
]
复制代码
2、如果分成三组，应该是3 VS 2 VS 2的队形
[
[
{
"player": "a",
"score": 22
},
{
"player": "b",
"score": -9
},
{
"player": "f",
"score": -11
}
],
[
{
"player": "c",
"score": 13
},
{
"player": "e",
"score": 0
}
],
[
{
"player": "d",
"score": 17
},
{
"player": "g",
"score": -2
}
]
]
复制代码
​不知道大家第一次看到这代题目时候，是怎么想的。请大家先想一下，不要着急看我的思路和代码，这样容易顺着我的思路走，应该有自己的思路与想法，如果没有，再参考我的解决思路。
解题思路：
​首先可以确定的是这道题是有可能无法得到最优解的，只能得到一个接近最优解的解或最优解。
1、 先按照选手的分数按照正序或者倒叙进行排序，我这里按照倒叙排列。
2、 求出所有选手的总分数，然后求出平均数。
3、 将选手分成两组，例如组一，组二，然后用组一的分值最小的选手去和组二中分值最大的选手进行交换
4、如果交换后组一的总分数大于平均数，那么进行交换，直至出现临界值，当组一的总分数小于平均分值，即分组成功
1、要注意分组中负数的存在，负数会越加越小
2、为什么用组一的分值最小的选手去和组二中分值最大的选手进行交换
因为可以使组一的分值缓慢下降，直至出现组一的分值大于平均值。 否则快速下降，很难确定临界值
Java代码：
下面是我的代码，如果有什么不足的地方或者错误的地方，欢迎指出。
```java
package com.kxj;
/**
* @ClassName GroupingDemo
* @Description TODO
* @Author kongxiangjin
* @Date 2019/10/15 16:13
* @Version 1.0
**/
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class GroupingDemo {
/**
* 选手集合
*/
private static List players = new ArrayList<>();
public static void main(String[] args) {
// 初始化选手
Player player1 = new Player("a", 22);
Player player2 = new Player("b", -9);
Player player3 = new Player("c", 13);
Player player4 = new Player("d", 17);
Player player5 = new Player("e", 0);
Player player6 = new Player("f", -11);
Player player7 = new Player("g", -2);
players.add(player1);
players.add(player2);
players.add(player3);
players.add(player4);
players.add(player5);
players.add(player6);
players.add(player7);
//选手总人数
int count = players.size();
//总分数
double sum = sumMethod(players);
//分组数
int groupNum = 2;
//平均数
double average = sum / groupNum;
//每组人数
int num = count / groupNum;
//double diff = sum;
boolean flag = false;
//倒叙
Collections.sort(players);
List groupList1 = new ArrayList<>();
List groupList2 = new ArrayList<>();
for (int i = 0; i < num; i++) {
groupList1.add(players.get(i));
}
for (int i = num; i < count; i++) {
groupList2.add(players.get(i));
}
for (int i = 0; i < groupList2.size(); ) {
// 先取出第二组中最大的选手
Player p2 = groupList2.get(i);
for (int j = groupList1.size() - 1; j >= 0; j--) {
// 集合中的对象进行交换
Player p1 = groupList1.get(j);
groupList1.remove(p1);
groupList1.add(p2);
groupList2.remove(p2);
groupList2.add(p1);
double sum1 = sumMethod(groupList1);
//              double sum2 = sumMethod(groupList2);
// 如果交换后的数据不满足条件，说明上一个值即为临界值，则进行回退
if (sum1 > average && j != 0) {
groupList1.remove(p2);
groupList1.add(p1);
groupList2.remove(p1);
groupList2.add(p2);
} else if (sum1 > average && j == 0) {
break;
} else {
// 找到临界值后跳出循环
flag = true;
break;
}
}
if (flag == true) {
System.out.println(groupList1);
System.out.println(groupList2);
break;
}
// 每次循环需要对组一进行重新排序，再交换的过程中，原先的倒叙会被打乱。
Collections.sort(groupList1);
}
}
/**
* 求总分数
* @param players
* @return
*/
private static double sumMethod(List players) {
double sum = 0;
for (Player player : players) {
sum += player.getScore();
}
return sum;
}
}
```
```java
package com.kxj;
/**
* @ClassName Player
* @Description TODO
* @Author kongxiangjin
* @Date 2019/10/15 16:14
* @Version 1.0
**/
public class Player implements Comparable {
private String name;
private int score;
public Player() {
}
public Player(String name, int score) {
this.name = name;
this.score = score;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
@Override
public int compareTo(Player o) {
return o.score - this.score;
}
@Override
public String toString() {
return "Player{" +
"name='" + name + '\'' +
", score=" + score +
'}';
}
}
```
复制代码

        无论组织团队活动、组织会议或举办培训，一般都要把人员平均分成若干小组，甚至要求按男女比例平均分组。目前最常用的方法就是“扫码分组”，今天给大家详细介绍一下具体的使用方法！
共分三个步骤完成：
1、创建一个分组；      2、扫码进入分组；      3、管理分组信息。
第一步：创建一个分组
1、扫码进入云分组小程序，点击菜单“创建的分组”---新建分组；
2、选择分组模式：男女比例平均分组；
3、填写基本信息，点击“生成分组”。
（创建分组时，系统会分配一个“口令”）
第二步：扫码进入分组
1、团队成员扫码进入云分组小程序，在首页输入口令；
2、填写基本信息（姓名、性别），点击“加入分组”；
3、进入分组后，可以看到自已的组别及本所组所有队员列表。
第三步：管理分组信息
1、进入主题管理页面，点击操作标识，可以修改主题、查看管理员、删除分组；
2、进入分组管理页面，屏幕布下拉，可以停止分组、授权管理员、关联签到名单、修改组名；
3、进入小组管理页面，可以给成员换组、修改成员信息、删除成员。

对List进行非固定下标的随机平均分组
前提
源码

前提
项目中用到了一个调度算法，会对List中的任务平均分组到不同的集群中，之前的思路是平均取余数，然后将余数加到最后一个分片中，这样资源有很大的浪费。因为最后的余数可以加到之前的所有的分片当中，而不必是最后一个。网上有一个流传度交广的算法是将余数分配到了前几个切片中，这样在调度比较频繁的时候，前几个人集群负载会较大，造成负载不均。现在的改进是将余数随机分配到不同的分片中。
源码
  private static final Random JVM_RANDOM = new JVMRandom();

    /**
     * 将一个list均分成n个list,主要通过偏移量来实现的,改进版
     * 对分片的算法作改进,如果是10个平分成4片,则A/B会分到3片,C/D分到2片,负载会更加均衡
     * 现在改进后的remainder会随机加到平均后的分组list中
     * @param source
     * @return
     */
    public static <T> List<List<T>> average(final List<T> source, final int n) {
        if (source == null) {
            throw new NullPointerException("List must not be null");
        }
        if (n <= 0) {
            throw new IllegalArgumentException("Size must be greater than 0");
        }
        List<List<T>> result = new ArrayList<List<T>>();
        int remaider = source.size() % n; // (先计算出余数)
        int number = source.size() / n; // 然后是商
        int offset = 0;// 偏移量

        int[] idxs = Arrays.stream(buildNoRepeatIndex(n), 0, remaider).sorted().toArray();
        for (int i = 0; i < n; i++) {
            List<T> value = null;
            if (remaider > 0 && containsInts(idxs, i)) {
                value = source.subList(i * number + offset, (i + 1) * number + offset + 1);
                remaider--;
                offset++;
            } else {
                value = source.subList(i * number + offset, (i + 1) * number + offset);
            }
            result.add(value);
        }
        return result;
    }

    /**
     * 创建不重复的数组下标
     * @param source
     * @return
     */
    public static int[] buildNoRepeatIndex(int size) {
        int values[] = new int[size];
        int temp1, temp2, temp3;

        for (int i = 0; i < size; i++) {
            values[i] = i;
        }

        // 随机交换values.length次
        for (int i = 0; i < size; i++) {
            temp1 = JVM_RANDOM.nextInt(size); // 随机产生一个位置
            temp2 = JVM_RANDOM.nextInt(size); // 随机产生另一个位置

            if (temp1 != temp2) {
                temp3 = values[temp1];
                values[temp1] = values[temp2];
                values[temp2] = temp3;
            }
        }

        return values;
    }

    private static boolean containsInts(int[] array, int target) {
        for (int value : array) {
            if (value == target) {
                return true;
            }
        }
        return false;
    }