ビンゴガーデンのPO率計算プログラム

 結果はどこかのwikiにのっていると思うので省略。

なお、実は一つ仕様上のプログラムミスがあるのだが気づくだろうか。

ここからは組と、昇順の重複なしの組み合わせでの番号とを相互変換するプログラムである。例えば{1,2,3,4,5}→1と出て、{1,2,3,4,6}→2と出て、{21,22,23,24,25}=53130(=25C5)と出る。

なんか全然整数にならなさそうな式だが、これは単純にΣをばらしただけなので、一応整数値を返す。興味があれば計算してみるとよいが、非常に面倒である。

toID[a_, b_, c_, d_, e_] := -15275 + (231879 a)/20 - (24265 a^2)/

  24 + (1057 a^3)/24 - (23 a^4)/24 + a^5/120 + (25897 b)/12 - (

  3311 b^2)/24 + (47 b^3)/12 - b^4/24 + (1727 c)/6 - 12 c^2 + c^3/

  6 + (49 d)/2 - d^2/2 + e

manipulate1[x_] := 

  For[i = 1, 

   x > 1/120 (-1518000 + 1650244 i - 137880 i^2 + 5755 i^3 - 120 i^4 +

        i^5), i++, mat[[1]] = i; 

   minus[[1]] = 

    1/120 (-1518000 + 1650244 i - 137880 i^2 + 5755 i^3 - 120 i^4 + 

       i^5)];

manipulate2[x_] := 

  For[i = mat[[1]] + 1, 

   x - minus[[1]] > 

    1/24 (-55200 + 58702 i - 3599 i^2 + 98 i^3 - i^4 - 

       51794 mat[[1]] + 3311 mat[[1]]^2 - 94 mat[[1]]^3 + mat[[1]]^4),

    i++, mat[[2]] = i; 

   minus[[2]] = 

    1/24 (-55200 + 58702 i - 3599 i^2 + 98 i^3 - i^4 - 

       51794 mat[[1]] + 3311 mat[[1]]^2 - 94 mat[[1]]^3 + mat[[1]]^4)];

manipulate3[x_] := 

  For[i = mat[[2]] + 1, 

   x - minus[[1]] - minus[[2]] > 

    1/6 (-1800 + 1874 i - 75 i^2 + i^3 - 1727 mat[[2]] + 

       72 mat[[2]]^2 - mat[[2]]^3), i++, mat[[3]] = i; 

   minus[[3]] = 

    1/6 (-1800 + 1874 i - 75 i^2 + i^3 - 1727 mat[[2]] + 

       72 mat[[2]]^2 - mat[[2]]^3)];

manipulate4[x_] := 

  For[i = mat[[3]] + 1, 

   x - minus[[1]] - minus[[2]] - minus[[3]] > 

    1/2 (-50 + 51 i - i^2 - 49 mat[[3]] + mat[[3]]^2), i++, 

   mat[[4]] = i; 

   minus[[4]] = 1/2 (-50 + 51 i - i^2 - 49 mat[[3]] + mat[[3]]^2)];

manipulate5[x_] := 

  For[i = mat[[4]] + 1, 

   x - minus[[1]] - minus[[2]] - minus[[3]] - minus[[4]] > -1 + i - 

     mat[[4]], i++, mat[[5]] = i];

freepat[x_] := 

  Which[x == 1, free = {1, 11, 13, 19, 23}, x == 2, 

   free = {1, 9, 11, 13, 19}, x == 3, free = {1, 13, 19, 21, 23}, 

   x == 4, free = {1, 11, 13, 19, 24}, x == 5, 

   free = {1, 9, 11, 13, 23}, x == 6, free = {2, 11, 13, 19, 23}, 

   x == 7, free = {1, 9, 11, 13, 24}, x == 8, 

   free = {1, 11, 13, 20, 23}];

rot[list_] := 

  For[r = 1, r <= 5, r++, 

   Which[list[[r]] == 7, newlist[[r]] = 12, list[[r]] == 8, 

    newlist[[r]] = 7, list[[r]] == 9, newlist[[r]] = 8, 

    list[[r]] == 12, newlist[[r]] = 17, list[[r]] == 14, 

    newlist[[r]] = 9,

    list[[r]] == 17, newlist[[r]] = 18, list[[r]] == 18, 

    newlist[[r]] = 19, list[[r]] == 19, newlist[[r]] = 14]];

ringo[x_] := 

  Which[x == 1, {1, 2, 3, 4, 5}, x == 2, {6, 7, 8, 9, 10}, 

   x == 3, {11, 12, 13, 14, 15}, x == 4, {16, 17, 18, 19, 20}, 

   x == 5, {21, 22, 23, 24, 25}, x == 6, {1, 6, 11, 16, 21}, 

   x == 7, {2, 7, 12, 17, 22}, x == 8, {3, 8, 13, 18, 23}, 

   x == 9, {4, 9, 14, 19, 24}, x == 10, {5, 10, 15, 20, 25}, 

   x == 11, {1, 7, 13, 19, 25}, x == 12, {5, 9, 13, 17, 21}];

rest3 = {0, 0, 0}; minusrest3 = {0, 0, 0};

rest31[x_] := 

 For[i = 1, x > 1/6 (-1140 + 1199 i - 60 i^2 + i^3), i++, 

  rest3[[1]] = i; 

  minusrest3[[1]] = 1/6 (-1140 + 1199 i - 60 i^2 + i^3)]; 

rest32[x_] := 

 For[i = rest3[[1]] + 1, 

  x - minusrest3[[1]] > 

   1/2 (-40 + 41 i - i^2 - 39 rest3[[1]] + rest3[[1]]^2), i++, 

  rest3[[2]] = i; 

  minusrest3[[2]] = 

   1/2 (-40 + 41 i - i^2 - 39 rest3[[1]] + rest3[[1]]^2)];

rest33[x_] := 

 For[i = rest3[[2]] + 1, 

  x - minusrest3[[1]] - minusrest3[[2]] > i - rest3[[2]] - 1, i++, 

  rest3[[3]] = i]

ここから実行部。

