Question

我正在努力使用一种将名称均匀分配到多维数组的算法。

我有7个名字列表，长度在3-5之间，其中每个分配了一个从0到列表长度的数字。

我想将它们分配给N个长度为14的数组（具有唯一的名称），以便获得一个多维数组，其中每个名称出现的次数大约相同。

例如，如果每个数字对应于每个列表的索引，并且我们假设每个列表的长度为4，则数组将如下所示：

[[ 0.  0.  1.  1.  2.  2.  3.  3.]
 [ 0.  0.  1.  1.  2.  2.  3.  3.]
 [ 0.  0.  1.  1.  2.  2.  3.  3.]
 [ 0.  0.  1.  1.  2.  2.  3.  3.]
 [ 0.  0.  1.  1.  2.  2.  3.  3.]
 [ 0.  0.  1.  1.  2.  2.  3.  3.]
 [ 0.  0.  1.  1.  2.  2.  3.  3.]
 [ 1.  1.  2.  2.  3.  3.  2.  2.]
 [ 1.  1.  2.  2.  3.  3.  2.  2.]
 [ 1.  1.  2.  2.  3.  3.  2.  2.]
 [ 1.  1.  2.  2.  3.  3.  2.  2.]
 [ 1.  1.  2.  2.  3.  3.  2.  2.]
 [ 1.  1.  2.  2.  3.  3.  2.  2.]
 [ 1.  1.  2.  2.  3.  3.  2.  2.]]

在这里，每一行对应一个名称列表，第1-7行= 8-14，因此第8行中的第一个元素是与第1行中第一个数字相同的列表的索引。将列表名称分配给这些值，并确保每列上没有重复的名称。

为澄清起见，每列对应于运动队的设置，有7个位置（（增加7个球员，总计14个）。并且每一行对应于该字段上的特定位置。

目标是确保每个玩家玩相似数量的游戏（这不是前面显示的情况），但是，某些组包含相同的名称（某些玩家玩2个位置），并且数量没有给出玩过的游戏数量（应将其概括为N个游戏。）。

到目前为止，我已经尝试对它们进行排序

num_pos=7
num_team=14
num_opp=8
def make_index_matrix(dim, max_values):
    assert len(max_values) == dim[0]
    out = np.zeros(dim)
    j = 0
    for k, mv in enumerate(max_values):
        assert mv > 0
        a = np.arange(mv).repeat(np.floor(dim[1]/mv))

        if len(a) < dim[1]:
            #r = np.ones(mv)

            r = np.arange(mv)
            a = np.concatenate((a, r))

        out[k,:] = a[:dim[1]]

    return out

lens = [x for pair in zip(lens,lens) for x in pair]
matches = make_index_matrix((num_team,num_opp),lens)
print matches
matches=matches[:,np.argsort(np.sum(matches,axis=0))] # sort by sum of columns

# Creating stabdard tean setyo
matches[num_pos:,:]= matches[:num_pos,:]+1
ma = np.max(matches[:num_pos,:]) # Highest actual player index

matches[np.where(matches==ma+1)]=randint(0,ma) #Making sure we dont add unexisting players
matches=matches[:,np.argsort(np.sum(matches,axis=0))] # sort by sum of columns

然后我从名称数组中分配名称

a = np.chararray((num_pos,num_opp),itemsize=30)
for i in range(num_pos):
    for j in range(num_opp):
        a[i,j] = names[i][int(matches[i,j])]

print Counter(a.flatten())

哪个产量

[['KAJA' 'KAJA' 'JULIE' 'JULIE' 'NORA' 'NORA' 'SANNA' 'SANNA']
 ['KATINKA' 'KATINKA' 'KARIANNE' 'KARIANNE' 'EMMA' 'EMMA' 'ADA' 'ADA']
 ['LOTTE' 'LOTTE' 'STINE' 'STINE' 'JENNY' 'JENNY' 'SARA-HELENE'
  'SARA-HELENE']
 ['MINA' 'MINA' 'LISA' 'LISA' 'CELINE' 'CELINE' 'MARIANNE' 'MARIANNE']
 ['KRISTINE' 'KRISTINE' 'MARIANNE' 'MARIANNE' 'HELLE' 'HELLE' 'SOFIE'
  'SOFIE']
 ['CAMILLA' 'CAMILLA' 'SANNE' 'SANNE' 'VICTORIA' 'VICTORIA' 'FRIDA' 'FRIDA']
 ['TUVA' 'TUVA' 'ADA' 'ADA' 'EMMA' 'EMMA' 'KATINKA' 'KATINKA']]
Counter({'MARIANNE': 4, 'ADA': 4, 'KATINKA': 4, 'EMMA': 4, 'LOTTE': 2, 'KARIANNE': 2, 'FRIDA': 2, 'JENNY': 2, 'STINE': 2, 'SARA-HELENE': 2, 'TUVA': 2, 'MINA': 2, 'VICTORIA': 2, 'KRISTINE': 2, 'CELINE': 2, 'HELLE': 2, 'CAMILLA': 2, 'JULIE': 2, 'SOFIE': 2, 'SANNA': 2, 'NORA': 2, 'SANNE': 2, 'LISA': 2, 'KAJA': 2})

对于8场游戏，结果并不算太差，但是一旦我们尝试6场游戏，分布就会变得更加不均匀。

Counter({'MARIANNE': 3, 'ADA': 3, 'KATINKA': 3, 'LOTTE': 2, 'KARIANNE': 2, 'EMMA': 2, 'STINE': 2, 'TUVA': 2, 'MINA': 2, 'KRISTINE': 2, 'CAMILLA': 2, 'JULIE': 2, 'SANNE': 2, 'LISA': 2, 'KAJA': 2, 'FRIDA': 1, 'JENNY': 1, 'SARA-HELENE': 1, 'VICTORIA': 1, 'CELINE': 1, 'HELLE': 1, 'SOFIE': 1, 'SANNA': 1, 'NORA': 1})

此脚本的主要思想是生成足球队，其中每个设置（列）加起来一定数量，以便我们在遇到f.ex时使用。在5个不同的团队中，第1栏的“得分”最高（最低），并与最具挑战性的团队匹配。理想情况下，最终设置应稍微随机化，以便玩家也可以与其他一些玩家一起玩。我已经用大都会黑市方法解决了这一问题，该方法建议进行更改，但前提是最终的“分数”在阈值以内。

多维数组中均匀分布的字符串

0 个答案: