gewichtetes zufälliges Item erhalten

Ich habe zum Beispiel diesen Tisch

+ ----------------- +
| Obst | gewicht |
+ ----------------- +
| Apfel | 4 |
| orange | 2 |
| Zitrone | 1 |
+ ----------------- +

Ich muss eine zufällige Frucht zurückgeben. Aber Apfel sollte 4-mal so häufig wie Zitrone und 2-mal so häufig wie Orange gepflückt werden .

Im allgemeineren Fall sollte es f(weight)mal häufig sein.

Was ist ein guter allgemeiner Algorithmus, um dieses Verhalten zu implementieren?

Oder gibt es vielleicht einige fertige Edelsteine ​​auf Ruby? :)

PS
Ich habe den aktuellen Algorithmus in Ruby https://github.com/fl00r/pickup implementiert

Die konzeptionell einfachste Lösung wäre, eine Liste zu erstellen, in der jedes Element so oft vorkommt, wie es gewichtet ist

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

Verwenden Sie dann die Funktionen, die Ihnen zur Verfügung stehen, um ein zufälliges Element aus dieser Liste auszuwählen (z. B. einen zufälligen Index im richtigen Bereich erstellen). Dies ist natürlich nicht sehr speichereffizient und erfordert ganzzahlige Gewichte.

Ein anderer, etwas komplizierterer Ansatz würde so aussehen:

1. Berechnen Sie die kumulativen Summen der Gewichte:

   intervals = [4, 6, 7]

   Wenn ein Index unter 4 einen Apfel darstellt , 4 bis unter 6 eine Orange und 6 bis unter 7 eine Zitrone .

2. Generieren Sie eine Zufallszahl nim Bereich von 0bis sum(weights).

3. Suchen Sie das letzte Objekt, dessen kumulierte Summe über dem angegebenen Wert liegt n. Die entsprechende Frucht ist Ihr Ergebnis.

Dieser Ansatz erfordert komplizierteren Code als der erste, aber weniger Speicher und Berechnung und unterstützt Gleitkommagewichte.

Für jeden Algorithmus kann der Einrichtungsschritt einmal für eine beliebige Anzahl von Zufallsauswahlen durchgeführt werden.

Hier ist ein Algorithmus (in C #), mit dem zufällig gewichtetes Element aus einer beliebigen Sequenz ausgewählt und nur einmal durchlaufen werden kann:

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. 
}

Dies basiert auf der folgenden Überlegung: Wählen wir das erste Element unserer Sequenz als "aktuelles Ergebnis" aus; Behalten Sie es dann bei jeder Iteration bei oder verwerfen Sie es und wählen Sie ein neues Element als aktuell aus. Wir können die Wahrscheinlichkeit berechnen, dass ein bestimmtes Element am Ende als Produkt aller Wahrscheinlichkeiten ausgewählt wird, dass es in nachfolgenden Schritten nicht verworfen wird, mal die Wahrscheinlichkeit, dass es überhaupt ausgewählt wird. Wenn Sie rechnen, werden Sie feststellen, dass sich dieses Produkt auf (Gewicht des Elements) / (Summe aller Gewichte) vereinfacht, was genau das ist, was wir brauchen!

Da diese Methode die Eingabesequenz nur einmal durchläuft, funktioniert sie auch bei übermäßig großen Sequenzen, vorausgesetzt, die Summe der Gewichte passt in eine int(oder Sie können einen größeren Typ für diesen Zähler auswählen).

Bereits vorliegende Antworten sind gut und ich werde sie ein wenig erweitern.

Wie Benjamin vorschlug, werden bei dieser Art von Problem normalerweise kumulative Summen verwendet:

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

Um ein Element in dieser Struktur zu finden, können Sie einen Code wie Nevermind verwenden. Dieses Stück C # -Code, das ich normalerweise verwende:

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

Nun zum interessanten Teil. Wie effizient ist dieser Ansatz und welche Lösung ist am effizientesten? Mein Code benötigt O (n) Speicher und wird in O (n) Zeit ausgeführt. Ich glaube nicht, dass dies mit weniger als O (n) Raum getan werden kann, aber die zeitliche Komplexität kann viel geringer sein, O (log n) in der Tat. Der Trick besteht darin, eine binäre Suche anstelle einer regulären for-Schleife zu verwenden.

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];
}

Es gibt auch eine Geschichte über das Aktualisieren von Gewichten. Im schlimmsten Fall bewirkt die Aktualisierung der Gewichtung für ein Element die Aktualisierung der kumulativen Summen für alle Elemente, wodurch die Aktualisierungskomplexität auf O (n) erhöht wird . Auch das kann mithilfe eines binär indizierten Baums auf O (log n) reduziert werden .

Dies ist eine einfache Python-Implementierung:

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

und

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

print select(population, weights)

In genetischen Algorithmen wird dieses Auswahlverfahren als Fitness-Proportional-Auswahl oder Roulette-Rad-Auswahl bezeichnet, da:

• Ein Teil des Rades wird jeder der möglichen Auswahlen basierend auf ihrem Gewichtswert zugewiesen. Dies kann erreicht werden, indem das Gewicht einer Auswahl durch das Gesamtgewicht aller Auswahlen dividiert und auf 1 normiert wird.
• Dann wird eine zufällige Auswahl getroffen, ähnlich wie das Roulette-Rad gedreht wird.

Typische Algorithmen haben die Komplexität O (N) oder O (log N), aber Sie können auch O (1) ausführen (z. B. Roulette-Rad-Auswahl über stochastische Akzeptanz ).

Dieser Kern tut genau das, wonach Sie fragen.

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;
    }

du kannst es so benutzen:

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

Der obige Code wird höchstwahrscheinlich (% 98) 0 zurückgeben, was der Index für 'apple' für das angegebene Array ist.

Außerdem testet dieser Code die oben bereitgestellte Methode:

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

Es gibt eine Ausgabe in etwa so:

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