У меня есть ящик для лута, который я хочу заполнить случайным предметом. Но я хочу, чтобы у каждого предмета был свой шанс быть выбранным. Например:

• 5% шанс 10 золота
• 20% шанс меча
• 45% шанс щита
• 20% шанс брони
• 10% шанс зелья

Как я могу сделать так, чтобы я выбрал точно один из пунктов выше, где эти проценты являются соответствующими шансами на получение добычи?

Мягкое решение вероятностей

Жестко запрограммированное вероятностное решение имеет тот недостаток, что вам необходимо установить вероятности в своем коде. Вы не можете определить их во время выполнения. Это также трудно поддерживать.

Вот динамическая версия того же алгоритма.

1. Создайте массив пар фактических предметов и веса каждого предмета
2. Когда вы добавляете элемент, вес элемента должен быть его собственным весом плюс сумма весов всех элементов, уже находящихся в массиве. Таким образом, вы должны отслеживать сумму отдельно. Тем более, что оно понадобится вам для следующего шага.
3. Чтобы получить объект, сгенерируйте случайное число между 0 и суммой весов всех элементов.
4. итерируйте массив от начала до конца, пока не найдете запись с весом, большим или равным случайному числу

Вот пример реализации в Java в форме класса шаблона, который вы можете создать для любого объекта, который использует ваша игра. Затем вы можете добавить объекты с помощью метода .addEntry(object, relativeWeight)и выбрать одну из записей, которые вы добавили ранее с.get()

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class WeightedRandomBag<T extends Object> {

    private class Entry {
        double accumulatedWeight;
        T object;
    }

    private List<Entry> entries = new ArrayList<>();
    private double accumulatedWeight;
    private Random rand = new Random();

    public void addEntry(T object, double weight) {
        accumulatedWeight += weight;
        Entry e = new Entry();
        e.object = object;
        e.accumulatedWeight = accumulatedWeight;
        entries.add(e);
    }

    public T getRandom() {
        double r = rand.nextDouble() * accumulatedWeight;

        for (Entry entry: entries) {
            if (entry.accumulatedWeight >= r) {
                return entry.object;
            }
        }
        return null; //should only happen when there are no entries
    }
}

Использование:

WeightedRandomBag<String> itemDrops = new WeightedRandomBag<>();

// Setup - a real game would read this information from a configuration file or database
itemDrops.addEntry("10 Gold",  5.0);
itemDrops.addEntry("Sword",   20.0);
itemDrops.addEntry("Shield",  45.0);
itemDrops.addEntry("Armor",   20.0);
itemDrops.addEntry("Potion",  10.0);

// drawing random entries from it
for (int i = 0; i < 20; i++) {
    System.out.println(itemDrops.getRandom());
}

Вот тот же класс, реализованный в C # для вашего проекта Unity, XNA или MonoGame:

using System;
using System.Collections.Generic;

class WeightedRandomBag<T>  {

    private struct Entry {
        public double accumulatedWeight;
        public T item;
    }

    private List<Entry> entries = new List<Entry>();
    private double accumulatedWeight;
    private Random rand = new Random();

    public void AddEntry(T item, double weight) {
        accumulatedWeight += weight;
        entries.Add(new Entry { item = item, accumulatedWeight = accumulatedWeight });
    }

    public T GetRandom() {
        double r = rand.NextDouble() * accumulatedWeight;

        foreach (Entry entry in entries) {
            if (entry.accumulatedWeight >= r) {
                return entry.item;
            }
        }
        return default(T); //should only happen when there are no entries
    }
}

И вот один в JavaScript :

var WeightedRandomBag = function() {

    var entries = [];
    var accumulatedWeight = 0.0;

    this.addEntry = function(object, weight) {
        accumulatedWeight += weight;
        entries.push( { object: object, accumulatedWeight: accumulatedWeight });
    }

    this.getRandom = function() {
        var r = Math.random() * accumulatedWeight;
        return entries.find(function(entry) {
            return entry.accumulatedWeight >= r;
        }).object;
    }   
}

Pro:

• Может обрабатывать любые весовые коэффициенты. Вы можете иметь предметы с астрономически малой вероятностью в наборе, если хотите. Весам также не нужно прибавлять до 100.
• Вы можете прочитать предметы и веса во время выполнения
• Использование памяти пропорционально количеству элементов в массиве

Contra:

• Требуется больше программирования, чтобы получить право
• В худшем случае вам может понадобиться выполнить итерацию всего массива ( O(n)сложность во время выполнения). Поэтому, когда у вас очень большой набор предметов и вы часто рисуете, это может стать медленным. Простая оптимизация заключается в том, чтобы сначала поставить наиболее вероятные элементы, чтобы в большинстве случаев алгоритм завершался рано. Более сложная оптимизация, которую вы можете сделать, состоит в том, чтобы использовать тот факт, что массив отсортирован, и выполнить поиск пополам. Это займет O(log n)время.
• Вам нужно создать список в памяти, прежде чем вы сможете его использовать (хотя вы можете легко добавлять элементы во время выполнения. Удаление элементов также может быть добавлено, но для этого потребуется обновить накопленные веса всех элементов, которые появляются после удаленной записи, что снова имеет O(n)худшее время выполнения)

