Jak mogę stworzyć „losowy” generator, który jest uprzedzony przez wcześniejsze zdarzenia?

Chcę wdrożyć system oparty na szansie, który jest uprzedzony przez wcześniejsze zdarzenie.

Tło: Kilka lat temu pamiętam aktualizację World of Warcraft, która ogłosiła, że ​​wprowadzili nowy kalkulator szans, który przeciwdziałałby kolczastym łańcuchom wydarzeń. (np. zadawanie krytycznych ciosów lub unikanie kilku razy z rzędu). Pomysł polegał na tym, że w przypadku unikania trafienia szansa na uniknięcie kolejnego trafienia byłaby zmniejszona, ale działałoby to w obie strony. Nie uchylanie się od trafienia zwiększyłoby szanse na uniknięcie kolejnego trafienia. Główna sztuczka polegała na tym, że podczas kilku prób szansa na unik nadal odpowiadałaby procentowi podanemu graczowi w jego arkuszu statystyk.

Tego rodzaju system bardzo mnie wtedy intrygował, a teraz jestem w potrzebie takiego rozwiązania.

Oto moje kłopoty:

• Zgaduję, że byłbym w stanie znaleźć zasoby online na temat wdrażania takiego systemu, ale być może brakuje mi odpowiednich słów, aby go znaleźć.
• Potrzebuję również tego podejścia, aby dopasować system, który nie jest dwumianowy (tj. Dwa wyniki), ale zamiast tego zawiera 4 wzajemnie wykluczające się zdarzenia.

Moje obecne podejście jest podobne do systemu biletów losowych. Kiedy zdarzenie ma miejsce, zmieniam wagi na korzyść wszystkich innych zdarzeń. Mogłoby to zadziałać, gdyby cztery zdarzenia miały być jednakowo prawdopodobne, ale w moim przypadku musi być znacznie bardziej powszechne. Ale ponieważ zdarzenie dominujące zdarza się częściej, przesuwa on ciężary innych o wiele wyżej niż zamierzano i wydaje mi się, że nie mogę znaleźć liczb dla przesunięć wagi, które są potrzebne, aby utrzymać średnią liczbę biletów wokół początkowych wartości, które były zdarzeniem dany.

Doceniono by kilka wskazówek kierunkowych lub wyraźny przykład.

Zasadniczo pytasz o „pół-losowy” generator zdarzeń, który generuje zdarzenia o następujących właściwościach:

1. Średnie tempo wystąpienia każdego zdarzenia jest określone z góry.

2. To samo zdarzenie jest mniej prawdopodobne, że wystąpi dwa razy z rzędu, niż byłoby przypadkowe.

3. Wydarzenia nie są w pełni przewidywalne.

Jednym ze sposobów na to jest najpierw zaimplementowanie generatora nieprzypadkowych zdarzeń, który spełnia cele 1 i 2, a następnie dodanie losowości, aby osiągnąć cel 3.

W przypadku generatora zdarzeń nieprzypadkowych możemy zastosować prosty algorytm ditheringu . W szczególności niech p ₁ , p ₂ , ..., p _n będą względnymi prawdopodobieństwami zdarzeń 1 do n , a niech s = p ₁ + p ₂ + ... + p _n będzie sumą wag. Następnie możemy wygenerować nieprzypadkową, maksymalnie równorzędną sekwencję zdarzeń, stosując następujący algorytm:

1. Początkowo niech e ₁ = e ₂ = ... = e _n = 0.

2. Aby wygenerować zdarzenie, zwiększ każde e _i o p _i wyślij zdarzenie k, dla którego e _k jest największe (zerwanie powiązań w dowolny sposób).

3. Decrement e _k o s , a następnie powtórz czynności od punktu 2.

Na przykład, biorąc pod uwagę trzy zdarzenia A, B i C, przy p _A = 5, p _B = 4 i p _C = 1, ten algorytm generuje coś w rodzaju następującej sekwencji wyników:

