加权扁平列表的正常分布

Question

我有任何长度的字符串项目的列表，我需要“正常化”此列表，以便每个项目是正常分布的一部分，将权重附加到字符串。

什么是更有效的和数学/统计的方式去关于这个比我下面有什么？

func normalizeAppend(in []string, shuffle bool) []string { 
    var ret []string 

    if shuffle { 
     shuffleStrings(in) 
    } 

    l := len(in) 
    switch { 
    case remain(l, 3) == 0: 
     l3 := (l/3) 
     var low, mid, high []string 
     for i, v := range in { 
      o := i + 1 
      switch { 
      case o <= l3: 
       low = append(low, v) 
      case o > l3 && o <= l3*2: 
       mid = append(mid, v) 
      case o >= l3*2: 
       high = append(high, v) 
      } 
     } 

     q1 := 1600/len(low) 
     q2 := 6800/len(mid) 
     q3 := 1600/len(high) 

     for _, v := range low { 
      ret = append(ret, fmt.Sprintf("%s_%d", v, q1)) 
     } 

     for _, v := range mid { 
      ret = append(ret, fmt.Sprintf("%s_%d", v, q2)) 
     } 

     for _, v := range high { 
      ret = append(ret, fmt.Sprintf("%s_%d", v, q3)) 
     } 
    case remain(l, 2) == 0 && l >= 4: 
     l4 := (l/4) 
     var first, second, third, fourth []string 
     for i, v := range in { 
      o := i + 1 
      switch { 
      case o <= l4: 
       first = append(first, v) 
      case o > l4 && o <= l4*2: 
       second = append(second, v) 
      case o > l4*2 && o <= l4*3: 
       third = append(third, v) 
      case o > l4*3: 
       fourth = append(fourth, v) 
      } 
     } 
     q1 := 1600/len(first) 
     q2 := 3400/len(second) 
     q3 := 3400/len(third) 
     q4 := 1600/len(fourth) 

     for _, v := range first { 
      ret = append(ret, fmt.Sprintf("%s_%d", v, q1)) 
     } 

     for _, v := range second { 
      ret = append(ret, fmt.Sprintf("%s_%d", v, q2)) 
     } 

     for _, v := range third { 
      ret = append(ret, fmt.Sprintf("%s_%d", v, q3)) 
     } 

     for _, v := range fourth { 
      ret = append(ret, fmt.Sprintf("%s_%d", v, q4)) 
     } 
    default: 
     var first, second, third []string 
     q1 := (1 + math.Floor(float64(l)*.16)) 
     q3 := (float64(l) - math.Floor(float64(l)*.16)) 
     var o float64 
     for i, v := range in { 
      o = float64(i + 1) 
      switch { 
      case o <= q1: 
       first = append(first, v) 
      case o > q1 && o < q3: 
       second = append(second, v) 
      case o >= q3: 
       third = append(third, v) 
      } 
     } 
     lq1 := 1600/len(first) 
     lq2 := 3400/len(second) 
     lq3 := 1600/len(third) 
     for _, v := range first { 
      ret = append(ret, fmt.Sprintf("%s_%d", v, lq1)) 
     } 

     for _, v := range second { 
      ret = append(ret, fmt.Sprintf("%s_%d", v, lq2)) 
     } 

     for _, v := range third { 
      ret = append(ret, fmt.Sprintf("%s_%d", v, lq3)) 
     } 

    } 

    return ret 
} 

一些要求澄清：

我将从列表中选择多次一个在由权重选择一个时间项目的列表，开始与我有（隐含的）重物列表1：

[A_1，B_1，C_1，D_1，E_1，F_1，G_1，H_1，I_1，j_1，K_1]

我正在寻找一种更好的方式，使该列表到的东西产生更选择权重的'正常'分布：

[A_1，B_2，C_3，D_5，E_14，f_30，g_14，h_5，I_3，J_2，K_1]

或许很可能我需要改变我的方法来统计的东西更接地。底线是我想以多种方式控制项目列表中的选择，其中之一是确保项目以接近正常曲线的方式返回。

Answer 1

如果你只是想计算的权重对于给定的名单，那么你需要下面的东西：

• 正态分布
• 正态分布
• 一个discretizer的方差的平均值为值

第一个很简单。你想要的意思是在列表的中心。因此（假设从零开始的索引）：

mean = (list.size - 1)/2 

第二种是随意的，取决于你希望你的权重如何陡峭下降。在3 * standard_deviation与mean之间的距离上，正态分布的权重实际上为零。因此，在大多数情况下，一个很好的标准偏差可能是第四和第六列表长度之间的事情：

standard_deviation = (1/4 .. 1/6) * list.size 
variance = standard_deviation^2 

假设你想要整型权，你需要从正态分布离散的权重。最简单的方法是通过指定最大重量（在平均位置的元素）。

就是这样。 i位置的元素的重量为：

weight[i] = round(max_weight * exp(-(i - mean)^2/(2 * variance)))