mat = {0, 0, 0, 0, 0}; pat = 7; minus = {0, 0, 0, 0, 0}; mass = 

 Table[0, 25]; hit = Table[0, 5]; free = Table[0, 5]; For[n = 33751, 

 n <= 53130, n++, newlist = Table[0, 5]; manipulate1[n]; 

 manipulate2[n]; manipulate3[n]; manipulate4[n]; manipulate5[n];

 For[k = 1, k <= 5, k++, hit[[k]] = mat[[k]]]; freepat[pat];

 For[pattern = 1, pattern <= 8, pattern++, bairitu = 1; newlist = hit;

   Which[pattern == 1, newlist = hit, pattern == 2, rot[hit], 

   pattern == 3, rot[hit]; rot[newlist], pattern == 4, rot[hit]; 

   rot[newlist]; rot[newlist], pattern == 5, rot[hit]; rot[newlist]; 

   rot[newlist]; rot[newlist], pattern == 6, rot[hit]; rot[newlist]; 

   rot[newlist]; rot[newlist];

   rot[newlist], pattern == 7, rot[hit]; rot[newlist]; rot[newlist]; 

   rot[newlist]; rot[newlist]; rot[newlist], pattern == 8, rot[hit]; 

   rot[newlist]; rot[newlist]; rot[newlist]; rot[newlist]; 

   rot[newlist]; rot[newlist]]; totalodds = 0; skip = 0; 

  newlist = Sort[newlist];

  b = newlist; 

  If[toID[newlist[[1]], newlist[[2]], newlist[[3]], newlist[[4]], 

     newlist[[5]]] < 

    toID[hit[[1]], hit[[2]], hit[[3]], hit[[4]], hit[[5]]], 

   result[[n]] = 

    result[[toID[newlist[[1]], newlist[[2]], newlist[[3]], 

      newlist[[4]], newlist[[5]]]]];

   For[c = 1, c <= 9 - pattern, c++, taihi = result[[n, 1]]; 

    result[[n, 1]] = result[[n, 2]]; result[[n, 2]] = result[[n, 3]]; 

    result[[n, 3]] = result[[n, 4]]; result[[n, 4]] = result[[n, 5]]; 

    result[[n, 5]] = result[[n, 6]]; result[[n, 6]] = result[[n, 7]]; 

    result[[n, 7]] = result[[n, 8]]; result[[n, 8]] = taihi]; 

   skip = 1; pattern = 8];

  If[toID[newlist[[1]], newlist[[2]], newlist[[3]], newlist[[4]], 

      newlist[[5]]] == 

     toID[hit[[1]], hit[[2]], hit[[3]], hit[[4]], hit[[5]]] && 

    pattern == 2, skip = 1; pattern = 8; 

   result[[n, 2]] = result[[n, 1]];

   result[[n, 3]] = result[[n, 1]];

   result[[n, 4]] = result[[n, 1]]; result[[n, 5]] = result[[n, 1]]; 

   result[[n, 6]] = result[[n, 1]]; result[[n, 7]] = result[[n, 1]]; 

   result[[n, 8]] = result[[n, 1]]]; 

  If[skip == 0, 

   For[z = 1, z <= 1140, z++, newlist = b; bairitu = 1; rest31[z]; 

    rest32[z]; rest33[z];

    A = Table[i, {i, 25}]; 

    A = Delete[

      A, {{newlist[[1]]}, {newlist[[2]]}, {newlist[[3]]}, {newlist[[

         4]]}, {newlist[[5]]}}];

    newlist = 

     Append[Append[Append[newlist, A[[rest3[[1]]]]], A[[rest3[[2]]]]],

       A[[rest3[[3]]]]];

    count = Count[newlist, 13]; freepat[pat]; 

    If[count == 1, 

     free = Append[Append[Append[Append[free, 8], 12], 14], 18]]; 

    mass = Table[0, 25]; 

    For[p = 1, p <= 25, p++, 

     Which[MemberQ[free, p] == True && MemberQ[newlist, p] == True, 

      mass[[p]] = 1; bairitu += 1, 

      MemberQ[free, p] == True || MemberQ[newlist, p] == True, 

      mass[[p]] = 1]];

    bingo = 0;

    If[mass[[1]] == 1 && mass[[2]] == 1 && mass[[3]] == 1 && 

      mass[[4]] == 1 && mass[[5]] == 1, bingo += 1];

    If[mass[[6]] == 1 && mass[[7]] == 1 && mass[[8]] == 1 && 

      mass[[9]] == 1 && mass[[10]] == 1, bingo += 1];

    If[mass[[11]] == 1 && mass[[12]] == 1 && mass[[13]] == 1 && 

      mass[[14]] == 1 && mass[[15]] == 1, bingo += 1];

    If[mass[[16]] == 1 && mass[[17]] == 1 && mass[[18]] == 1 && 

      mass[[19]] == 1 && mass[[20]] == 1, bingo += 1];

    If[mass[[21]] == 1 && mass[[22]] == 1 && mass[[23]] == 1 && 

      mass[[24]] == 1 && mass[[25]] == 1, bingo += 1];

    If[mass[[1]] == 1 && mass[[6]] == 1 && mass[[11]] == 1 && 

      mass[[16]] == 1 && mass[[21]] == 1, bingo += 1];

    If[mass[[2]] == 1 && mass[[7]] == 1 && mass[[12]] == 1 && 

      mass[[17]] == 1 && mass[[22]] == 1, bingo += 1];

    If[mass[[3]] == 1 && mass[[8]] == 1 && mass[[13]] == 1 && 

      mass[[18]] == 1 && mass[[23]] == 1, bingo += 1];

    If[mass[[4]] == 1 && mass[[9]] == 1 && mass[[14]] == 1 && 

      mass[[19]] == 1 && mass[[24]] == 1, bingo += 1];

    If[mass[[5]] == 1 && mass[[10]] == 1 && mass[[15]] == 1 && 

      mass[[20]] == 1 && mass[[25]] == 1, bingo += 1];

    If[mass[[1]] == 1 && mass[[7]] == 1 && mass[[13]] == 1 && 

      mass[[19]] == 1 && mass[[25]] == 1, bingo += 1];

    If[mass[[5]] == 1 && mass[[9]] == 1 && mass[[13]] == 1 && 

      mass[[17]] == 1 && mass[[21]] == 1, bingo += 1];

    odds = 0;

    Which[bingo == 0, odds = 0, bingo == 1, odds = 0.5, bingo == 2, 

     odds = 2.0, bingo == 3, odds = 10.0, bingo == 4, odds = 60.0];

    totalodds += odds*bairitu/1140;

    ]; result[[n, pattern]] = totalodds]

 ]; Print[{n, result[[n]]}]]

誤り探しの答えは