A B A B C A B A B A A B A B C A B A B A A B A B C A B A B A

Zauważ, że ta sekwencja 30 zdarzeń zawiera dokładnie 15 As, 12 Bs i 3 Cs. Nie do końca optymalnie się rozprowadza - jest kilka przypadków dwóch jak z rzędu, których można było uniknąć - ale się zbliża.

Teraz, aby dodać losowość do tej sekwencji, masz kilka (niekoniecznie wykluczających się) opcji:

• Możesz śledzić porady Philippa i utrzymać „talię” z N nadchodzących wydarzeniach, na pewnym odpowiednim rozmiarze numerem N . Za każdym razem, gdy musisz wygenerować zdarzenie, wybierasz losowe zdarzenie z talii, a następnie zamieniasz je na wyjście następnego zdarzenia za pomocą algorytmu ditheringu powyżej.

  Zastosowanie tego do powyższego przykładu, przy N = 3, daje np .:

  A B A B C A B B A B A B C A A A A B B A B A C A B A B A B A

  podczas gdy N = 10 daje bardziej losowy wygląd:

  A A B A C A A B B B A A A A A A C B A B A A B A C A C B B B

  Zwróć uwagę, że wspólne zdarzenia A i B kończą się znacznie większą liczbą przebiegów z powodu przetasowania, podczas gdy rzadkie zdarzenia C są wciąż dość dobrze rozłożone.

• Możesz wprowadzić losowość bezpośrednio do algorytmu ditheringu. Na przykład, zamiast zwiększając e _I o p _ı w etapie 2, można ją zwiększyć p _ı x losowej (0, 2), w której losowy ( , b ) jest równomiernie rozproszony liczby losowej o wartości pomiędzy i b ; dałoby to wynik podobny do następującego:

  A B B C A B A A B A A B A B A A B A A A B C A B A B A C A B

  lub możesz zwiększyć e _i o p _i + losowo (- c , c ), co dałoby (dla c = 0,1 × s ):

  B A A B C A B A B A B A B A C A B A B A B A A B C A B A B A

  lub, dla c = 0,5 × s :

  B A B A B A C A B A B A A C B C A A B C B A B B A B A B C A

  Zauważ, że schemat addytywny ma znacznie silniejszy efekt losowy dla rzadkich zdarzeń C niż dla wspólnych zdarzeń A i B, w porównaniu do multiplikatywnego; to może, ale nie musi być pożądane. Oczywiście, można również korzystać z niektórych kombinacji tych systemów, lub jakiegokolwiek innego dostosowywania do przyrostów, jak długo zachowuje właściwość, że średni przyrost e _ja równa P _I .

• Alternatywnie można zakłócać wyjście algorytmu ditheringu, czasami zastępując wybrane zdarzenie k losowym (wybranym zgodnie z surowymi wagami p _i ). Tak długo, jak użyjesz tego samego k w kroku 3, jak wypisujesz w kroku 2, proces ditheringu będzie miał tendencję do wyrównywania przypadkowych fluktuacji.

  Na przykład, oto przykładowy wynik, z 10% szansą na losowe wybranie każdego zdarzenia:

  B A C A B A B A C B A A B B A B A B A B C B A B A B C A B A

  a oto przykład z 50% szansą, że każde wyjście będzie losowe:

  C B A B A C A B B B A A B A A A A A B B A C C A B B A B B C

  Można również rozważyć karmienie mieszankę czysto losowych i wygładzony wydarzeń na pokładzie / mieszania basenie, jak opisano powyżej, lub może losowanie algorytm ditheringu wybierając k losowo, jako ważone przez e _i s (leczenia negatywnych ciężarów jako zero).

Ps. Oto kilka całkowicie losowych sekwencji zdarzeń, z tymi samymi średnimi wskaźnikami, dla porównania:

A C A A C A B B A A A A B B C B A B B A B A B A A A A A A A
B C B A B C B A A B C A B A B C B A B A A A A B B B B B B B
C A A B A A B B C B B B A B A B A A B A A B A B A C A A B A

Styczna: Ponieważ w komentarzach pojawiła się debata na temat tego, czy w przypadku rozwiązań pokładowych konieczne jest umożliwienie opróżnienia pokładu przed ponownym napełnieniem, postanowiłem dokonać graficznego porównania kilku strategii napełniania pokładu:

^{Wykres kilku strategii generowania pół losowych rzutów monetą (przy średnim stosunku główek do reszek wynoszącym 50:50). Oś pozioma to liczba przewrotów, oś pionowa to skumulowana odległość od oczekiwanego stosunku, mierzona jako (głowice - ogony) / 2 = głowice - przewroty / 2.}

Czerwone i zielone linie na wykresie pokazują dwa niepoparte na pokładzie algorytmy do porównania:

• Czerwona linia, deterministyczne dithering : wyniki parzyste są zawsze główkami, wyniki nieparzyste zawsze są ogonami.
• Zielona linia, niezależne losowe rzuty : każdy wynik jest wybierany niezależnie losowo, z 50% szansą na głowy i 50% szansą na reszkę.

Pozostałe trzy linie (niebieski, fioletowy i cyjan) pokazują wyniki trzech strategii opartych na talii, z których każda została wdrożona przy użyciu talii 40 kart, która początkowo jest wypełniona 20 kartami „głów” i 20 kartami „ogonów”:

• Niebieska linia, wypełnij, gdy jest pusta : Karty losowane są do momentu, aż talia będzie pusta, a następnie do talii zostaną napełnione 20 kart „głów” i 20 kart „ogonów”.
• Purpurowa linia, wypełnij, gdy połowa będzie pusta : Karty losowane są do momentu, gdy w talii pozostanie 20 kart; następnie talię uzupełnia się 10 kartami „głów” i 10 kartami „ogonami”.
• Cyjan-linia, wypełniaj w sposób ciągły : karty losowane są losowo; losowanie parzyste jest natychmiast zastępowane kartą „głów”, a losowanie nieparzyste kartą „reszka”.

Oczywiście powyższy wykres jest tylko pojedynczą realizacją losowego procesu, ale jest dość reprezentatywny. W szczególności widać, że wszystkie procesy pokładowe mają ograniczone odchylenie i pozostają dość blisko czerwonej (deterministycznej) linii, podczas gdy czysto losowa zielona linia ostatecznie odchodzi.

(W rzeczywistości odchylenie linii niebieskiej, purpurowej i niebieskiej od zera jest ściśle ograniczone rozmiarem talii: niebieska linia nigdy nie może dryfować więcej niż 10 kroków od zera, fioletowa linia może uzyskać tylko 15 kroków od zera , a linia cyjanowa może dryfować co najwyżej o 20 kroków od zera. Oczywiście w praktyce żadna z linii, która faktycznie osiąga swój limit, jest bardzo mało prawdopodobna, ponieważ istnieje silna tendencja do powrotu bliżej zera, jeśli wędrują zbyt daleko poza.)

Na pierwszy rzut oka nie ma oczywistej różnicy między różnymi strategiami opartymi na talii (chociaż średnio niebieska linia pozostaje nieco bliżej czerwonej linii, a linia cyjanowa pozostaje nieco dalej), ale dokładniejsze sprawdzenie niebieskiej linii ujawnia wyraźny deterministyczny wzór: co 40 rysunków (oznaczonych przerywanymi szarymi pionowymi liniami) niebieska linia dokładnie spotyka czerwoną linię na zero. Linie fioletowe i cyjanowe nie są tak ściśle ograniczone i mogą trzymać się zera w dowolnym momencie.

We wszystkich strategiach opartych na talii ważną cechą, która ogranicza ich warianty, jest fakt, że podczas losowania kart z talii, determinacja jest uzupełniana . Gdyby karty użyte do uzupełnienia talii były wybierane losowo, wszystkie strategie oparte na talii byłyby nie do odróżnienia od czystego losowego wyboru (zielona linia).

Nie rzucaj kośćmi, rozdawaj karty.

Weź wszystkie możliwe wyniki RNG, umieść je na liście, losowo potasuj i zwróć wyniki w losowej kolejności. Gdy znajdziesz się na końcu listy, powtórz.

Wyniki będą nadal równomiernie rozmieszczone, ale poszczególne wyniki nie będą się powtarzać, chyba że ostatnia z listy będzie również pierwszą z następnych.

Jeśli jest to zbyt przewidywalne dla twojego gustu, możesz użyć listy, która jest nrazy liczba możliwych wyników i umieścić każdy możliwy wynik nrazy przed tasowaniem. Lub możesz przetasować listę, zanim zostanie ona całkowicie iterowana.

Możesz spróbować losowego wykresu Markowa . Rozważ każde zdarzenie, które może wystąpić, jako węzeł na wykresie. Z każdego wydarzenia utwórz link do siebie, które może nastąpić po nim. Każde z tych łączy jest ważone przez coś zwanego prawdopodobieństwem przejścia . Następnie wykonujesz losowy spacer po wykresie zgodnie z modelem przejścia.

Na przykład możesz mieć wykres przedstawiający wynik ataku (trafienie krytyczne, unik itp.). Zainicjuj węzeł początkowy na jeden wybrany losowo, biorąc pod uwagę statystyki gracza (po prostu „rzuć kostką”). Następnie, przy następnym ataku, zdecyduj, co stanie się dalej, biorąc pod uwagę model przejściowy.

Należy zadbać o to, aby zdecydować, jak ważić przejścia. Po pierwsze, wszystkie przejścia wychodzące z węzła muszą się sumować z prawdopodobieństwem 1. Jedną prostą rzeczą, którą możesz zrobić, jest przejście z każdego węzła do każdego innego węzła, z wagami równoważnymi prawdopodobieństwu wystąpienia tych zdarzeń a priori , biorąc pod uwagę, że bieżące zdarzenie nie może się powtórzyć.

Na przykład, jeśli masz trzy zdarzenia:

  Critical, P = 0.1
  Hit,      P = 0.3
  Miss,     P = 0.6

Możesz skonfigurować model przejścia tak, aby trafienie krytyczne nie powtórzyło się po prostu poprzez równomierne rozłożenie jego masy prawdopodobieństwa na inne zdarzenia:

  Critical -> Critical,   P = 0.0
  Critical -> Hit,        P = 0.35
  Critical -> Miss,       P = 0.65

EDYCJA: Jak mówią komentarze poniżej, ten model nie jest wystarczająco skomplikowany, aby uzyskać pożądane zachowanie. Zamiast tego może być konieczne dodanie wielu dodatkowych stanów!

Oto implementacja, którą utworzyłem w C #, która:

• Aktywuj zdarzenia na podstawie prawdopodobieństwa
• Dostosuj te prawdopodobieństwa, aby zmniejszyć szanse na powtarzające się zdarzenia
• Nie oddalaj się zbytnio od pierwotnych prawdopodobieństw

Dodałem kilka komentarzy, abyś mógł zobaczyć, co robię.

    int percentageEvent1 = 15; //These are the starter values. So given a scenario, the
    int percentageEvent2 = 40; //player would have around a 15 percent chance of event
    int percentageEvent3 = 10; //one occuring, a 40 percent chance of event two occuring
    int percentageEvent4 = 35; //10 percent for event three, and 35 percent for event four.

    private void ResetValues()
    {
        percentageEvent1 = 15;
        percentageEvent2 = 40;
        percentageEvent3 = 10;
        percentageEvent4 = 35;
    }

    int resetCount = 0; //Reset the probabilities every so often so that they don't stray too far.

    int variability = 1; //This influences how much the chance of an event will increase or decrease
                           //based off of past events.

    Random RandomNumberGenerator = new Random();

    private void Activate() //When this is called, an "Event" will be activated based off of current probability.
    {
        int[] percent = new int[100];
        for (int i = 0; i < 100; i++) //Generate an array of 100 items, and select a random event from it.
        {
            if (i < percentageEvent1)
            {
                percent[i] = 1; //Event 1
            }
            else if (i < percentageEvent1 + percentageEvent2)
            {
                percent[i] = 2; //Event 2
            }
            else if (i < percentageEvent1 + percentageEvent2 + percentageEvent3)
            {
                percent[i] = 3; //Event 3
            }
            else
            {
                percent[i] = 4; //Event 4
            }
        }
        int SelectEvent = percent[RandomNumberGenerator.Next(0, 100)]; //Select a random event based on current probability.

        if (SelectEvent == 1)
        {
            if (!(percentageEvent1 - (3 * variability) < 1)) //Make sure that no matter what, probability for a certain event
            {                                                //does not go below one percent.
                percentageEvent1 -= 3 * variability;
                percentageEvent2 += variability;
                percentageEvent3 += variability;
                percentageEvent4 += variability;
            }
        }
        else if (SelectEvent == 2)
        {
            if (!(percentageEvent2 - (3 * variability) < 1))
            {
                percentageEvent2 -= 3 * variability;
                percentageEvent1 += variability;
                percentageEvent3 += variability;
                percentageEvent4 += variability;
            }
        }
        else if (SelectEvent == 3)
        {
            if (!(percentageEvent3 - (3 * variability) < 1))
            {
                percentageEvent3 -= 3 * variability;
                percentageEvent1 += variability;
                percentageEvent2 += variability;
                percentageEvent4 += variability;
            }
        }
        else
        {
            if (!(percentageEvent4 - (3 * variability) < 1))
            {
                percentageEvent4 -= 3 * variability;
                percentageEvent1 += variability;
                percentageEvent2 += variability;
                percentageEvent3 += variability;
            }
        }

        resetCount++;
        if (resetCount == 10)
        {
            resetCount = 0;
            ResetValues();
        }

        RunEvent(SelectEvent); //Run the event that was selected.
    }

Mam nadzieję, że to pomoże, proszę sugerować ulepszenia tego kodu w komentarzach, dzięki!

Pozwól mi trochę uogólnić odpowiedź mklingen . Zasadniczo chcesz wdrożyć błąd Hazardzisty , ale przedstawię tutaj bardziej ogólną metodę:

Powiedz, że są nmożliwe zdarzenia z prawdopodobieństwem p_1, p_2, ..., p_n. Kiedy zdarzenie się iwydarzy, jego prawdopodobieństwo przeskaluje się ze współczynnikiem 0≤a_i≤1/p_i(to drugie jest ważne, w przeciwnym razie prawdopodobieństwo będzie większe niż jedno, a pozostałe zdarzenia muszą mieć ujemne prawdopodobieństwa , co w zasadzie oznacza „ anty ” zdarzenia. Lub coś takiego) typowo a_i<1. Możesz na przykład wybrać a_i=p_i, co oznacza, że ​​prawdopodobieństwo wystąpienia zdarzenia po raz drugi jest pierwotnym prawdopodobieństwem, że wydarzenie nastąpi dokładnie dwa razy z rzędu, np. Drugie rzut monetą miałby prawdopodobieństwo 1/4 zamiast 1/2. Z drugiej strony możesz też mieć coś a_i>1, co oznaczałoby wywołanie „udaru szczęścia / nieszczęścia”.

Wszystkie pozostałe zdarzenia powinny być jednakowo prawdopodobne względem siebie, tzn. Wszystkie muszą zostać przeskalowane o ten sam współczynnik, b_itak aby suma wszystkich prawdopodobieństw była równa jeden, tj.

