重み付けされたランダムなアイテムを取得する

例えば、私はこの表を持っています

+ ----------------- +
| フルーツ| 重量|
+ ----------------- +
| りんご| 4 |
| オレンジ| 2 |
| レモン| 1 |
+ ----------------- +

ランダムなフルーツを返す必要があります。ただし、リンゴはレモンの 4倍、オレンジの 2倍の頻度で摘み取る必要があります。

より一般的なケースでは、それはf(weight)頻繁に起こるはずです。

この動作を実装するのに適した一般的なアルゴリズムは何ですか？

または、Rubyにすぐに使える宝石がありますか？:)

PS
現在のアルゴリズムをRuby https://github.com/fl00r/pickupに実装しました

概念的に最も簡単な解決策は、各要素がその重みの数だけ出現するリストを作成することです。

fruits = [apple, apple, apple, apple, orange, orange, lemon]

次に、自由に使用できる関数を使用して、そのリストからランダムな要素を選択します（たとえば、適切な範囲内でランダムなインデックスを生成します）。もちろん、これはメモリ効率が悪く、整数の重みが必要です。

もう少し複雑なアプローチは次のようになります。

1. 重みの累積合計を計算します。

   intervals = [4, 6, 7]

   4未満のインデックスはリンゴ、4〜6未満はオレンジ、6〜7未満はレモンを表します。

2. 〜nの範囲の乱数を生成0しsum(weights)ます。

3. 累積合計が上記の最後のアイテムを見つけますn。対応する果物はあなたの結果です。

このアプローチでは、最初のアプローチよりも複雑なコードが必要ですが、メモリと計算が少なく、浮動小数点の重みがサポートされます。

いずれのアルゴリズムでも、任意の数のランダム選択に対してセットアップ手順を1回実行できます。

これは、任意のシーケンスからランダムに重み付けされた要素を選択できるアルゴリズム（C＃）です。

public static T Random<T>(this IEnumerable<T> enumerable, Func<T, int> weightFunc)
{
    int totalWeight = 0; // this stores sum of weights of all elements before current
    T selected = default(T); // currently selected element
    foreach (var data in enumerable)
    {
        int weight = weightFunc(data); // weight of current element
        int r = Random.Next(totalWeight + weight); // random value
        if (r >= totalWeight) // probability of this is weight/(totalWeight+weight)
            selected = data; // it is the probability of discarding last selected element and selecting current one instead
        totalWeight += weight; // increase weight sum
    }

    return selected; // when iterations end, selected is some element of sequence. 
}

これは、次の理由に基づいています。シーケンスの最初の要素を「現在の結果」として選択しましょう。次に、各反復で、それを保持するか、破棄して現在の要素として新しい要素を選択します。与えられた要素が最終的に選択される確率を、後続のステップで破棄されないすべての確率の積として計算し、最初に選択される確率を計算します。計算すると、この製品は（要素の重量）/（すべての重量の合計）に単純化されることがわかります。これはまさに必要なものです。

このメソッドは入力シーケンスを1回だけ反復するため、重みの合計が収まるint場合（または、このカウンターにもっと大きなタイプを選択できる場合）、わいせつに大きいシーケンスでも機能します

すでに存在する答えは良いです、そして私はそれらを少し拡張します。

ベンジャミンが示唆したように、この種の問題では通常、累積合計が使用されます。

+------------------------+
| fruit  | weight | csum |
+------------------------+
| apple  |   4    |   4  |
| orange |   2    |   6  |
| lemon  |   1    |   7  |
+------------------------+

この構造内のアイテムを見つけるには、Nevermindのコードのようなものを使用できます。私が通常使用するこのC＃コード：

double r = Random.Next() * totalSum;
for(int i = 0; i < fruit.Count; i++)
{
    if (csum[i] > r)
        return fruit[i];
}

興味深い部分に移ります。このアプローチはどれほど効率的で、最も効率的なソリューションは何ですか？私のコードはO（n）メモリを必要とし、O（n）時間で実行されます。O（n）未満のスペースでは実現できないと思いますが、時間の複雑さははるかに低く、実際にはO（log n）です。トリックは、通常のforループの代わりにバイナリ検索を使用することです。

double r = Random.Next() * totalSum;
int lowGuess = 0;
int highGuess = fruit.Count - 1;

while (highGuess >= lowGuess)
{
    int guess = (lowGuess + highGuess) / 2;
    if ( csum[guess] < r)
        lowGuess = guess + 1;
    else if ( csum[guess] - weight[guess] > r)
        highGuess = guess - 1;
    else
        return fruit[guess];
}

重みの更新に関する話もあります。最悪の場合、1つの要素の重みを更新すると、すべての要素の累積合計が更新され、更新の複雑さがO（n）に増加します。これもバイナリインデックスツリーを使用してO（log n）に削減できます。

これは単純なPython実装です。

from random import random

def select(container, weights):
    total_weight = float(sum(weights))
    rel_weight = [w / total_weight for w in weights]

    # Probability for each element
    probs = [sum(rel_weight[:i + 1]) for i in range(len(rel_weight))]

    slot = random()
    for (i, element) in enumerate(container):
        if slot <= probs[i]:
            break

    return element

そして

population = ['apple','orange','lemon']
weights = [4, 2, 1]

print select(population, weights)

遺伝的アルゴリズムでは、この選択手順はフィットネス比例選択またはルーレットホイール選択と呼ばれます。

• ホイールの割合が、重み値に基づいて可能な選択のそれぞれに割り当てられます。これは、選択の重みをすべての選択の合計重みで割って、1に正規化することで実現できます。
• 次に、ルーレットのホイールが回転する方法と同様に、ランダムに選択されます。

典型的なアルゴリズムの複雑さはO（N）またはO（log N）ですが、O（1）も可能です（たとえば、確率的受け入れによるルーレットホイールの選択）。

この要点はまさにあなたが求めていることをしている。

public static Random random = new Random(DateTime.Now.Millisecond);
public int chooseWithChance(params int[] args)
    {
        /*
         * This method takes number of chances and randomly chooses
         * one of them considering their chance to be choosen.    
         * e.g. 
         *   chooseWithChance(0,99) will most probably (%99) return 1
         *   chooseWithChance(99,1) will most probably (%99) return 0
         *   chooseWithChance(0,100) will always return 1.
         *   chooseWithChance(100,0) will always return 0.
         *   chooseWithChance(67,0) will always return 0.
         */
        int argCount = args.Length;
        int sumOfChances = 0;

        for (int i = 0; i < argCount; i++) {
            sumOfChances += args[i];
        }

        double randomDouble = random.NextDouble() * sumOfChances;

        while (sumOfChances > randomDouble)
        {
            sumOfChances -= args[argCount -1];
            argCount--;
        }

        return argCount-1;
    }

次のように使用できます。

string[] fruits = new string[] { "apple", "orange", "lemon" };
int choosenOne = chooseWithChance(98,1,1);
Console.WriteLine(fruits[choosenOne]);

上記のコードは、おそらく（％98）0を返します。これは、指定された配列の「リンゴ」のインデックスです。

また、このコードは上記のメソッドをテストします。

Console.WriteLine("Start...");
int flipCount = 100;
int headCount = 0;
int tailsCount = 0;

for (int i=0; i< flipCount; i++) {
    if (chooseWithChance(50,50) == 0)
        headCount++;
    else
        tailsCount++;
}

Console.WriteLine("Head count:"+ headCount);
Console.WriteLine("Tails count:"+ tailsCount);

次のような出力が得られます。

Start...
Head count:52
Tails count:48