…Which[MemberQ[free, p] == True && MemberQ[newlist, p] == True && p!=13, 

      mass[[p]] = 1; bairitu += 1,…の部分で、これだと中心部分にHITした場合、もともとFREEかつHIT扱いとなるが本家ではそのマスのみはHIT扱いと重ねてもオッズアップにならない。すなわち、赤色の「ただし中心(13マス目)は除く」を加える必要があった。

ビンゴバルーンのPO率計算プログラム

 最初に結果だけ述べると

FREE0個配置　7.6%

FREE1個配置　43.8%　

FREE2個配置　189.9%

FREE3個配置　488.2%

FREE4個配置　1535.8%

である。つまりFREEが1個しかおけない状況が続いているようでは、それはハニーエイトのPO率よりも20%低く、ビンゴガーデンの最低配置を下回るということになる。

ただしシンキングタイムでFREEを2個配置できれば、1.9倍の期待値を得られる。

以下計算プログラム。

toID1[{a_, b_, c_, d_, e_}] := 

  Sum[Binomial[25 - k, 4], {k, a - 1}] + 

   Sum[Binomial[25 - a - k, 3], {k, b - a - 1}] + 

   Sum[Binomial[25 - b - k, 2], {k, c - b - 1}] + 

   Sum[Binomial[25 - c - k, 1], {k, d - c - 1}] + e - d;

toID2[{a_, b_, c_, d_}] := 

 Sum[Binomial[25 - k, 3], {k, a - 1}] + 

  Sum[Binomial[25 - a - k, 2], {k, b - a - 1}] + 

  Sum[Binomial[25 - b - k, 1], {k, c - b - 1}] + d - c; 

sgn0[x_] := 

 Which[x == 1, 16, x == 2, 9, x == 3, 15, x == 4, 21, x == 5, 4, 

  x == 6, 8, x == 7, 14, x == 8, 20, x == 9, 24, x == 10, 1, x == 11, 

  3, x == 12, 7, x == 13, 13, x == 14, 19, x == 15, 23, x == 16, 25, 

  x == 17, 2, x == 18, 6, x == 19, 12, x == 20, 18, x == 21, 22, 

  x == 22, 5, x == 23, 11, x == 24, 17, x == 25, 10]; 

mir0[x_] := 

 Which[x == 1, 1, x == 2, 4, x == 3, 3, x == 4, 2, x == 5, 9, x == 6, 

  8, x == 7, 7, x == 8, 6, x == 9, 5, x == 10, 16, x == 11, 15, 

  x == 12, 14, x == 13, 13, x == 14, 12, x == 15, 11, x == 16, 10, 

  x == 17, 21, x == 18, 20, x == 19, 19, x == 20, 18, x == 21, 17, 

  x == 22, 24, x == 23, 23, x == 24, 22, x == 25, 25]; 

toIDall[{a_, b_, c_, d_, e_}] := 

 Sum[Binomial[25 - k, 4], {k, a - 1}] + 

  Sum[Binomial[25 - a - k, 3], {k, b - a - 1}] + 

  Sum[Binomial[25 - b - k, 2], {k, c - b - 1}] + 

  Sum[Binomial[25 - c - k, 1], {k, d - c - 1}] + e - d;

toID12[{a_, b_, c_, d_, e_, f_, g_, h_, i_, j_, l_, m_}] := 

  Sum[Binomial[25 - k, 11], {k, a - 1}] + 

   Sum[Binomial[25 - a - k, 10], {k, b - a - 1}] + 

   Sum[Binomial[25 - b - k, 9], {k, c - b - 1}] + 

   Sum[Binomial[25 - c - k, 8], {k, d - c - 1}] + 

   Sum[Binomial[25 - d - k, 7], {k, e - d - 1}] + 

   Sum[Binomial[25 - e - k, 6], {k, f - e - 1}] + 

   Sum[Binomial[25 - f - k, 5], {k, g - f - 1}] + 

   Sum[Binomial[25 - g - k, 4], {k, h - g - 1}] + 

   Sum[Binomial[25 - h - k, 3], {k, i - h - 1}] + 

   Sum[Binomial[25 - i - k, 2], {k, j - i - 1}] + 

   Sum[Binomial[25 - j - k, 1], {k, l - j - 1}] + m - l;

toID11[{a_, b_, c_, d_, e_, f_, g_, h_, i_, j_, l_}] := 

 Sum[Binomial[25 - k, 10], {k, a - 1}] + 

  Sum[Binomial[25 - a - k, 9], {k, b - a - 1}] + 

  Sum[Binomial[25 - b - k, 8], {k, c - b - 1}] + 

  Sum[Binomial[25 - c - k, 7], {k, d - c - 1}] + 

  Sum[Binomial[25 - d - k, 6], {k, e - d - 1}] + 

  Sum[Binomial[25 - e - k, 5], {k, f - e - 1}] + 

  Sum[Binomial[25 - f - k, 4], {k, g - f - 1}] + 

  Sum[Binomial[25 - g - k, 3], {k, h - g - 1}] + 

  Sum[Binomial[25 - h - k, 2], {k, i - h - 1}] + 

  Sum[Binomial[25 - i - k, 1], {k, j - i - 1}] + l - j; 

toID10[{a_, b_, c_, d_, e_, f_, g_, h_, i_, j_}] := 

 Sum[Binomial[25 - k, 9], {k, a - 1}] + 

  Sum[Binomial[25 - a - k, 8], {k, b - a - 1}] + 

  Sum[Binomial[25 - b - k, 7], {k, c - b - 1}] + 

  Sum[Binomial[25 - c - k, 6], {k, d - c - 1}] + 

  Sum[Binomial[25 - d - k, 5], {k, e - d - 1}] + 

  Sum[Binomial[25 - e - k, 4], {k, f - e - 1}] + 

  Sum[Binomial[25 - f - k, 3], {k, g - f - 1}] + 

  Sum[Binomial[25 - g - k, 2], {k, h - g - 1}] + 

  Sum[Binomial[25 - h - k, 1], {k, i - h - 1}] + j - i;

toID9[{a_, b_, c_, d_, e_, f_, g_, h_, i_}] := 

  Sum[Binomial[25 - k, 8], {k, a - 1}] + 

   Sum[Binomial[25 - a - k, 7], {k, b - a - 1}] + 

   Sum[Binomial[25 - b - k, 6], {k, c - b - 1}] + 

   Sum[Binomial[25 - c - k, 5], {k, d - c - 1}] + 

   Sum[Binomial[25 - d - k, 4], {k, e - d - 1}] + 

   Sum[Binomial[25 - e - k, 3], {k, f - e - 1}] + 

   Sum[Binomial[25 - f - k, 2], {k, g - f - 1}] + 

   Sum[Binomial[25 - g - k, 1], {k, h - g - 1}] + i - h;

toID8[{a_, b_, c_, d_, e_, f_, g_, h_}] := 

  Sum[Binomial[25 - k, 7], {k, a - 1}] + 

   Sum[Binomial[25 - a - k, 6], {k, b - a - 1}] + 

   Sum[Binomial[25 - b - k, 5], {k, c - b - 1}] + 

   Sum[Binomial[25 - c - k, 4], {k, d - c - 1}] + 

   Sum[Binomial[25 - d - k, 3], {k, e - d - 1}] + 

   Sum[Binomial[25 - e - k, 2], {k, f - e - 1}] + 

   Sum[Binomial[25 - f - k, 1], {k, g - f - 1}] + h - g;

sgn[vec_] := Sort[Table[sgn0[vec[[i]]], {i, 1, Length[vec]}]];

mir[vec_] := Sort[Table[mir0[vec[[i]]], {i, 1, Length[vec]}]];

check[vec_] := {toIDall[mir[vec]], toIDall[mir[sgn[vec]]], 

  toIDall[mir[sgn[sgn[vec]]]], toIDall[mir[sgn[sgn[sgn[vec]]]]], 

  toIDall[sgn[vec]], toIDall[sgn[sgn[vec]]], 

  toIDall[sgn[sgn[sgn[vec]]]]}

ほとんど四則計算などでの処理となっている。toIDというのは{1,2,3,4,5}の組を1番目、{21,22,23,24,25}の組を最後つまり53130(=25C5)番目とするように和と積で表したプログラムである。sgn0やmir0というのは、ビンゴバルーンの盤面が対称面が多いので処理を軽減するために同一ターンを判定するのに使っている。例えば左右対称の関数は{1,2,3,4,5}を入力すると、軸上の1,3は変わらず、2,4はお互いに位置が入れ替わるので昇順に並べると結局同一置換。5のみが軸対象の9に移動するので{1,2,3,4,9}を返す。checkの関数は裏返したり軸対象にしたり回転させたり様々な同一パターンを探るための関数である。

do[i_] := 

  For[l = 1, l <= 1, l++, first5 = first5all[[i]]; dai1 = 0; dai2 = 0;

   prevodds = 0; fly = 0; 

   For[q = 1, q <= 7, q++, 

    If[check[first5all[[i]]][[q]] < i, fly = 1]]; 

   Which[fly == 0, 

    For[j = 1, j <= 12650, j++, set2 = free2[[j]]; 

     rest3 = Subsets[Complement[all, first5], {3}]; odds = 0; 

     For[k = 1, k <= 1140, k++, baloon = Table[0, 25]; 

      cons = Union[first5, rest3[[k]], set2]; 

      Which[Length[cons] == 8, odds += 5*result8[[toID8[cons]]], 

       Length[cons] == 9, odds += 4*result9[[toID9[cons]]], 

       Length[cons] == 10, odds += 3*result10[[toID10[cons]]], 

       Length[cons] == 11, odds += 2*result11[[toID11[cons]]], 

       Length[cons] == 12, odds += result12[[toID12[cons]]]]]; 

     If[odds > prevodds, dai1 = j; dai2 = odds; prevodds = odds]];

    Return[{dai1, dai2/1140}], fly == 1, Return[{0, 0}]]; 

   If[QuotientRemainder[i, 100][[2]] == 0, Print[{dai1, dai2}]]];

ここが本体。各マスへの入賞パターンをすべて把握し、その中で最大のものを記録せよ、というプログラムである。

しかしこれ、簡単そうに見えるが、FREE4個ともなると53130通り?もの5級終了後のパターンにFREEの組み合わせ1140通りを乗じてそのすべてにオッズ処理をしなければならない。

よっていくらPCのプログラミングで素早く計算ができるとは言っても、このブログの過去を見ればわかる通り、CPUを並立処理で100%近くで夜通し延々と毎日稼働させ続けて1か月かかった。

しかしいったんデータさえ手に入れてしまえば、ビンゴバルーンのすべてのパターン、すべてのFREE配置個数に対してもっとも配当の期待値が高額となる配置方法を得られたということになるのでその成果は大きいはず…だがまあ別に使わなくてもええか(本音)FREE4個とか需要ないやろ…。

ビンゴファームのPO率計算プログラム

 先に結果のみ貼り付ける。あとでソースコード…?

緑カード------------------------------------------------------------------------------

FREE5個　PO率60.1%　平均0.623ライン　スーパー0.24%　ハイパー0.03%

FREE6個　PO率65.5%　平均0.678ライン　スーパー0.30%　ハイパー0.03%

FREE7個　PO率71.2%　平均0.735ライン　スーパー0.40%　ハイパー0.03%

FREE8個　PO率77.2%　平均0.791ライン　スーパー0.48%　ハイパー0.04%

FREE9個　PO率83.5%　平均0.853ライン　スーパー0.53%　ハイパー0.05%

FREE10個 PO率90.8%　平均0.929ライン　スーパー0.58%　ハイパー0.07%

FREE11個 PO率97.6%　平均0.998ライン　スーパー0.66%　ハイパー0.07%

FREE12個 PO率104.5% 平均1.065ライン　スーパー0.76%　ハイパー0.08%

FREE13個 PO率111.2% 平均1.135ライン　スーパー0.82%　ハイパー0.08%　

FREE14個 PO率118.9% 平均1.195ライン　スーパー0.89%　ハイパー0.12%

FREE15個 PO率125.4% 平均1.253ライン　スーパー0.96%　ハイパー0.15%

青カード-------------------------------------------------------------------------------

FREE8個　PO率84.7%　平均0.879ライン　スーパー0.57%　ハイパー0.03%

FREE9個　PO率88.8%　平均0.910ライン　スーパー0.67%　ハイパー0.04%

FREE10個 PO率100.1% 平均1.018ライン　スーパー0.80%　ハイパー0.06%

FREE11個 PO率114.3% 平均1.151ライン　スーパー0.97%　ハイパー0.09%

FREE12個 PO率122.5% 平均1.222ライン　スーパー1.04%　ハイパー0.12%

FREE13個 PO率135.8% 平均1.344ライン　スーパー1.24%　ハイパー0.15%

FREE14個 PO率142.3% 平均1.402ライン　スーパー1.36%　ハイパー0.15%

FREE15個 PO率153.8% 平均1.509ライン　スーパー1.66%　ハイパー0.12%

FREE16個 PO率167.7% 平均1.626ライン　スーパー2.07%　ハイパー0.09%

FREE17個 PO率179.1% 平均1.722ライン　スーパー2.35%　ハイパー0.08%

FREE18個 PO率191.2% 平均1.812ライン　スーパー2.63%　ハイパー0.09%

FREE19個 PO率207.2% 平均1.923ライン　スーパー3.06%　ハイパー0.11%

FREE20個 PO率215.0% 平均1.976ライン　スーパー3.28%　ハイパー0.12%

FREE21個 PO率245.4% 平均2.176ライン　スーパー4.01%　ハイパー0.19%

赤カード---------------------------------------------------------------------------------

FREE24個 PO率496.0% 平均3.480ライン　スーパー11.69%　ハイパー0.42%

FREE28個 PO率897.9% 平均5.034ライン　スーパー22.68%　ハイパー0.68%

FREE32個 PO率1098.0%平均5.662ライン　スーパー32.27%　ハイパー0.57%

プログラムの方法としては、例えば空きマスが56個ならば{1,2,3,4…25,1,2,3,4…,25,1,2,3,4,5,6}という配列を作ってそれをランダムに並び替え配置。

あとは入賞の組{1,2,3,4,5,6,7,8…,25}をランダムに並べて最初の8つの要素を入賞番号とする。ここで注意したいのは、この番号を{1,2,3,4,5,6,7,8}で固定しても一見マスの番号配置がランダムなのでこちらもランダムにする必要がないのではないかと思うところだが、それはこのゲーム以外の数字が均等にならぶゲームではそうなのだが、1~6の番号はマスの番号配置の仕方から必ず3個のマスにHITする。8個の番号中、6個が3個マスHITするのは、もともと3個HIT確率が初期で32%、2個HIT確率が初期で68%であることを考えるとあまりに不自然である。これを間違えてしまうと、以前の我のようにやたら高いＰＯ率が出てくる。

緑カードでFREEが12個以上あれば、おおむねメダルは増える傾向にある。

青カードでは場合によってはメダルが減る傾向のカードになることも。

赤カードのFREE32個では平均で10倍以上の返しが期待でき、スーパーラインの成立確率は実に30%越え。ただしハイパーは0.5%程度と低い。

以下は計算プログラム。チェーンボンバーなどに比べるとかなり簡単。

やはりmathematica用。

green = {{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0},

   {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0},

   {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0},

   {0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},

   {0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},

   {0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0},

   {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0},

   {0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},

   {0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0},

   {1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0},

   {0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0},

   {0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0},

   {0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0},

   {0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0},

   {0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0},

   {1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0},

   {0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0}};

blue = {{1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0},

   {0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 

    1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0},

   {0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0},

   {0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0},

   {0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0},

   {0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0},

   {1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0},

   {0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0},

   {1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0},

   {0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0},

   {0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0}};

red = {{1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0},

   {0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0},

   {0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0},

   {0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0},

   {0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0}};

bingo[list_] := 

  For[a = 1, a <= 1, a++, 

   If[list[[1]] == 1 && list[[2]] == 1 && list[[3]] == 1 && 

     list[[4]] == 1, line += 1]; 

   If[list[[5]] == 1 && list[[6]] == 1 && list[[7]] == 1 && 

     list[[8]] == 1, line += 1]; 

   If[list[[9]] == 1 && list[[10]] == 1 && list[[11]] == 1 && 

     list[[12]] == 1, line += 1]; 

   If[list[[13]] == 1 && list[[14]] == 1 && list[[15]] == 1 && 

     list[[16]] == 1, line += 1]; 

   If[list[[1]] == 1 && list[[5]] == 1 && list[[9]] == 1 && 

     list[[13]] == 1, line += 1]; 

   If[list[[2]] == 1 && list[[6]] == 1 && list[[10]] == 1 && 

     list[[14]] == 1, line += 1]; 

   If[list[[3]] == 1 && list[[7]] == 1 && list[[11]] == 1 && 

     list[[15]] == 1, line += 1];

   If[list[[4]] == 1 && list[[8]] == 1 && list[[12]] == 1 && 

     list[[16]] == 1, line += 1]; 

   If[list[[1]] == 1 && list[[6]] == 1 && list[[11]] == 1 && 

     list[[16]] == 1, line += 1]; 

   If[list[[4]] == 1 && list[[7]] == 1 && list[[10]] == 1 && 

     list[[13]] == 1, line += 1]];

superbingoculc[list1_, list2_, list3_, list4_] := 

  For[b = 1, b <= 1, b++, 

   If[list1[[1]] == 1 && list1[[5]] == 1 && list1[[9]] == 1 && 

     list1[[13]] == 1 && list3[[1]] == 1 && list3[[5]] == 1 && 

     list3[[9]] == 1 && list3[[13]] == 1, superbingo += 1]; 

   If[list1[[2]] == 1 && list1[[6]] == 1 && list1[[10]] == 1 && 

     list1[[14]] == 1 && list3[[2]] == 1 && list3[[6]] == 1 && 

     list3[[10]] == 1 && list3[[14]] == 1, superbingo += 1]; 

   If[list1[[3]] == 1 && list1[[7]] == 1 && list1[[11]] == 1 && 

     list1[[15]] == 1 && list3[[3]] == 1 && list3[[7]] == 1 && 

     list3[[11]] == 1 && list3[[15]] == 1, superbingo += 1]; 

   If[list1[[4]] == 1 && list1[[8]] == 1 && list1[[12]] == 1 && 

     list1[[16]] == 1 && list3[[4]] == 1 && list3[[8]] == 1 && 

     list3[[12]] == 1 && list3[[16]] == 1, superbingo += 1]; 

   If[list2[[1]] == 1 && list2[[5]] == 1 && list2[[9]] == 1 && 

     list2[[13]] == 1 && list4[[1]] == 1 && list4[[5]] == 1 && 

     list4[[9]] == 1 && list4[[13]] == 1, superbingo += 1]; 

   If[list2[[2]] == 1 && list2[[6]] == 1 && list2[[10]] == 1 && 

     list2[[14]] == 1 && list4[[2]] == 1 && list4[[6]] == 1 && 

     list4[[10]] == 1 && list4[[14]] == 1, superbingo += 1]; 

   If[list2[[3]] == 1 && list2[[7]] == 1 && list2[[11]] == 1 && 

     list2[[15]] == 1 && list4[[3]] == 1 && list4[[7]] == 1 && 

     list4[[11]] == 1 && list4[[15]] == 1, superbingo += 1]; 

   If[list2[[4]] == 1 && list2[[8]] == 1 && list2[[12]] == 1 && 

     list2[[16]] == 1 && list4[[4]] == 1 && list4[[8]] == 1 && 

     list4[[12]] == 1 && list4[[16]] == 1, superbingo += 1]; 

   If[list1[[1]] == 1 && list1[[2]] == 1 && list1[[3]] == 1 && 

     list1[[4]] == 1 && list2[[1]] == 1 && list2[[2]] == 1 && 

     list2[[3]] == 1 && list2[[4]] == 1, superbingo += 1]; 

   If[list1[[5]] == 1 && list1[[6]] == 1 && list1[[7]] == 1 && 

     list1[[8]] == 1 && list2[[5]] == 1 && list2[[6]] == 1 && 

     list2[[7]] == 1 && list2[[8]] == 1, superbingo += 1]; 

   If[list1[[9]] == 1 && list1[[10]] == 1 && list1[[11]] == 1 && 

     list1[[12]] == 1 && list2[[9]] == 1 && list2[[10]] == 1 && 

     list2[[11]] == 1 && list2[[12]] == 1, superbingo += 1]; 

   If[list1[[13]] == 1 && list1[[14]] == 1 && list1[[15]] == 1 && 

     list1[[16]] == 1 && list2[[13]] == 1 && list2[[14]] == 1 && 

     list2[[15]] == 1 && list2[[16]] == 1, superbingo += 1]; 

   If[list3[[1]] == 1 && list3[[2]] == 1 && list3[[3]] == 1 && 

     list3[[4]] == 1 && list4[[1]] == 1 && list4[[2]] == 1 && 

     list4[[3]] == 1 && list4[[4]] == 1, superbingo += 1]; 

   If[list3[[5]] == 1 && list3[[6]] == 1 && list3[[7]] == 1 && 

     list3[[8]] == 1 && list4[[5]] == 1 && list4[[6]] == 1 && 

     list4[[7]] == 1 && list4[[8]] == 1, superbingo += 1]; 

   If[list3[[9]] == 1 && list3[[10]] == 1 && list3[[11]] == 1 && 

     list3[[12]] == 1 && list4[[9]] == 1 && list4[[10]] == 1 && 

     list4[[11]] == 1 && list4[[12]] == 1, superbingo += 1]; 

   If[list3[[13]] == 1 && list3[[14]] == 1 && list3[[15]] == 1 && 

     list3[[16]] == 1 && list4[[13]] == 1 && list4[[14]] == 1 && 

     list4[[15]] == 1 && list4[[16]] == 1, superbingo += 1]];

hyperbingoculc[list1_, list2_, list3_, list4_] := 

 For[c = 1, c <= 1, c++, 

  If[list1[[1]] == 1 && list1[[6]] == 1 && list1[[11]] == 1 && 

    list1[[16]] == 1 && list4[[1]] == 1 && list4[[6]] == 1 && 

    list4[[11]] == 1 && list4[[16]] == 1, hyperbingo += 1]; 

  If[list2[[4]] == 1 && list2[[7]] == 1 && list2[[10]] == 1 && 

    list2[[13]] == 1 && list3[[4]] == 1 && list3[[7]] == 1 && 

    list3[[10]] == 1 && list3[[13]] == 1, hyperbingo += 1]]

さきにマスがHIT(1)orFREE(1)の状態かそうでない状態(0)を格納したリストがあると仮定して、そのリストのn番目(n=1,2,3,…16)を適宜判定してビンゴ個数をカウントする。

ついで本体。実行部分。

do = 1000000;

For[free = 32, free <= 32, free++, totalodds = 0; totalstar = 0; 

 totalline = 0; totalsuper = 0; totalhyper = 0;

 over50 = over30 = over10 = over5 = over3 = over1 = totalstar = 0; 

 For[times = 1, times <= do, times++, in = RandomSample[Range[25]]; 

  pattern = {0, 0, 0, 0}; 

  While[Count[red[[pattern[[1]]]], 1] + 

     Count[red[[pattern[[2]]]], 1] + Count[red[[pattern[[3]]]], 1] + 

     Count[red[[pattern[[4]]]], 1] != free, 

   pattern = RandomSample[{1, 2, 3, 4, 5}]]; 

  card1 = red[[pattern[[1]]]]; card2 = red[[pattern[[2]]]]; 

  card3 = red[[pattern[[3]]]]; card4 = red[[pattern[[4]]]];

  length = 

   Count[card1, 0] + Count[card2, 0] + Count[card3, 0] + 

    Count[card4, 0];

  Which[length <= 25, numlist = Table[i, {i, 1, length}], 

   26 <= length <= 50, 

   numlist = Join[Table[i, {i, 25}], Table[i, {i, length - 25}]], 

   51 <= length <= 75, 

   numlist = 

    Join[Table[i, {i, 25}], Table[i, {i, 25}], 

     Table[i, {i, 1, length - 50}]]];

  numlist = RandomSample[numlist];

  card = Join[card1, card2, card3, card4]; card0 = card; 

  hole = Position[card0, 0];

  For[i = 1, i <= length, i++, 

   If[numlist[[i]] == in[[1]] || numlist[[i]] == in[[2]] || 

     numlist[[i]] == in[[3]] || numlist[[i]] == in[[4]] || 

     numlist[[i]] == in[[5]] || numlist[[i]] == in[[6]] || 

     numlist[[i]] == in[[7]] || numlist[[i]] == in[[8]], 

    card[[hole[[i, 1]]]] = 1]]; line = 0; superbingo = 0; 

  hyperbingo = 0;

  bingo[card[[1 ;; 16]]]; bingo[card[[17 ;; 32]]]; 

  bingo[card[[33 ;; 48]]]; bingo[card[[49 ;; 64]]];

  superbingoculc[card[[1 ;; 16]], card[[17 ;; 32]], card[[33 ;; 48]], 

   card[[49 ;; 64]]];

  hyperbingoculc[card[[1 ;; 16]], card[[17 ;; 32]], card[[33 ;; 48]], 

   card[[49 ;; 64]]];

  odds = 0; star = 0;

  Which[line == 0, odds = 0, line == 1, odds = 1, line == 2, 

   odds = 1.5, line == 3, odds = 2.5, line == 4, odds = 4, line >= 5, 

   odds = 2*line - 4];

  odds += superbingo*10;

  odds += hyperbingo*50;

  If[odds >= 1, over1 += 1]; If[odds >= 3, over3 += 1]; 

  If[odds >= 5, over5 += 1; star = 1]; 

  If[odds >= 10, over10 += 1; star = 2]; 

  If[odds >= 30, over30 += 1; star = 3]; 

  If[odds >= 50, over50 += 1; star = 5];

  star += superbingo*5;

  star += hyperbingo*10;

  totalodds += odds; totalline += line; totalsuper += superbingo; 

  totalhyper += hyperbingo; totalstar += star;

  If[QuotientRemainder[times, 10000][[2]] == 0, 

   Print[N[{free, times, totalodds/times, totalline/times, 

      totalsuper/times, totalhyper/times, over1, over3, over5, over10,

       over30, over50, totalstar/times}]]]]; 

 result[[free - 19, 1]] = free;

 result[[free - 19, 2]] = 

  N[{totalodds/times, totalline/times, totalsuper/times, 

    totalhyper/times, over1, over3, over5, over10, over30, over50, 

    totalstar/times}]]

ただビンゴをしているかどうかを判定するだけのプログラムなので、構造自体は極めて簡単である。

ただし不確定要素が大きいため、25C8通りの全数え上げはやめている。

このプログラムにより以下の結果を得た。FREEの個数、カードの色別に解析。

チェーンボンバーのPO計算プログラム

mathematica用

oddslist = Table[Table[0, 10000], 250]; counter = 

 Table[Table[0, 1001], 250]; For[game = 1, game <= 250, game++, 

 totalodds = 0; maxodds = 0; 

 For[times = 1, times <= 100, times++,　oddsupinitial = 0; 

  rowodds = {1.5, 0.6, 0.5, 0.5, 0.6, 1.5}; 

  basicrowodds = {1.5, 0.6, 0.5, 0.5, 0.6, 1.5}; maxchain = 1; 

  chain = 1; oddsup1 = RandomInteger[{2, 5}];

  oddsup2 = RandomInteger[{1, 2}]; 

  Which[oddsup2 == 1, oddsup2 = 1, oddsup2 == 2, oddsup2 = 6]; 

  pattern = allpattern[[game]];

  in = {1, 2, 3, 4, 5, 6, 7, 8};

  pattern[[RandomInteger[{31, 54}]]] = 6;

  random = RandomInteger[{1, 10}];

  If[random == 1, pattern[[RandomInteger[{31, 54}]]] = 6];

  syokipattern = pattern; 

  numlist = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 

    17, 18, 19, 20, 21, 22, 23, 24, 25, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 

    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};

  For[i = 1, i <= 100, i++, randomA = RandomInteger[{1, 54}];

   randomB = RandomInteger[{1, 54}];

   taihi = numlist[[randomA]];

   numlist[[randomA]] = numlist[[randomB]];

   numlist[[randomB]] = taihi];

  syokinumlist = numlist;

  For[a = 1, a <= 5, a++, chain = 1; bomblist = Table[0, 54]; 

   erase = Table[0, 54]; k1 = k2 = k3 = k4 = k5 = k6 = 0;

   bombwait1 = {0, 0, 0, 0, 0, 0, 0, 0, 0}; 

   bombwait2 = {0, 0, 0, 0, 0, 0, 0, 0, 0};

   bombwait3 = {0, 0, 0, 0, 0, 0, 0, 0, 0}; 

   bombwait4 = {0, 0, 0, 0, 0, 0, 0, 0, 0};

   bombwait5 = {0, 0, 0, 0, 0, 0, 0, 0, 0}; 

   bombwait6 = {0, 0, 0, 0, 0, 0, 0, 0, 0};

   

   precount = 0; postcount = 1; bombflag = 0; 

   Which[a == 1, 

    For[b = 1, b <= 54, b++, 

     If[numlist[[b]] == in[[1]] || numlist[[b]] == in[[2]] || 

       numlist[[b]] == in[[3]], 

      Which[pattern[[b]] == 6, bombflag = 1; mass = b, 

       pattern[[b]] < 6, numlist[[b]] = 0; pattern[[b]] = 0]]], 

    a == 2, For[b = 1, b <= 54, b++, 

     If[numlist[[b]] == in[[4]] || numlist[[b]] == in[[5]], 

      Which[pattern[[b]] == 6, bombflag = 1; mass = b, 

       pattern[[b]] < 6, numlist[[b]] = 0; pattern[[b]] = 0]]], 

    a == 3, For[b = 1, b <= 54, b++, 

     If[numlist[[b]] == in[[6]], 

      Which[pattern[[b]] == 6, bombflag = 1; mass = b, 

       pattern[[b]] < 6, numlist[[b]] = 0; pattern[[b]] = 0]]], 

    a == 4, For[b = 1, b <= 54, b++, 

     If[numlist[[b]] == in[[7]], 

      Which[pattern[[b]] == 6, bombflag = 1; mass = b, 

       pattern[[b]] < 6, numlist[[b]] = 0; pattern[[b]] = 0]]], 

    a == 5, For[b = 1, b <= 54, b++, 

     If[numlist[[b]] == in[[8]], 

      Which[pattern[[b]] == 6, bombflag = 1; mass = b, 

       pattern[[b]] < 6, numlist[[b]] = 0; pattern[[b]] = 0]]]];

   If[bombflag == 1, b = mass; 

    For[e = 1, e <= 1, e++, bomblist[[b]] = 1; 

     While[precount < postcount, 

      For[c = 1, c <= 54, c++, precount = postcount; 

       For[d = 1, d <= Length[nextlist[b]], d++, 

        If[pattern[[nextlist[b][[d]]]] == 6, 

         bomblist[[nextlist[b][[d]]]] = 1]];

       If[bomblist[[c]] == 1, 

        For[d = 1, d <= Length[nextlist[c]], d++, 

          If[pattern[[nextlist[c][[d]]]] == 6, 

           bomblist[[nextlist[c][[d]]]] = 1]];]]; 

      postcount = Count[bomblist, 1]]; kibaku = Table[0, 54]; 

     For[f = 1, f <= 54, f++, 

      If[bomblist[[f]] == 1, kibaku[[f]] = 1; pattern[[f]] = 0; 

       numlist[[f]] = 0; 

       For[g = 1, g <= Length[nextlist[f]], g++, 

        tonari = nextlist[f][[g]]; pattern[[tonari]] = 0; 

        kibaku[[tonari]] = 1]]];

     For[f = 1, f <= 54, f++, 

      If[kibaku[[f]] == 1 && bomblist[[f]] != 1 && numlist[[f]] > 0, 

       retu = QuotientRemainder[f, 6][[2]]; If[retu == 0, retu = 6];

       Which[retu == 1, k1 += 1; bombwait1[[k1]] = numlist[[f]], 

        retu == 2, k2 += 1; bombwait2[[k2]] = numlist[[f]], retu == 3,

         k3 += 1; bombwait3[[k3]] = numlist[[f]], retu == 4, k4 += 1; 

        bombwait4[[k4]] = numlist[[f]], retu == 5, k5 += 1; 

        bombwait5[[k5]] = numlist[[f]], retu == 6, k6 += 1; 

        bombwait6[[k6]] = numlist[[f]]];]];

     For[h = 1, h <= 54, h++, 

      If[kibaku[[h]] == 1 || bomblist[[h]] == 1, pattern[[h]] = 0; 

       numlist[[h]] = 0]]];];

   chainflag = 0; While[chainflag == 0, chainflag = 1;

    For[i = 48, i >= 1, i--, nullcount = 0; 

     If[pattern[[i]] != 0 , 

      For[j = i + 6, j <= 54, j = j + 6, 

       If[pattern[[j]] == 0, nullcount += 1]]]; 

     If[nullcount > 0, pattern[[i + 6*nullcount]] = pattern[[i]]; 

      numlist[[i + 6*nullcount]] = numlist[[i]]; pattern[[i]] = 0; 

      numlist[[i]] = 0]]; erase = Table[0, 54]; chaincount = 0; 

    For[i = 1, i <= 54, i++, 

     If[pattern[[i]] != 0 && pattern[[i]] < 6, 

      For[j = 1, j <= Length[nextlist[i]], j++, 

       If[pattern[[nextlist[i][[j]]]] == pattern[[i]], 

        erase[[nextlist[i][[j]]]] = 1; chainflag = 0; 

        If[chaincount == 0, chain += 1; chaincount = 1]; 

        If[numlist[[nextlist[i][[j]]]] != 0 && 

          bombcheck[[nextlist[i][[j]]]] == 0, 

         Which[QuotientRemainder[nextlist[i][[j]], 6][[2]] == 1, 

          k1 += 1; bombwait1[[k1]] = numlist[[nextlist[i][[j]]]]; 

          bombcheck[[nextlist[i][[j]]]] = 1, 

          QuotientRemainder[nextlist[i][[j]], 6][[2]] == 2, k2 += 1; 

          bombwait2[[k2]] = numlist[[nextlist[i][[j]]]]; 

          bombcheck[[nextlist[i][[j]]]] = 1, 

          QuotientRemainder[nextlist[i][[j]], 6][[2]] == 3, k3 += 1; 

          bombwait3[[k3]] = numlist[[nextlist[i][[j]]]]; 

          bombcheck[[nextlist[i][[j]]]] = 1, 

          QuotientRemainder[nextlist[i][[j]], 6][[2]] == 4, k4 += 1; 

          bombwait4[[k4]] = numlist[[nextlist[i][[j]]]]; 

          bombcheck[[nextlist[i][[j]]]] = 1, 

          QuotientRemainder[nextlist[i][[j]], 6][[2]] == 5, k5 += 1; 

          bombwait5[[k5]] = numlist[[nextlist[i][[j]]]]; 

          bombcheck[[nextlist[i][[j]]]] = 1, 

          QuotientRemainder[nextlist[i][[j]], 6][[2]] == 0, k6 += 1; 

          bombwait6[[k6]] = numlist[[nextlist[i][[j]]]]; 

          bombcheck[[nextlist[i][[j]]]] = 1]]]]]];

    bombcheck = Table[0, 54];

    

    For[i = 1, i <= 54, i++, 

     If[erase[[i]] == 1, pattern[[i]] = 0; numlist[[i]] = 0]]]; 

   If[chain > maxchain, maxchain = chain];

   doubletimes = 0;

   If[chain >= 5, doubletimes = chain - 4];

   For[n = 1, n <= doubletimes, n++, 

    Which[oddsupinitial == 0, 

     rowodds[[oddsup1]] += basicrowodds[[oddsup1]]; oddsupinitial = 1,

      oddsupinitial == 1, 

     rowodds[[oddsup2]] += basicrowodds[[oddsup2]]]]; 

   bottom = {0, 0, 0, 0, 0, 0};

   k = {k1, k2, k3, k4, k5, k6};

   l = {0, 0, 0, 0, 0, 0};

   bombwait = {bombwait1, bombwait2, bombwait3, bombwait4, bombwait5, 

     bombwait6};

   For[i = 1, i <= 6, i++, l[[i]] = 9; 

    For[j = 48 + i, j >= 1, j = j - 6, 

     Which[pattern[[j]] == 0, bottom[[i]] = l[[i]], pattern[[j]] != 0,

       l[[i]] = l[[i]] - 1]]];

   

   For[i = 1, i <= 6, i++, m = 0; 

    For[j = l[[i]] - k[[i]] + 1, j <= l[[i]], j++, m += 1; 

     pattern[[6*j + i - 6]] = 6; 

     numlist[[6*j + i - 6]] = bombwait[[i, m]]]]]; 

  eraseline = {0, 0, 0, 0, 0, 0};

  For[a = 1, a <= 6, a++, 

   Which[pattern[[48 + a]] == 0, eraseline[[a]] = 1, 

    pattern[[48 + a]] != 0, eraseline[[a]] = 0]];

  odds = Dot[eraseline, rowodds];

  odds = FractionalPart[odds] + IntegerPart[odds];

  If[eraseline == {1, 1, 1, 1, 1, 1}, odds += 50]; totalodds += odds; 

  PO = totalodds/times; oddslist[[game, times]] = odds; 

  If[odds > maxodds, maxodds = odds];

  If[QuotientRemainder[times, 100][[2]] == 0, 

   Print[{game, times, maxchain, odds, PO, maxodds}]];]; 

 For[i1 = 1, i1 <= 1000, i1++, j1 = 0.1*i1 - 0.1; 

  counter[[game, i1]] = Count[oddslist[[game]], j1]]; 

 counter[[game, 1001]] = PO]

