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

如果您只想计算给定列表的权重，则需要以下内容：

正态分布的平均值
正态分布的方差
值的离散器

第一个很简单。您希望均值位于列表的中心。因此（假设从零开始索引）：

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)))

将平面列表加权到正态分布

1 个答案: