事前のイベントによってバイアスされる「ランダム」ジェネレーターを作成するにはどうすればよいですか？

事前のイベントによって偏ったチャンスベースのシステムを実装したいと考えています。

背景：数年前、私はWorld of Warcraftのアップデートを思い出します。彼らは、スパイクチェーンのイベントに対抗する新しいチャンス計算機を実装したことを発表しました。（たとえば、クリティカルストライクを行うか、連続して数回回避する）。アイデアは、あなたがヒットをかわす場合、次のヒットをかわす可能性は減少するが、それは両方の方法で働くということでした。ヒットを回避しないと、次のヒットを回避する機会が等しく増加します。ここでの主要なトリックは、いくつかの試行にわたって、覆い焼きの可能性がプレイヤーの統計シートでプレイヤーに与えられた割合に対応することでした。

この種のシステムは当時非常に興味をそそられ、今ではそのような解決策が必要な状況にあります。

私のトラブルは次のとおりです。

• このようなシステムの実装に関するオンラインリソースを見つけることができると思いますが、それを見つけるための関連する話題の言葉が欠けているだけかもしれません。
• また、2項式（つまり2つの結果）ではなく、4つの相互に排他的なイベントを含むシステムに適合するために、このアプローチが必要です。

私の現在のアプローチは、ラッフルチケットシステムのアプローチに似ています。イベントが発生すると、他のすべてのイベントを優先して重みを変更します。4つのイベントが等しく発生する可能性がある場合、これは機能する可能性がありますが、私の場合は、より広く普及する必要があります。しかし、一般的なイベントがより頻繁に発生するため、他のものの重みが意図したよりもはるかに大きくシフトし、イベントがあった初期値の周りに平均チケット数を維持するために必要な重みシフトの数値を見つけることができないようです与えられた。

いくつかの方向ポインターまたは明確な例が大歓迎です。

基本的に、あなたが求めているのは、以下のプロパティを持つイベントを生成する「セミランダム」イベントジェネレータです。

1. 各イベントが発生する平均レートは事前に指定されています。

2. 同じイベントがランダムに発生するよりも、連続して2回発生する可能性は低くなります。

3. イベントは完全には予測できません。

そのための1つの方法は、最初に目標1と2を満たす非ランダムイベントジェネレーターを実装し、次に、ランダム性を追加して目標3を満たすことです。

非ランダムイベントジェネレーターには、単純なディザリングアルゴリズムを使用できます。具体的には、聞かせてP ₁、P ₂、...、P _Nにイベント1の相対尤度であるN、およびlet S = P ₁ + P ₂ + ... + Pを_n個の重みの合計です。その後、次のアルゴリズムを使用して、イベントの非ランダムな最大分散シーケンスを生成できます。

1. 最初に、e ₁ = e ₂ = ... = e _n = 0とします。

2. イベントを生成するには、各e _iをp _iだけインクリメントし、e _kが最大のイベントkを出力します（好きな方法でタイを壊します）。

3. e _kをsだけ減らし、手順2から繰り返します。

たとえば、p _A = 5、p _B = 4、p _C = 1の3つのイベントA、B、Cが与えられた場合、このアルゴリズムは次の出力シーケンスのようなものを生成します。

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

この30個のイベントのシーケンスには、正確に15個のAs、12個のB、および3個のCが含まれています。それは完全に最適な分布ではありません（2つのAsが連続して発生することはいくつかありますが、回避することはできましたが）。

ここで、このシーケンスにランダム性を追加するには、いくつかの（必ずしも相互に排他的ではない）オプションがあります。

• Philippのアドバイスに従い、適切なサイズの数Nに対して、N個の今後のイベントの「デッキ」を維持できます。イベントを生成する必要があるたびに、デッキからランダムなイベントを選択し、上記のディザリングアルゴリズムによって次のイベント出力に置き換えます。

  これを上記の例にN = 3で適用すると、次のようになります：

  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

  一方、N = 10はよりランダムに見えるようになります。

  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

  シャッフルにより、一般的なイベントAとBがより多くの実行で終了することに注意してください。一方、まれなCイベントは依然としてかなり間隔が空いています。

• ディザリングアルゴリズムにランダム性を直接注入できます。たとえば、ステップ2でe _iをp _iだけ増やす代わりに、p _i ×random（0、2）だけ増やすことができます。ここで、random（a、b）はaとbの間で一様に分布した乱数です。これにより、次のような出力が生成されます。

  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

  または、e _iをp _i + random（− c、c）だけインクリメントすることができます（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

  または、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

  乗法スキームと比較して、一般的なイベントAおよびBよりもまれなイベントCの方が、加算スキームのランダム化効果がはるかに強いことに注意してください。これは望ましい場合と望ましくない場合があります。もちろん、e _iの平均増分がp _iに等しいというプロパティを保持する限り、これらのスキームの組み合わせ、または増分に対する他の調整を使用することもできます。

• あるいは、選択したイベントkをランダムなイベント（生の重みp _iに応じて選択）に置き換えることにより、ディザリングアルゴリズムの出力を乱すことができます。ステップ2で出力したのと同じkをステップ3 でも使用している限り、ディザリングプロセスはランダムな変動を均等にする傾向があります。

  たとえば、各イベントがランダムに選択される可能性が10％の場合の出力例を次に示します。

  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

  そして、各出力がランダムである可能性が50％である例を次に示します。

  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

  上記のように、純粋にランダムなイベントとディザリングされたイベントの混合をデッキ/ミキシングプールに供給すること、またはe _i s（負の重みをゼロとして扱う）で重み付けされたkをランダムに選択してディザリングアルゴリズムをランダム化することも検討できます。

追伸 比較のために、同じ平均レートの完全にランダムなイベントシーケンスを次に示します。

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

タンジェント：があったので、コメントの中でいくつかの議論それが再充填される前のデッキが空にできるようにするために、デッキベースのソリューションのために、それが必要なのかどうかについて、私はいくつかのデッキ充填戦略のグラフィカルな比較を行うことにしました。

^{セミランダムコインフリップを生成するためのいくつかの戦略のプロット（平均して頭と尾の比率が50:50）。横軸はフリップの数、縦軸は予想される比率からの累積距離で、（heads-tails）/ 2 = heads-flips / 2として測定されます。}

プロットの赤と緑の線は、比較のために2つの非デッキベースのアルゴリズムを示しています。

• 赤い線、決定論的ディザリング：偶数の結果は常にヘッドであり、奇数の結果は常にテールです。
• 緑の線、独立したランダムフリップ：各結果はランダムに独立して選択され、50％の確率で頭を、50％の確率で尾を引きます。

他の3行（青、紫、シアン）は、最初に20枚の「ヘッド」カードと20枚の「テール」カードで満たされた40枚のカードのデッキを使用して実装された3つのデッキベースの戦略の結果を示しています：

• 青い線、空のときに塗りつぶす：カードはデッキが空になるまでランダムに描かれ、その後デッキには20枚の「ヘッド」カードと20枚の「テール」カードが補充されます。
• 紫の線、半分空になったら塗りつぶし：デッキに20枚のカードが残るまで、カードはランダムに描かれます。次に、デッキに10枚の「ヘッド」カードと10枚の「テール」カードを追加します。
• シアン線、連続塗りつぶし：カードはランダムに描かれます。偶数のドローはすぐに「ヘッド」カードに置き換えられ、奇数のドローは「テール」カードに置き換えられます。

もちろん、上記のプロットはランダムなプロセスの1つの実現にすぎませんが、合理的に代表しています。特に、すべてのデッキベースのプロセスにはバイアスが制限されており、赤（決定論的）線にかなり近づいていますが、純粋にランダムな緑の線は最終的にはさまよいます。

（実際、青、紫、シアンの線のゼロからのずれは、デッキのサイズに厳密に制限されています。青の線はゼロから10ステップ以上ドリフトすることはありません。紫の線はゼロから15ステップしか移動できません。もちろん、シアンの線はゼロから最大20ステップ離れてドリフトする可能性があります。もちろん、実際にその限界に到達するラインは、あまり遠くにさまれるとゼロに近づく傾向が強いため、実際にはほとんどありません。オフ。）

一見したところ、異なるデッキベースの戦略の間に明らかな違いはありませんが（平均して、青い線は赤い線にやや近く、シアンの線はやや遠くに留まります）、青い線を詳しく調べますは明確な決定的パターンを明らかにします：40の描画（灰色の点線の縦線でマーク）ごとに、青い線はゼロで赤い線と正確に一致します。紫とシアンの線はそれほど厳しく制限されておらず、どの点でもゼロから離れたままにできます。

すべてのデッキベースの戦略において、バリエーションを制限する重要な機能は、カードがデッキからランダムに引き出される一方で、デッキが決定論的に補充されるという事実です。デッキの補充に使用されるカード自体がランダムに選択された場合、デッキベースの戦略はすべて、純粋なランダム選択と区別できなくなります（緑の線）。

サイコロを振らないで、カードを配ります。

RNGのすべての可能な結果を​​取得し、それらをリストに入れ、ランダムにシャッフルし、ランダムな順序で結果を返します。リストの最後に達したら、繰り返します。

結果は依然として均一に分散されますが、リストの最後が次のリストの最初でもない限り、個々の結果は繰り返されません。

これがあなたの好みに対して少し予測しやすい場合、n可能な結果の数倍のリストを使用し、nシャッフルする前に各可能な結果を​​その時間に入れることができます。または、リストを完全に繰り返す前にリストをシャッフルできます。