ウディタと違って視覚的に見づらいので2日くらいかかった。

これでまた解析を行う。

FREE別配当分布表示(2)

凡例などをつけて、ついにFREE個数別に色付けされた度数分布のグラフが完成した。
分割幅は左から払い戻し率0~50%未満、50~100%未満、…と続き2950~3000%未満、そして最も右の列は3000%以上をまとめている。その理由は、もはや30倍超えといえばほぼほぼ7個ラインのオッズアップ1個がほとんどであり、それ以外の配当は起こりにくいからである。実際、オッズアップ2個で75倍などはまずないし、50倍と4個ライン1個などもこれまた起こりづらい。

悲しいことにグラフがぎざぎざしすぎているが、これもやはり最大値にあわせたグラフにしようか悩んでいる。ただ、実際のアニマロッタでここまで払い戻し率がぶれることはほぼないので無視するか…。現在の設定ではFREE配置可能個数を1~4個が等確率で出現するようにしているため、グラフがかなり大きく揺れ動いている。実際はFREE1個が大半で、ときどきFREE2個、まれにFREE3個、ごくまれにFREE4個なので、特に問題ないはず。
右上を見ると、各FREE個数別の配当分布が分かる。(ほかのグラフで見づらいが)
面白い点は、FREE4個配置でも配当が0~100%というのが存在している点である。
これは、7個ラインの倍率とそのオッズアップ確率がFREEの個数が多いがゆえに高いため、7個ラインの確率がそこまで高くなくても期待値的にそれを狙いにいく、ということが関係している。最適解が7個ラインを成立させにいくため、それが失敗すればもはや払い戻しは皆無に等しい。ただ、もともとのFREEの多さから、まぐれで4個ラインあたりが当選することがあり、それが100％階級あたりの赤色になっている、ということである。

また7個ライン成立確率は、それが成立したときFREE4個である可能性が圧倒的に高い。
ただこれはFREE1~4個を等確率で出しているからその傾向が言えるのであって、これが等確率でないとこの考察は使えないことに注意。例えばFREE3個が10000回で、FREE4個が1回だと、7個ラインの成立確率はFREE3個が圧倒的多数を占めるだろう。だからといってグラフの度数分布から4個での7個ライン成立が少ない、というのは間違いであることが分かるだろう。

では、実際のアニマロッタらしく、FREE1個が80%、FREE2個が15%、FREE3個が4%、FREE4個が1%であったと仮定する。もちろん実際にこの確率ではないが、そうすれば中央のグラフが落ち着いたり実践データに近くなるので。

なんかうまい具合にPO率がちょうど100%くらいになった。
右上のグラフは、黄色と赤の発生確率が足して5%なのでほとんど表示されていない…がこれは仕様なのでしようがない(寒)
念のためにわかりやすい最上段右列の期待値を一応計算してみる。
この配置では、24番と23番に入って配当が3→6倍となる確率が(2/19)*(1/18)=1/171である。よって170/171の確率で300%、1/171の確率で600%より、その期待値は(51000+600)/171=51600/171=301.7…となり、切り捨てなので301%となり確かに期待値の計算は正しく行われている。なお、3,6倍以外の配当は取りえない。

