ビンゴガーデンの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日くらいかかった。

これでまた解析を行う。