Примечание: я создал библиотеку C # для этой конкретной проблемы

Другие решения хороши, если у вас есть только небольшое количество предметов, и ваши вероятности никогда не меняются. Однако с большим количеством элементов или изменением вероятностей (например, удаление элементов после их выбора) вам понадобится что-то более мощное.

Вот два наиболее распространенных решения (оба из которых включены в вышеуказанную библиотеку)

Метод псевдонима Уокера

Умное решение, которое очень быстро ( O(1)!), Если ваши вероятности постоянны. По сути, алгоритм создает 2D-дартс («таблицу псевдонимов») из ваших вероятностей и бросает в нее дротик.

Есть много статей в Интернете о том, как это работает, если вы хотите узнать больше.

Единственная проблема заключается в том, что если ваши вероятности изменяются, вам необходимо заново создать таблицу псевдонимов, что является медленным. Таким образом, если вам нужно удалить предметы после того, как они собраны, это не решение для вас.

Основанное на дереве решение

Другое распространенное решение - создать массив, в котором каждый элемент хранит сумму вероятности и всех элементов перед ним. Затем просто сгенерируйте случайное число из [0,1) и выполните двоичный поиск, где это число попадает в список.

Это решение очень легко кодировать / понимать, но выбор выполняется медленнее, чем метод псевдонима Уокера, и изменение вероятностей все еще происходит O(n). Мы можем улучшить его, превратив массив в дерево бинарного поиска, где каждый узел отслеживает сумму вероятностей во всех элементах своего поддерева. Затем, когда мы генерируем число из [0,1), мы можем просто пройтись по дереву, чтобы найти элемент, который оно представляет.

Это дает нам O(log n)возможность выбрать предмет и изменить вероятности! Это делает NextWithRemoval()очень быстро!

Результаты

Вот несколько быстрых тестов из приведенной выше библиотеки, сравнивающих эти два подхода

         Тесты WeightedRandomizer | Дерево | Стол
-------------------------------------------------- ---------------------------------
Добавить () x10000 + NextWithReplacement () x10: | 4 мс | 2 мс
Добавить () x10000 + NextWithReplacement () x10000: | 7 мс | 4 мс
Добавить () x10000 + NextWithReplacement () x100000: | 35 мс | 28 мс
(Add () + NextWithReplacement ()) x10000 (с чередованием) | 8 мс | 5403 мс
Добавить () x10000 + NextWithRemoval () x10000: | 10 мс | 5948 мс

Итак, как вы можете видеть, для особого случая статических (неизменяемых) вероятностей метод псевдонима Уокера работает примерно на 50-100% быстрее. Но в более динамичных случаях дерево на несколько порядков быстрее !

Решение Колесо Фортуны

Вы можете использовать этот метод, когда вероятности в вашем пуле предметов имеют довольно большой общий знаменатель, и вам нужно очень часто использовать его.

Создайте массив опций. Но вставляйте каждый элемент в него несколько раз, причем количество дубликатов каждого элемента пропорционально его вероятности появления. В приведенном выше примере все элементы имеют вероятности, которые являются множителями 5%, поэтому вы можете создать массив из 20 элементов, например:

10 gold
sword
sword
sword
sword
shield
shield
shield
shield
shield
shield
shield
armor
armor
armor
armor
potion
potion

Затем просто выберите случайный элемент этого списка, сгенерировав одно случайное целое число от 0 до длины массива - 1.

Недостатки:

• Вам нужно создать массив при первом создании элемента.
• Когда предполагается, что один из ваших элементов имеет очень низкую вероятность, вы получите действительно большой массив, который может потребовать много памяти.

Преимущества:

• Если у вас уже есть массив и вы хотите рисовать его несколько раз, тогда он очень быстрый. Только одно случайное целое число и один доступ к массиву.

Жестко-вероятностное решение

Самый простой способ найти случайный элемент из взвешенной коллекции - это пройти по цепочке операторов if-else, где каждое if-else увеличивается, вероятно, так как предыдущий не попадает.

int rand = random(100); //Random number between 1 and 100 (inclusive)
if(rand <= 5) //5% chance
{
    print("You found 10 gold!");
}
else if(rand <= 25) //20% chance
{
    print("You found a sword!");
}
else if(rand <= 70) //45% chance
{
    print("You found a shield!");
}
else if(rand <= 90) //20% chance
{
    print("You found armor!");
}
else //10% chance
{
    print("You found a potion!");
}