さて次は何をするか…。
面をクリックしてその詳細情報を下のほうに示そうかと考えている。
具体的な案としては、面をクリックするとその面の拡大図が表示されて、番号(マス)にカーソルを合わせると配当分布が表示されたり、7個ラインの成立の確率やその他のラインの成立確率などを表示するシステムである。
後は残り1~3球の抽選で最大、最小のWINを与える組などの表示など。
ただまだどうするかは決定していない。

FREE別配当分布表示(1)

今度は面別の払い戻し率がどうなのかを、なんとなく右上に作成することにする。
これはFREE別に色分けしようと考えている。FREE1個を青、FREE2個を緑にしてそれらを足し合わせた度数分布的なものを作りたい。
形としては、正規分布になることはないが、まあそれになんとなく近そうな形になっていくことを期待している。

これはFREEの個数別の期待度を図る目的で作る。昨日作ったグラフは、各期待値にFREEの個数がラベル付けされていないので、FREE個数別でどれくらいの配当があるかを判断できないという難点がある。そこで色分けしたFREE個数別の度数分布を作ろう、というわけである。これにより、FREE2個がこの期待値付近でこういう具合に分散している、などを視覚的に把握することができる。

さて、それを実装するにはどうすればよいかだが、まず度数分布を示す棒は、とりあえずウディタの線を引くことのできる<LINE>コマンドをやはり使用する。刻み幅はいうまでもなく0.5倍(50%)ごとである。0.5*n(nは0以上)の配当意外になることは決してないからである。逆に0.5nとなるnが存在しないことはもちろんある。例えばn=3など。

