dapatkan item acak berbobot

Saya punya, misalnya, tabel ini

+ ----------------- +
| buah | berat |
+ ----------------- +
| apel | 4 |
| oranye | 2 |
| lemon | 1 |
+ ----------------- +

Saya perlu mengembalikan buah acak. Tetapi apel harus dipetik 4 kali lebih sering dari Lemon dan 2 kali lebih sering dari jeruk .

Dalam kasus yang lebih umum, harus f(weight)sering kali.

Apa algoritma umum yang baik untuk menerapkan perilaku ini?

Atau mungkin ada beberapa permata siap pakai di Ruby? :)

PS
Saya sudah menerapkan algoritma saat ini di Ruby https://github.com/fl00r/pickup

Solusi yang paling sederhana secara konseptual adalah membuat daftar di mana setiap elemen terjadi sebanyak beratnya, jadi

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

Kemudian gunakan fungsi apa pun yang Anda miliki untuk memilih elemen acak dari daftar itu (misalnya menghasilkan indeks acak dalam kisaran yang tepat). Ini tentu saja tidak sangat efisien memori dan membutuhkan bobot integer.

Pendekatan lain yang sedikit lebih rumit akan terlihat seperti ini:

1. Hitung jumlah bobot kumulatif:

   intervals = [4, 6, 7]

   Jika indeks di bawah 4 mewakili apel , 4 di bawah 6 jeruk dan 6 di bawah 7 lemon .

2. Hasilkan nomor acak ndalam kisaran 0hingga sum(weights).

3. Temukan item terakhir yang jumlah kumulatifnya di atas n. Buah yang sesuai adalah hasil Anda.

Pendekatan ini membutuhkan kode yang lebih rumit daripada yang pertama, tetapi lebih sedikit memori dan komputasi dan mendukung bobot titik-mengambang.

Untuk kedua algoritma, langkah-setup dapat dilakukan satu kali untuk jumlah acak pilihan.

Berikut adalah algoritma (dalam C #) yang dapat memilih elemen tertimbang acak dari urutan apa pun, hanya mengulanginya sekali saja:

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

Ini didasarkan pada alasan berikut: mari pilih elemen pertama dari urutan kami sebagai "hasil saat ini"; kemudian, pada setiap iterasi, simpan atau buang dan pilih elemen baru sebagai yang sekarang. Kita dapat menghitung probabilitas setiap elemen yang diberikan untuk dipilih pada akhirnya sebagai produk dari semua probabilitas yang tidak akan dibuang dalam langkah-langkah berikutnya, kali probabilitas bahwa itu akan dipilih di tempat pertama. Jika Anda menghitung, Anda akan melihat bahwa produk ini disederhanakan menjadi (bobot elemen) / (jumlah semua bobot), yang persis seperti yang kami butuhkan!

Karena metode ini hanya mengulangi urutan input sekali saja, metode ini bekerja bahkan dengan urutan yang sangat besar, asalkan jumlah bobot cocok menjadi int(atau Anda dapat memilih jenis yang lebih besar untuk penghitung ini)

Sudah ada jawaban yang bagus dan saya akan sedikit mengembangkannya.

Seperti yang disarankan Benjamin, jumlah kumulatif biasanya digunakan dalam masalah seperti ini:

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

Untuk menemukan item dalam struktur ini, Anda dapat menggunakan sesuatu seperti sepotong kode Nevermind. Sepotong kode C # yang biasa saya gunakan:

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

Sekarang ke bagian yang menarik. Seberapa efisien pendekatan ini dan solusi apa yang paling efisien? Sepotong kode saya membutuhkan O (n) memori dan berjalan dalam waktu O (n) . Saya tidak berpikir itu bisa dilakukan dengan kurang dari O (n) ruang tetapi kompleksitas waktu bisa jauh lebih rendah, O (log n) sebenarnya. Caranya adalah dengan menggunakan pencarian biner daripada biasa untuk loop.

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

Ada juga cerita tentang memperbarui bobot. Dalam kasus terburuk, memperbarui bobot untuk satu elemen menyebabkan pembaruan jumlah kumulatif untuk semua elemen meningkatkan kompleksitas pembaruan ke O (n) . Itu juga dapat ditebang ke O (log n) menggunakan pohon indeks biner .

Ini adalah implementasi Python sederhana:

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

dan

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

print select(population, weights)

Dalam algoritme genetik, prosedur pemilihan ini disebut sebagai Pemilihan proporsi proporsional atau Pemilihan Roda Roulette sejak:

• proporsi roda ditetapkan untuk masing-masing pilihan yang mungkin berdasarkan nilai bobotnya. Ini dapat dicapai dengan membagi bobot seleksi dengan bobot total semua seleksi, sehingga menormalkannya menjadi 1.
• kemudian pemilihan acak dibuat mirip dengan bagaimana roda roulette diputar.

Algoritma tipikal memiliki kompleksitas O (N) atau O (log N) tetapi Anda juga dapat melakukan O (1) (mis. Pemilihan roda Roulette melalui penerimaan stokastik ).

Inti ini melakukan persis apa yang Anda minta.

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

Anda bisa menggunakannya seperti itu:

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

Kode di atas kemungkinan besar (% 98) menghasilkan 0 yang merupakan indeks 'apel' untuk larik yang diberikan.

Kode ini juga menguji metode yang disediakan di atas:

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

Ini memberikan output seperti itu:

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