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

 

 '''

 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)

<?php
 

 
 !<<<目前只实现了分2组的情况>>>!

 

 /**

  * 按分数对选手进行平均分组，可分多组。

  *

  * 

  * 注意：

  * 1. 输入的选手名单players为集合形式，player表示选手名称，score表示选手的分数

  * 2. 选手的分数体现选手的实力，分数有可能是负数

  * 3. 最终解不是唯一，但要求分组后，每组的实力尽量接近，每组的人数也尽量接近

  *

  * 例如：

  * 将所有选手，总共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

  *     }

  * ]

  * 分成两组，应该为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

  *     }

  *   ]

  * ]

  * 分成3组，应该为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

  *     }

  *   ]

  * ]

  *

  */

 

 

 namespace Interview;

 

 

 class AverageGroup

 {

     

 
private $players = array();

 
private $count = 2;

 

 
/**

 
* @param [array] 选手名单

 
* @param [integer] 分组数

 
*/

 
function __construct($players, $count = 2) {

 
$this->players = $players;

 
$this->count = $count;

 
}

 

 

 
/**

 
* @return [array] 分组后的结果

 
*/

 
/*

 
* 思路：

 
* 元素替换法

 
* 默认把倒叙排列的数组分成两个数组，最大的$quantity个为一组，剩下最小的为另外一组，

 
* 依次用最小的里面的最大的元素替换最大的组里的最小的，然后对数组求和，

 
* 把和跟平均数比较，如果最大的数组的和小于等于平均数，就停止，返回最大的数组，

 
* 利用array_diff()得到另外一个数组。

 
*/

 
public function divide($group = array(),$count=2) {

 
   $group_score = array();

 
   //转换成只有score的一维数组

 
   foreach ($group as $gro){

 
       foreach ($gro as $k=>$v){

 
           if($k=="score"){

 
               array_push($group_score, $v);

 
           }

 
       }

 
   }

 
$con = count($group_score); 

 
$quantity = round($con/$count); //每组的人数

 
$sum = array_sum($group_score);

 
$average = round($sum/$count); // 分数取平均

 
rsort($group_score); //数组倒叙排列

 

 

 
$big_array = array();

 
for($a=0;$a<$quantity;$a++){

 
   array_push($big_array, $group_score[$a]);

 
}

 
$small_array = array();

 
$small_array = array_diff($group_score, $big_array);

 


         for($a=$con-$quantity;$a>=0;$a--){

             if(array_sum($big_array)>$average){

                 for($b=$quantity;$b<$con;){

                     list($big_array[$a],$small_array[$b])=array($small_array[$b],$big_array[$a]);

                     if(array_sum($big_array)>$average){

                         $b++;

                     }else {

                         break;

                     }

                 }

             }

         }

 
//还原数组

 
$big = array();

 
$small = array();

 
foreach ($group as $gro){

 
   foreach ($gro as $k=>$v){

 
       if($k=="score"){

     
       if(in_array($v, $big_array)){

     
           $big []= $gro;

     
       }else{

     
           $small []= $gro;

     
       }

 
       }

 
   }

 
}

 
print_r($big);

 
print_r($small);

 
}

 }

举个栗子。
 
 
 
现在从我们班选了6个人，分成两组，需要emmm，比如说去打僵尸
 1组分配狙击枪，2组分配步枪。
 
 
那么这时候就出现问题了：显然手持步枪冲锋作战死的更快，所以大家都想去1组。
 
那么这时候就需要进行公平的分组：抓阄
 
为了跟本文内容有关系所以 大家暂定为用一个python程序来实现分组。nice√
 
那么，思路如下：
 
首先统计6个人的姓名(或者编号)，把它们都放在列表lovelive里面。
 
可是μ‘s不是9个人吗
 
然后用1个空列表l0和原来的列表lovelive分别存放1组和2组人员的姓名(或编号)。
 
用随机数取下标的值以保证100%公平√
 
每次取1个值x，放入空列表l0中。
 
每次取完值之后就把这个x从lovelive中删掉避免重复。
 
取到3个值就停。
 
这样l0就能取到3个人，而列表lovelive就剩下另外3个人。
 
这样一来，思路就基本确定了。
 
import random

str1 = 'kinlrmi.soulrn.christine.christian.saph.laflosia'
ll = str1.split('.')	#我觉得这样写比直接在列表里挨个添加姓名更快一点
l0 =[]

while len(ll) != 3:		#当ll中的3个元素被添加到l0中时，就实现平均分组了
    a = len(ll)-1	    #确定x的取值范围上限。因为程序会修改ll中元素的总数
    x=random.randint(0,a)
    l0.append(ll[x])    #将随机得到的元素添加到l0中
    ll.remove(ll[x])    #添加完了之后把ll中这个项删掉。
print(l0,ll)
 
len()得到的值是列表中元素的个数。比如str1=[1，2，3]有三个元素，len(str1)得到的值就是3，减去1得到的就是对应末位元素3的下标。
 
以上就是一个比较基础的版本。
 
这时候啊，写程序的同学就猫病就犯了，他觉得这样不能体现出他的nb 傻逼 之处
 
所以他重新写了一个列表嵌套的（其实反而不那么好用）：
 
import random

str1 = 'kinlrmi.soulrn.christine.christian.saph.laflosia'
list1 = str1.split('.')		#把str1变成列表
list2 = [[],[]]				#赋两个组初始值为空

while len(list2[1]) != 3:	#为了保证每个组都分到三个人
    list2 = [[],[]]			#如果没有实现均分那就重新分，重置分组为空列表
    for i in list1:			#从list1第一个元素开始，顺序放入随机选定的组
        x = random.randint(0,1)	#随机选一个组
        list2[x].append(i)		#把list1中的元素放入选定的组
else:
    print(list2)
 
简单理解一下：
 
第一个程序是固定两个分组，随机挑选人名然后塞进组里面。
第二个组是顺序遍历人名，随机塞到某一个分组里面。
 
这样写代码更易于维护，比如两个组变成三个组，比如6个人变成9个人，都是可行的。
 
唯一有一个小问题就是，如果用第二个代码来运算的话，连续1000次都没有随机到平均分配的话，程序就会停止运行（用的IDE是vs code）。
 
我觉得应该没有人这么脸黑吧
 

 
目录
 
String分组
数组分组

 
简易的将String和数组进行分组方法
 
String分组
 
    public static List<String> StringSplit() {
        
        int packetNum = 9;//分成几组
        
        String str = "123456789012345678901234567890";//要分组的字符串
        
        List<String> list =new ArrayList<String>();
        
        int packetLength = str.length()/packetNum;
        
        for (int i = 0; i < packetNum-1; i++) {
            
            list.add(str.substring(i*packetLength,  i*packetLength+packetLength));
        }
        
        list.add(str.substring((packetNum-1)*packetLength,  str.length()));
        
        return list;
        
    }
 
数组分组
 
    public static List<byte[]> ByteArraySplit() {
        
        List<byte[]> list =new ArrayList<byte[]>();
        
        int packetNum = 9;//分成几组
        
        byte[] byteArray = new  byte[]{1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0};//要分组的数组
        
        int packetLength = byteArray.length/packetNum;
         
        for (int i = 0; i < packetNum-1; i++) {
            
            byte packetByte[] = new byte[packetLength];
            
            System.arraycopy(byteArray, i*packetLength,  packetByte, 0, packetLength);
            
            list.add(packetByte);
        }
        
        byte endPacketByte[] = new  byte[byteArray.length-(packetNum-1)*packetLength];
        
        System.arraycopy(byteArray,  (packetNum-1)*packetLength,endPacketByte, 0,  endPacketByte.length);
        list.add(endPacketByte);
        
        return list;
    }