マルコフランダムグラフを試すことができます。発生する可能性のある各イベントをグラフ内のノードと見なします。各イベントから、後に発生する可能性のある他の各イベントへのリンクを作成します。これらの各リンクは、遷移確率と呼ばれるものによって重み付けされます。次に、遷移モデルに従ってグラフのランダムウォークを実行します。

たとえば、攻撃の結果（クリティカルヒット、回避など）を表すグラフを作成できます。開始ノードを、プレイヤーの統計情報からランダムに選択したノードに初期化します（「サイコロを転がす」だけです）。次に、次の攻撃で、遷移モデルを指定して次に何が起こるかを決定します。

遷移の重み付け方法を決定するには注意が必要です。1つの理由として、ノードから発生するすべての遷移は1の確率に達する必要があります。1つの簡単なことは、すべてのノードから他のすべてのノードへの遷移を行うことです。現在のイベントが二度と発生しないことを考えると、アプリオリ。

たとえば、3つのイベントがある場合：

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

確率モデルを他のイベントに均一に再配布するだけで、クリティカルヒットが再び発生しないように遷移モデルを設定できます。

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

編集：以下のコメントが示すように、このモデルは、望ましい動作を得るのに十分複雑ではありません。代わりに、複数の状態を追加する必要がある場合があります！

C＃で作成した実装は次のとおりです。

• 確率に基づいてイベントをアクティブ化する
• これらの確率を調整して、繰り返し発生するイベントの可能性を減らします
• 元の確率から離れすぎない

あなたが私がしていることを見ることができるように、私はいくつかのコメントを追加しました。

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

これがお役に立てば幸いです、コメントでこのコードの改善を提案してください、ありがとう！

mklingenの答えを少し一般化させてください。基本的には、ギャンブラーの誤 implementを実装する必要がありますが、ここではより一般的な方法を提供します。

n確率のある可能性のあるイベントがあるとしましょうp_1, p_2, ..., p_n。イベントは、ときにi起こった、その確率は係数で再スケールばならない0≤a_i≤1/p_i（持っている必要があり、後者は重要であるそうでなければ、1よりも確率も大きく、他のイベントで終わる負の確率、基本的には平均「反かかわらず、」 -イベント。か何かを）通常a_i<1。たとえばa_i=p_i、を選択できます。これは、2回目に発生するイベントの確率が、イベントが連続して正確に2回発生する元の確率であることを意味します。たとえば、2回目のコイントスの確率は1/2ではなく1/4です。一方、a_i>1「運/不運の一撃」を引き起こすことを意味する、いくつかのを持つこともできます。

他のすべてのイベントは、相互に同等の確率を維持する必要がありますb_i。つまり、すべての確率の合計が1になるように、同じ要因ですべてのスケールを変更する必要があります。

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)

これまでのところ、とても簡単です。しかし、別の要件を追加しましょう。2つのイベントのすべての可能なシーケンスを考慮して、そこから抽出された単一イベントの確率が元の確率でなければなりません。

させて

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

は、イベントのj後にイベントが発生する確率を示し、iそれ以外のp_ij≠p_ji場合b_i=b_j (2)（が(1)暗示するa_j = 1 - a_i*p_i + (1-a_i)*p_i/p_j）に注意してください。これは、ベイズの定理が要求するものでもあり、これはまた、

Σ_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)

望みどおり。これa_iが他のすべてを修正することを意味することに注意してください。

次に、この手順を複数回適用した場合、つまり3つ以上のイベントのシーケンスに対して何が起こるかを見てみましょう。3番目のイベントの不正確率の選択には、基本的に2つのオプションがあります。

a）最初のイベントとリグを忘れて、2番目のイベントのみが発生したかのように。

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

これは、たとえばp_jik≠p_ikjほとんどの場合、通常、ベイズに違反することに注意してください。

b）次に発生するイベントの新しい確率を取得する新しい確率として、p_ij（fixedのi）確率を使用しpi_jます。を変更するかどうかはあなた次第ですが、変更されたために新しいものは間違いなく異なることに注意してください。この場合も、同じ確率で発生するすべての順列を要求することにより、おそらく選択が制限されます。どれどれ...pi_jkkai_jbi_jpi_jai_jijk

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

およびその循環順列。それぞれの場合に等しくなければなりません。

私はこれに関する私の継続がしばらく待たなければならないのではないかと心配しています...

最良の選択肢は、ランダムに重み付けされたアイテム選択を使用することだと思います。C＃の実装はここにありますが、他の言語でも簡単に見つけることができます。

アイデアは、選択されるたびにオプションの重量を減らし、選択されないたびにオプションの重量を増やすことです。