1 = a_i*p_i + b_i*(1-p_i)  # Σ_{j≠i) p_j  = 1 - p_i
⇒ b_i = (1 - a_i*p_i) / (1 - p_i).   (1)

Do tej pory takie proste. Ale teraz dodajmy kolejny wymóg: biorąc pod uwagę wszystkie możliwe sekwencje dwóch zdarzeń, wyodrębnione z nich prawdopodobieństwa pojedynczego zdarzenia będą pierwotnymi prawdopodobieństwami.

Pozwolić

        / p_i * b_i * p_j  (j≠i)
p_ij = <
        \ a_i * (p_i)²     (j=i)

oznacz prawdopodobieństwo wystąpienia zdarzenia jpo wydarzeniu ii zwróć uwagę, że p_ij≠p_jichyba b_i=b_j (2)(co (1)implikuje a_j = 1 - a_i*p_i + (1-a_i)*p_i/p_j). Tego właśnie wymaga twierdzenie Bayesa, co również implikuje

Σ_j p_ij = p_i * b_i * (1 - p_i) + a_i * (p_i)²
         = b_i * p_i + (a_i - b_i) * (p_i)²
         = p_i  # using (1)

tak jak chcesz. Zwróć uwagę, jak to oznacza, że a_inaprawia się wszystkie pozostałe.

Zobaczmy teraz, co się stanie, gdy zastosujemy tę procedurę wiele razy, tj. Dla sekwencji trzech i więcej zdarzeń. Istnieją zasadniczo dwie opcje wyboru ustalonych prawdopodobieństw trzeciego zdarzenia:

a) Zapomnij o pierwszym zdarzeniu i urządzeniu tak, jakby miało miejsce tylko drugie, tj

         / p_ij * a_j * p_j  (j=k)
p_ijk = <
         \ p_ij * b_j * p_l  (j≠k)

Pamiętaj, że zwykle narusza to Bayesa, ponieważ np. p_jik≠p_ikjW większości przypadków.

b) Użyj prawdopodobieństw p_ij(dla ustalonych i) jako nowych prawdopodobieństw, pi_jz których uzyskasz nowe prawdopodobieństwa, pi_jkaby zdarzenie kmiało miejsce w następnej kolejności. To, czy zmodyfikujesz, ai_jczy nie, zależy od ciebie, ale pamiętaj, że nowe bi_jsą zdecydowanie różne ze względu na zmodyfikowane pi_j. Z drugiej strony wybór ai_jprawdopodobnie jest ograniczony przez wymaganie wszystkich permutacji ijkwystąpienia z tym samym prawdopodobieństwem. Zobaczmy...

         / p_ij * bi_j * pi_k  (j≠k)
p_ijk = <
         \ (p_ij)² * ai_j      (j=k)

         / b_i * bi_j * p_i * p_j * pi_k  (i≠j≠k≠i)
         | b_i * ai_j * p_i * (p_j)²      (i≠j=k)
      = <  a_i * (p_i)² * bi_i * pi_k     (i=j≠k)
         | b_i * p_i * bi_j * p_k * pi_i  (i=k≠j)
         \ a_i * ai_i * (p_i)² * pi_i     (i=k=j)

i ich cykliczne permutacje, które muszą być równe dla odpowiednich przypadków.

Obawiam się, że moja kontynuacja będzie musiała chwilę poczekać ...

Myślę, że najlepszą opcją jest użycie losowego wyboru przedmiotów. Jest to implementacja dla C # tutaj , ale można je łatwo znaleźć lub wykonane w innych językach.

Pomysł polegałby na zmniejszeniu wagi opcji za każdym razem, gdy jest ona wybierana, i zwiększaniu jej za każdym razem, gdy nie jest wybierana.