とりあえず、度数分布の横軸として0~50%未満、50~100%未満、という具合にしようと思っている。ただこれだとこの最初の2つの階級がずいぶん突出するという問題を排除できないような気がする…。
そういうわけで、縦軸を可変にする必要が出てくる。
もし0~50%未満が100回起これば、その100回分の棒が画面から出ないようにしたい。
そうするとその他の棒も伸び縮みすることになる。

それらを形にしたものが以下。

確かに各階級で最も大きな棒がある一定の位置まで伸びるようにして、それ以外の棒の伸び具合が変わる。何気にこの機能の実装は初めてである。
青はFREE1個の期待値で、緑はFREE2個の期待値を表す。
分かりやすいように凡例と注意事項を右の空きスペースに記述する。

予測・実測PO率グラフ表示

ゲーム数を重ねていき、そのゲームごとの払い戻し率をグラフにする。
具体的には、5,6,7球終了後の期待される払い戻し率と、実際の8球終了後の払い戻し率の推移を見ていこうと、いうわけである。グラフの描画方法などは以前と同じなので特筆すべき点は特にない。

上のグラフから見て取れることは、やはりゲーム終了後の払い戻し率の平均を推定すると、そこまで違いがないということである。
これはつまり、5球終了時点での払い戻し率平均に信頼を持ちやすい、ということである。
その理由の一つに8面の平均をとっている、ということが挙げられ、この時点で1回のゲーム試行は8面のビンゴバルーンの試行の平均をとったものと同等になるため、その分ばらつきが少なくなる、ということがある。
もし100面ビンゴバルーンなどが発生すれば、ある1ゲームでの予想払い戻し率は、相当実際の払い戻し率に近くなるだろう。
なお、この8面のうちひとつでも7個ラインが発生すれば25倍となるので、8面の平均をとれば300%の払い戻し率を確実に超える。
500%を超えているのは、ほぼほぼ7個ラインが2面で成立あるいは7個ラインのオッズアップ(後者のほうが確率が高いと思われる)が発生したものと予想される。

また、上記のグラフは常時FREEを2個配置可能なもとでの試行を行っており、8面でこれを行えばほぼ確実に等倍以上の返りが期待できその半数程度?が2倍以上というものである。

これからわかる通り、ビンゴバルーンにおいてFREEが2個配置可能であれば、平均してBETより多くのWINを得られることが多い、ということになる。その確率がどれくらいかは、また53130個のデータを集めて100%以上のものを53130で割ればよい。
実際に過去のデータ総整理で、FREE2個配置ではたしかPO率が170%程度だったような気がする。

ただ、グラフだけを見ても実際のPOがどれくらいかを数値で判定しづらいので、凡例の右当たりの最近のPO率の平均を各グラフ別に記述しようと思っている。
以前にも述べた通り、凡例の上から順に数字が小さくなっていけば、それは何らかのメダルを増やさせまいとする操作が発生しているということになり、逆もまたしかり。

せっかくなので、FREE1個、FREE2個(率掲載)、3個、4個の場合のグラフものせておく。