たとえば、選択したオプションNumOptions-1の重みを1つ減らし、他のすべてのオプションの重みを1ずつ増やした場合（重みが0未満のアイテムを削除し、0を超えたときにそれらを読み込む）、すべてのオプションがおよそ選択されます長期間にわたって同じ回数ですが、最近選択されたオプションは選択される可能性がはるかに低くなります。

他の多くの回答で示唆されているように、ランダムな順序を使用する場合の問題は、1つを除いてすべてのオプションが選択された後、次に選択されるオプションを100％確実に予測できることです。それはあまりランダムではありません。

私の答えは間違っていて、テストに欠陥がありました。

この設計の欠陥を指摘する議論とコメントのためにこの回答を残していますが、実際のテストは間違っていました。

探しているのは加重ウェイトです。4つの可能な結果のウェイトは、全体の適切なウェイトを維持したまま、以前の結果によってさらに調整（加重）する必要があります。

これを実現する最も簡単な方法は、ロールされる特定の値の重みを減らし、他の重みを増やすことにより、各ロールのすべての重みを変更することです。

例として、Fumble、Miss、Hit、Critの4つのウェイトがあるとしましょう。また、それらに必要な全体の重みは、Fumble = 10％、Miss = 50％、Hit = 30％、Crit = 10％であるとします。

乱数ジェネレーター（RNG）を使用して1から100の値を生成し、その値をこの範囲内の値と比較した場合（1-10ファンブル、11-60ミス、61-90ヒット、91-100クリティカル）、個々のロールを生成しています。

そのロールを行うときに、ロールされた値に基づいてそれらの範囲をすぐに調整する場合、将来のロールに重み付けすることになりますが、他のウェイトを増やすのと同じ合計量だけロールされたウェイトを減らす必要もあります。したがって、上記の例では、ロールされたウェイトを3減らし、他のウェイトをそれぞれ1ずつ増やします。

各ロールに対してこれを行うと、縞模様の可能性が依然としてありますが、各ロールについて、将来のロールが現在のロール以外のものになる可能性が増加するため、それらは大幅に減少します。この効果を大きくすることで、重みをより大きな係数で増加/減少させることにより（たとえば、電流を6減らし、他を2増やす）、ストリークの可能性をさらに減らすことができます。

このアプローチを検証するために簡単なアプリを実行し、それらの重みで32000回繰り返した後、次のグラフを作成します。上のグラフは各ロールでの4つの重みの即時値を示し、下のグラフはそのポイントまでロールアップされた各タイプの結果の合計数を示します。

ご覧のとおり、重みは目的の値を中心にわずかに変動しますが、全体の重みは目的の範囲内にとどまり、最初のさまざまな開始数が落ち着いた後、結果は目的の割合にほぼ完全に適合します。

この例は.NET System.Randomクラスを使用して作成されていることに注意してください。これは実際には優れたRNGの1つではないため、より優れたRNGを使用することでより正確な結果を得ることができます。また、このツールでグラフ化できる最大の結果は32000でしたが、私のテストツールは同じ全体パターンで5億件以上の結果を生成することができました。

本質的にフィルターであることができます。過去nイベントを追跡します。確率は、それらのイベントに適用されるフィルターの一部です。0番目のフィルターはベース確率で、0の場合は回避し、1の場合は失敗します。ベースが25％で、フィルターが各反復の半分に減少するとします。フィルタは次のようになります。

[.25 .125 .0625 .03125] 

ご希望であれば、お気軽に続けてください。このスキームの全体的な確率は、0.25の基本確率よりわずかに高くなります。実際、同じスキームが与えられた場合の確率は（xを実際の確率と呼び、pは確率入力です）：

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

xを解くと、答えがp(1+1/2+1/4+1/8)/(1+p(1/2+1/4+1/8)であることがわかりx=0.38461538461ます。しかし、本当に欲しいのは、xが与えられたときにpを見つけることです。それはより難しい問題であることが判明しました。無限フィルターを想定した場合、問題はx+x*p=2*p、またはになりp=x/(2-x)ます。したがって、フィルターを増やすと、平均して同じ結果が得られる数値pについて解くことができますが、その割合は最近の成功率に依存します。

基本的に、以前の値を使用して、このラウンドの許容しきい値を決定し、ランダムな値を取得します。次に、フィルターを指定して次のランダム値を生成します。

あなた自身が提案したように、これへのアプローチの1つは、重み付きランダムを実装することです。考え方は、重みと結果を変更できる乱数（または結果）ジェネレーターを作成することです。

これがJavaでの実装です。

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

編集 重みを自動的に調整する場合、たとえば、結果がBだったときにAの可能性を増やします。

1. nextOutcome()メソッドの動作を変更し、結果に応じて重みを変更します
2. setWeight()結果に応じて重みを変更するために使用します。