Na przykład, jeśli zmniejszysz wagę wybranej opcji o NumOptions-1i zwiększysz wagę każdej innej opcji o 1 (uważając, aby usunąć przedmioty o wadze <0 i przeczytać je, gdy wzrosną powyżej 0) , każda opcja zostanie wybrana w przybliżeniu tyle samo razy w ciągu długiego okresu, ale ostatnio wybrane opcje będą znacznie mniej prawdopodobne.

Problem z korzystaniem z losowego zamawiania, jak sugeruje wiele innych odpowiedzi, polega na tym, że po wybraniu każdej opcji, z wyjątkiem jednej, można z całkowitą pewnością przewidzieć, która opcja zostanie wybrana w następnej kolejności. To niezbyt losowe.

Moja odpowiedź jest nieprawidłowa, mój test był wadliwy.

Zostawiam tę odpowiedź tutaj do dyskusji i komentarzy, które wskazują na wady tego projektu, ale rzeczywisty test był niepoprawny.

To, czego szukasz, to waga ważona: wagi dla czterech możliwych wyników muszą być dalej korygowane (ważone) o poprzednie wyniki, przy jednoczesnym zachowaniu odpowiednich ogólnych wag.

Najłatwiejszym sposobem na osiągnięcie tego jest zmiana wszystkich wag dla każdego rzutu poprzez zmniejszenie ciężaru dla określonej wartości rzutu i zwiększenie innych ciężarów .

Na przykład załóżmy, że masz 4 ciężary: Fumble, Miss, Hit i Crit. Powiedzmy też, że pożądane dla nich ogólne wagi to Fumble = 10%, Miss = 50%, Hit = 30% i Crit = 10%.

Jeśli używasz generatora liczb losowych (RNG) do generowania wartości od 1 do 100, a następnie porównujesz tę wartość z miejscem, w którym mieści się w tym zakresie (1-10 Fumble, 11-60 miss, 61-90 hit, 91-100 kryt. ), generujesz indywidualny rzut.

Jeśli, kiedy wykonasz ten rzut, natychmiast dostosujesz te zakresy na podstawie wartości rzutu, będziesz oceniać przyszłe rzuty, ale musisz także zmniejszyć wagę rzutu o tę samą całkowitą kwotę, o którą zwiększasz pozostałe ciężary. W naszym powyższym przykładzie zmniejszysz zrolowany ciężar o 3 i zwiększysz pozostałe ciężary o 1 każdy.

Jeśli zrobisz to dla każdego rzutu, nadal będziesz mieć szansę na serie, ale zostaną one znacznie zmniejszone, ponieważ dla każdego rzutu zwiększasz szansę, że przyszłe rzuty będą inne niż bieżący rzut. Możesz zwiększyć ten efekt, a tym samym jeszcze bardziej zmniejszyć ryzyko powstawania smug, zwiększając / zmniejszając ciężary o większy współczynnik (np. Zmniejsz prąd o 6 i zwiększ pozostałe o 2).

Uruchomiłem szybką aplikację, aby zweryfikować to podejście, a po 32 000 iteracjach z tymi wagami generuje następujące wykresy. Górny wykres pokazuje natychmiastowe wartości 4 wag dla każdego rzutu, a dolny wykres pokazuje sumę każdego rodzaju wyniku zrolowanego do tego punktu.

Jak widać, wagi wahają się nieznacznie wokół pożądanych wartości, ale ogólne masy pozostają w pożądanych zakresach, a po ustaleniu początkowej różnorodności liczb początkowych wyniki pasują prawie do pożądanych wartości procentowych.

Zauważ, że ten przykład został stworzony przy użyciu klasy .NET System.Random, która tak naprawdę nie jest jedną z lepszych RNG, więc prawdopodobnie możesz uzyskać dokładniejsze wyniki, używając lepszego RNG. Zauważ również, że 32000 to maksymalne wyniki, które mogłem przedstawić za pomocą tego narzędzia, ale moje narzędzie testowe było w stanie wygenerować ponad 500 milionów wyników przy tych samych ogólnych wzorcach.