Причина, по которой условные выражения равны его вероятности плюс все предыдущие возможности условных вычислений, заключается в том, что предыдущие условные обозначения уже исключили возможность того, что они являются этими элементами. Таким образом, для условного щита else if(rand <= 70)70 равно 45% шанса щита, плюс 5% шанса золота и 20% шанса меча.

Преимущества:

• Легко программировать, потому что не требует структур данных.

Недостатки:

• Сложно поддерживать, потому что вам нужно поддерживать частоту выпадения в вашем коде. Вы не можете определить их во время выполнения. Поэтому, если вы хотите получить что-то большее в будущем, вы должны проверить другие ответы.

В C # вы можете использовать сканирование Linq для запуска вашего аккумулятора, чтобы проверить случайное число в диапазоне от 0 до 100.0f и .First (), чтобы получить. Так что, как одна строка кода.

Так что-то вроде:

var item = a.Select(x =>
{
    sum += x.prob;
    if (rand < sum)
        return x.item;
    else
        return null;
 }).FirstOrDefault());

sumявляется инициализированным нулем целым числом и aявляется списком вероятностей / элементов структуры / кортежей / экземпляров. randранее сгенерированное случайное число в диапазоне.

Это просто накапливает сумму по списку диапазонов до тех пор, пока она не превысит ранее выбранное случайное число, и возвращает либо элемент, либо ноль, где ноль будет возвращено, если диапазон случайных чисел (например, 100) меньше общего диапазона взвешивания по ошибке и выбранное случайное число находится за пределами общего диапазона взвешивания.

Однако вы заметите, что веса в OP близко соответствуют нормальному распределению (кривая Белла). Я думаю, что в общем случае вам не понадобятся конкретные диапазоны, вы будете стремиться к распределению, которое сужается либо вокруг кривой колокола, либо только на убывающей экспоненциальной кривой (например). В этом случае вы можете просто использовать математическую формулу для генерации индекса в массив элементов, отсортированных в порядке предпочтительной вероятности. Хорошим примером является CDF в нормальном распределении

Также пример здесь .

Другой пример - вы можете взять случайное значение от 90 градусов до 180 градусов, чтобы получить нижний правый квадрант круга, взять компонент x с помощью cos (r) и использовать его для индексации в списке приоритетов.

С различными формулами вы можете иметь общий подход, при котором вы просто вводите список приоритетов любой длины (например, N) и отображаете результат формулы (например, cos (x) от 0 до 1) путем умножения (например, Ncos (x) ) = От 0 до N), чтобы получить индекс.

Probabilities don’t need to be hard-coded. The items and the thresholds can be together in an array.

for X in items’range loop
  If items (X).threshold < random() then
     Announce (items(X).name)
     Exit loop
  End if
End loop

You do have to accumulate the thresholds still, but you can do it when creating a parameter file instead of coding it.

I done this function: https://github.com/thewheelmaker/GDscript_Weighted_Random Now! in your case you can use it like this:

on_normal_case([5,20,45,20,10],0)

It gives just a number between 0 to 4 but you can put it in array where you got the items.

item_array[on_normal_case([5,20,45,20,10],0)]

Or in function:

item_function(on_normal_case([5,20,45,20,10],0))

Here is the code. I made it on GDscript, you can, but it can alter other language, also check for logic errors:

func on_normal_case(arrayy,transformm):
    var random_num=0
    var sum=0
    var summatut=0
    #func sumarrays_inarray(array):
    for i in range(arrayy.size()):
        sum=sum+arrayy[i]
#func no_fixu_random_num(here_range,start_from):
    random_num=randi()%sum+1
#Randomies be pressed down
#first start from zero
    if 0<=random_num and random_num<=arrayy[0]:
        #print(random_num)
        #print(array[0])
        return 0+ transformm
    summatut=summatut+arrayy[0]
    for i in range(arrayy.size()-1):
        #they must pluss together
        #if array[i]<=random_num and random_num<array[i+1]:
        if summatut<random_num and random_num<=summatut+arrayy[i+1]:
            #return i+1+transform
            #print(random_num)
            #print(summatut)
            return i+1+ transformm

        summatut=summatut+arrayy[i+1]
    pass

It works like this: on_normal_case([50,50],0) This gives 0 or 1, it has same probability both.

on_normal_case([50,50],1) This gives 1 or 2, it has same probability both.

on_normal_case([20,80],1) This gives 1 or 2, it has bigger change to get two.

on_normal_case([20,80,20,20,30],1) This give random numbers range 1-5 and bigger numbers are more likely than smaller numbers.

on_normal_case([20,80,0,0,20,20,30,0,0,0,0,33],45) This throw dices between numbers 45,46,49,50,51,56 you see when there is zero it never occure.

So it function returns just one random number that depends lenght of that arrayy array and transformm number, and ints in the array are probability weights that a number might occure, where that number is location on the array, pluss transformm number.