Możesz zrobić to, co zasadniczo jest filtrem. Śledź n ostatnich wydarzeń. Prawdopodobieństwo to niektóre filtry zastosowane do tych zdarzeń. 0 filtr jest podstawowym prawdopodobieństwem, jeśli 0, to unikniesz, jeśli 1 nie. Załóżmy, że podstawa wynosiła 25%, a filtr zmniejsza się o połowę z każdą iteracją. Twój filtr to:

[.25 .125 .0625 .03125] 

Jeśli chcesz, możesz kontynuować. Ogólne prawdopodobieństwo tego schematu jest nieco wyższe niż podstawowe prawdopodobieństwo 0,25. W rzeczywistości prawdopodobieństwo, biorąc pod uwagę ten sam schemat, jest (nazywam x rzeczywiste prawdopodobieństwo, p jest wejściem prawdopodobieństwa):

x=p+(1-x)*(p/2+p/4+p/8)

Rozwiązywanie dla x, znajdujemy odpowiedź brzmi p(1+1/2+1/4+1/8)/(1+p(1/2+1/4+1/8), czy za naszym konkretnym przypadku x=0.38461538461. Ale tak naprawdę chcesz znaleźć p, biorąc pod uwagę x. To okazuje się trudniejszym problemem. Jeśli założono filtr nieskończony, problemem staje się x+x*p=2*plub p=x/(2-x). Więc zwiększając swój filtr, możesz następnie rozwiązać dla liczby p, która średnio da ci te same wyniki, ale w tempie zależnym od tego, ile sukcesów ostatnio się wydarzyło.

Zasadniczo za pomocą poprzednich wartości określa się próg akceptacji w tej rundzie i przyjmuje wartość losową. Następnie wygeneruj następną losową wartość dla danego filtra.

Tak jak sam się zaproponowałeś, jednym z podejść do tego jest wdrożenie ważonej losowej. Chodzi o to, aby stworzyć generator liczb losowych (lub wyników), w którym wagi i wyniki mogą być modyfikowane.

Oto implementacja tego w Javie.

import java.util.Map;
import java.util.Random;

/**
 * A psuedorandom weighted outcome generator
 * @param <E> object type to return
 */
public class WeightedRandom<E> {

    private Random random;
    private Map<E, Double> weights;

    public WeightedRandom(Map<E, Double> weights) {
        this.random = new Random();
        this.weights = weights;
    }

    /**
     * Returns a random outcome based on the weight of the outcomes
     * @return
     */
    public E nextOutcome() {
        double totalweight = 0;

        // determine the total weigth
        for (double w : weights.values()) totalweight += w;

        // determine a value between 0.0 and the total weight
        double remaining = random.nextDouble() * totalweight;

        for (E entry : weights.keySet()) {
            // subtract the weight of this entry
            remaining -= weights.get(entry);

            // if the remaining is smaller than 0, return this entry
            if (remaining <= 0) return entry;
        }

        return null;
    }

    /**
     * Returns the weight of an outcome
     * @param outcome the outcome to query
     * @return the weight of the outcome, if it exists
     */
    public double getWeight(E outcome) {
        return weights.get(outcome);
    }

    /**
     * Sets the weight of an outcome
     * @param outcome the outcome to change
     * @param weight the new weigth
     */
    public void setWeight(E outcome, double weight) {
        weights.put(outcome, weight);
    }
}

EDYCJA W przypadku, gdy chcesz automatycznie dostosowywać wagi, na przykład zwiększ szansę na A, gdy wynik to B. Możesz również:

1. Zmień zachowanie nextOutcome()metody, aby modyfikowała wagę zgodnie z wynikiem
2. Służy setWeight()do modyfikowania masy zgodnie z wynikiem.